[Tikiwiki-cvs] _mods/features/tikidav/lib/pear/HTTP/WebDAV Server.php,NONE,1.1 _parse_lockinfo.php,NONE,1.1 _parse_propfind.php,NONE,1.1 _parse_proppatch.php,NONE,1.1 dav.txt,NONE,1.1

[<jr...@us...>]

Update of /cvsroot/tikiwiki/_mods/features/tikidav/lib/pear/HTTP/WebDAV
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv31614/features/tikidav/lib/pear/HTTP/WebDAV

Added Files:
	Server.php _parse_lockinfo.php _parse_propfind.php 
	_parse_proppatch.php dav.txt 
Log Message:


--- NEW FILE: Server.php ---
<?php
//
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | li...@ph... so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Hartmut Holzgraefe <hho...@ph...>                       |
// |          Christian Stocker <ch...@bi...>                       |
// +----------------------------------------------------------------------+
//
[...1836 lines suppressed...]
    {
        switch (strtolower($this->_prop_encoding)) {
        case "utf-8":
            return $text;
        case "iso-8859-1":
        case "iso-8859-15":
        case "latin-1":
        default:
            return utf8_encode($text);
        }
    }
} 

  /*
   * Local variables:
   * tab-width: 4
   * c-basic-offset: 4
   * End:
   */
?>
--- NEW FILE: _parse_lockinfo.php ---
<?php
//
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | li...@ph... so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Hartmut Holzgraefe <hho...@ph...>                       |
// |          Christian Stocker <ch...@bi...>                       |
// +----------------------------------------------------------------------+
//
// $Id: _parse_lockinfo.php,v 1.1 2006/01/14 16:05:13 jreyesg Exp $
//

/**
 * helper class for parsing LOCK request bodies
 * 
 * @package HTTP_WebDAV_Server
 * @author Hartmut Holzgraefe <hho...@ph...>
 * @version 0.99.1dev
 */
class _parse_lockinfo 
{
	/**
	 * success state flag
	 *
	 * @var bool
	 * @access public
	 */
	var $success = false;

	/**
	 * lock type, currently only "write"
	 *
	 * @var string
	 * @access public
	 */
	var $locktype = "";

	/**
	 * lock scope, "shared" or "exclusive"
	 *
	 * @var string
	 * @access public
	 */
	var $lockscope = "";

	/**
	 * lock owner information
	 *
	 * @var string
	 * @access public
	 */
	var $owner = "";

	/**
	 * flag that is set during lock owner read
	 *
	 * @var bool
	 * @access private
	 */
	var $collect_owner = false;
	
	/**
	 * constructor
	 *
	 * @param  string  path of stream to read
	 * @access public
	 */
    function _parse_lockinfo($path) 
	{
		// we assume success unless problems occur
		$this->success = true;

		// remember if any input was parsed
		$had_input = false;
		
		// open stream
		$f_in = fopen($path, "r");
		if (!$f_in) {
			$this->success = false;
			return;
		}

		// create namespace aware parser
		$xml_parser = xml_parser_create_ns("UTF-8", " ");

		// set tag and data handlers
		xml_set_element_handler($xml_parser,
								array(&$this, "_startElement"),
								array(&$this, "_endElement"));
		xml_set_character_data_handler($xml_parser,
									   array(&$this, "_data"));

		// we want a case sensitive parser
		xml_parser_set_option($xml_parser,
							  XML_OPTION_CASE_FOLDING, false);

		// parse input
		while($this->success && !feof($f_in)) {
			$line = fgets($f_in);
			if (is_string($line)) {
				$had_input = true;
				$this->success &= xml_parse($xml_parser, $line, false);
			}
		} 

		// finish parsing
		if($had_input) {
			$this->success &= xml_parse($xml_parser, "", true);
		}

		// check if required tags where found
		$this->success &= !empty($this->locktype);
		$this->success &= !empty($this->lockscope);

		// free parser resource
		xml_parser_free($xml_parser);

		// close input stream
		fclose($f_in);		
	}
    

	/**
	 * tag start handler
	 *
	 * @param  resource  parser
	 * @param  string    tag name
	 * @param  array     tag attributes
	 * @return void
	 * @access private
	 */
    function _startElement($parser, $name, $attrs) 
    {
		// namespace handling
        if (strstr($name, " ")) {
            list($ns, $tag) = explode(" ", $name);
        } else {
            $ns = "";
            $tag = $name;
        }
		
  
        if ($this->collect_owner) {
			// everything within the <owner> tag needs to be collected
            $ns_short = "";
            $ns_attr = "";
            if ($ns) {
                if ($ns == "DAV:") {
                    $ns_short = "D:";
                } else {
                    $ns_attr = " xmlns='$ns'";
                }
            }
            $this->owner .= "<$ns_short$tag$ns_attr>";
        } else if ($ns == "DAV:") {
			// parse only the essential tags
            switch ($tag) {
			case "write":
				$this->locktype = $tag;
				break;
			case "exclusive":
			case "shared":
				$this->lockscope = $tag;
				break;
			case "owner":
				$this->collect_owner = true;
				break;
            }
        }
    }
	
	/**
	 * data handler
	 *
	 * @param  resource  parser
	 * @param  string    data
	 * @return void
	 * @access private
	 */
    function _data($parser, $data) 
    {
		// only the <owner> tag has data content
        if ($this->collect_owner) {
            $this->owner .= $data;
        }
    }

	/**
	 * tag end handler
	 *
	 * @param  resource  parser
	 * @param  string    tag name
	 * @return void
	 * @access private
	 */
    function _endElement($parser, $name) 
    {
		// namespace handling
		if (strstr($name, " ")) {
			list($ns, $tag) = explode(" ", $name);
		} else {
			$ns = "";
			$tag = $name;
		}

		// <owner> finished?
		if (($ns == "DAV:") && ($tag == "owner")) {
			$this->collect_owner = false;
		}

		// within <owner> we have to collect everything
		if ($this->collect_owner) {
			$ns_short = "";
			$ns_attr = "";
			if ($ns) {
				if ($ns == "DAV:") {
                    $ns_short = "D:";
				} else {
					$ns_attr = " xmlns='$ns'";
				}
			}
			$this->owner .= "</$ns_short$tag$ns_attr>";
		}
    }
}

?>
--- NEW FILE: _parse_propfind.php ---
<?php
//
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | li...@ph... so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Hartmut Holzgraefe <hho...@ph...>                       |
// |          Christian Stocker <ch...@bi...>                       |
// +----------------------------------------------------------------------+
//
// $Id: _parse_propfind.php,v 1.1 2006/01/14 16:05:13 jreyesg Exp $
//

/**
 * helper class for parsing PROPFIND request bodies
 * 
 * @package HTTP_WebDAV_Server
 * @author Hartmut Holzgraefe <hho...@ph...>
 * @version 0.99.1dev
 */
class _parse_propfind 
{
	/**
	 * success state flag
	 *
	 * @var bool
	 * @access public
	 */
	var $success = false;

	/**
	 * found properties are collected here
	 *
	 * @var array
	 * @access public
	 */
	var $props = false;

	/**
	 * internal tag nesting depth counter
	 *
	 * @var int
	 * @access private
	 */
	var $depth = 0;

	
	/**
	 * constructor
	 *
	 * @access public
	 */
	function _parse_propfind($path) 
	{
		// success state flag
		$this->success = true;
		
		// property storage array
		$this->props = array();

		// internal tag depth counter
		$this->depth = 0;

		// remember if any input was parsed
		$had_input = false;

		// open input stream
		$f_in = fopen($path, "r");
	/*	$content = fread($f_in,500 );
		$gestor = fopen("c:\\log2.txt", "a");
		fwrite($gestor, "\n en parse".$content);
		*/
		if (!$f_in) {
			$this->success = false;
			return;
		}

		// create XML parser
		$xml_parser = xml_parser_create_ns("UTF-8", " ");

		// set tag and data handlers
		xml_set_element_handler($xml_parser,
								array(&$this, "_startElement"),
								array(&$this, "_endElement"));

		// we want a case sensitive parser
		xml_parser_set_option($xml_parser, 
							  XML_OPTION_CASE_FOLDING, false);


		// parse input
		while($this->success && !feof($f_in)) {
			$line = fgets($f_in);
			if (is_string($line)) {
				$had_input = true;
				$this->success &= xml_parse($xml_parser, $line, false);
			}
		} 
		
		// finish parsing
		if($had_input) {
			$this->success &= xml_parse($xml_parser, "", true);
		}

		// free parser
		xml_parser_free($xml_parser);
		
		// close input stream
		fclose($f_in);

		// if no input was parsed it was a request
		if(!count($this->props)) $this->props = "all"; // default
	}
	

	/**
	 * start tag handler
	 * 
	 * @access private
	 * @param  resource  parser
	 * @param  string    tag name
	 * @param  array     tag attributes
	 */
	function _startElement($parser, $name, $attrs) 
	{
		// name space handling
		if (strstr($name, " ")) {
			list($ns, $tag) = explode(" ", $name);
			if ($ns == "")
				$this->success = false;
		} else {
			$ns = "";
			$tag = $name;
		}

		// special tags at level 1: <allprop> and <propname>
		if ($this->depth == 1) {
			if ($tag == "allprop")
				$this->props = "all";

			if ($tag == "propname")
				$this->props = "names";
		}

		// requested properties are found at level 2
		if ($this->depth == 2) {
			$prop = array("name" => $tag);
			if ($ns)
				$prop["xmlns"] = $ns;
			$this->props[] = $prop;
		}

		// increment depth count
		$this->depth++;
	}
	

	/**
	 * end tag handler
	 * 
	 * @access private
	 * @param  resource  parser
	 * @param  string    tag name
	 */
	function _endElement($parser, $name) 
	{
		// here we only need to decrement the depth count
		$this->depth--;
	}
}


?>
--- NEW FILE: _parse_proppatch.php ---
<?php
//
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | li...@ph... so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Hartmut Holzgraefe <hho...@ph...>                       |
// |          Christian Stocker <ch...@bi...>                       |
// +----------------------------------------------------------------------+
//
// $Id: _parse_proppatch.php,v 1.1 2006/01/14 16:05:13 jreyesg Exp $
//

/**
 * helper class for parsing PROPPATCH request bodies
 * 
 * @package HTTP_WebDAV_Server
 * @author Hartmut Holzgraefe <hho...@ph...>
 * @version 0.99.1dev
 */
class _parse_proppatch 
{
    /**
     *
     * 
     * @var
     * @access
     */
    var $success;

    /**
     *
     * 
     * @var
     * @access
     */
    var $props;

    /**
     *
     * 
     * @var
     * @access
     */
    var $depth;

    /**
     *
     * 
     * @var
     * @access
     */
    var $mode;

    /**
     *
     * 
     * @var
     * @access
     */
    var $current;

    /**
     * constructor
     * 
     * @param  string  path of input stream 
     * @access public
     */
    function _parse_proppatch($path) 
    {
        $this->success = true;

        $this->depth = 0;
        $this->props = array();
        $had_input = false;

        $f_in = fopen($path, "r");
        if (!$f_in) {
            $this->success = false;
            return;
        }

        $xml_parser = xml_parser_create_ns("UTF-8", " ");

        xml_set_element_handler($xml_parser,
                                array(&$this, "_startElement"),
                                array(&$this, "_endElement"));

        xml_set_character_data_handler($xml_parser,
                                       array(&$this, "_data"));

        xml_parser_set_option($xml_parser,
                              XML_OPTION_CASE_FOLDING, false);

        while($this->success && !feof($f_in)) {
            $line = fgets($f_in);
            if (is_string($line)) {
                $had_input = true;
                $this->success &= xml_parse($xml_parser, $line, false);
            }
        } 
        
        if($had_input) {
            $this->success &= xml_parse($xml_parser, "", true);
        }

        xml_parser_free($xml_parser);

        fclose($f_in);
    }

    /**
     * tag start handler
     *
     * @param  resource  parser
     * @param  string    tag name
     * @param  array     tag attributes
     * @return void
     * @access private
     */
    function _startElement($parser, $name, $attrs) 
    {
        if (strstr($name, " ")) {
            list($ns, $tag) = explode(" ", $name);
            if ($ns == "")
                $this->success = false;
        } else {
            $ns = "";
            $tag = $name;
        }

        if ($this->depth == 1) {
            $this->mode = $tag;
        } 

        if ($this->depth == 3) {
            $prop = array("name" => $tag);
            $this->current = array("name" => $tag, "ns" => $ns, "status"=> 200);
            if ($this->mode == "set") {
                $this->current["val"] = "";     // default set val
            }
        }

        if ($this->depth >= 4) {
            $this->current["val"] .= "<$tag";
            foreach ($attr as $key => $val) {
                $this->current["val"] .= ' '.$key.'="'.str_replace('"','&quot;', $val).'"';
            }
            $this->current["val"] .= ">";
        }

        

        $this->depth++;
    }

    /**
     * tag end handler
     *
     * @param  resource  parser
     * @param  string    tag name
     * @return void
     * @access private
     */
    function _endElement($parser, $name) 
    {
        if (strstr($name, " ")) {
            list($ns, $tag) = explode(" ", $name);
            if ($ns == "")
                $this->success = false;
        } else {
            $ns = "";
            $tag = $name;
        }

        $this->depth--;

        if ($this->depth >= 4) {
            $this->current["val"] .= "</$tag>";
        }

        if ($this->depth == 3) {
            if (isset($this->current)) {
                $this->props[] = $this->current;
                unset($this->current);
            }
        }
    }

    /**
     * input data handler
     *
     * @param  resource  parser
     * @param  string    data
     * @return void
     * @access private
     */
    function _data($parser, $data) {
        if (isset($this->current)) {
            $this->current["val"] .= $data;
        }
    }
}

?>
--- NEW FILE: dav.txt ---
The HTTP_WebDAV_Server class provides a framwork for the
implementation of customized WebDAV servers that can provide
filesystem like access to almost any kind of hierachically stored
data.

The (abstract) server base class tries to encapsulate as much of
the protocol details as possible. It takes care of the needed WebDAV
header and XML payload parsing and generation (and knows about some
of the problems with common clients and tries hard to work around
them). 

WebDAV itself is an extension to the HTTP protocol. The HTTP
specific parts of it are already taken care of by the web server. Any
data needed by the server class is provided by the PHP SAPI interface
of the server used.

To create a working server from the base class you have to extend and
add methods for the actual access, modification and access control of
your own data.

You may use the included HTTP_WebDAV_Server_Filesystem class as an
example of how to create a working server. This sample implementation
is used for testing the implementation of this package against the
litmus WebDAV compliance test suite.
(litmus is available on http://www.webdav.org/neon/litmus)

The methods you can add in your extended class are mostly named after
the WebDAV specific request methods (using upper case names). Methods
you may implement are:

* GET()				  get a resource from the server  
* HEAD()				get resource headers only from the server  
* PUT()         create or modify a resource on the server
* COPY()        copy a resource on the server
* MOVE()        move a resource on the server
* DELETE()      delete a resource on the server
* MKCOL()       create a new collection
* PROPFIND()    get property data for a resource
* PROPPATCH()   modify property data for a resource
* LOCK()        lock a resource
* UNLOCK()      unlock a locked resource
* checklock()   check whether a resource is locked
* check_auth()  check authentication

You can think of WebDAV resources as files, collections as directories
and properties as filesystem meta data (like size, creation date, ...).

The base class is able identify which of the methods you have
implemented and will create appropriate answers to OPTIONS requests
that ask for the WebDAV standards compliance level and the allowed
HTTP methods for you.

For a minimal working test server you need to implement GET(), PUT()
and PROPFIND() only. 

For a minimal (level 1) standards compliant server you also need to
implement MKCOL(), DELETE(), and PROPPATCH(). The COPY(), MOVE() and
HEAD() methods are emulated using GET(), PUT() and DELETE() if not
implemented, but for performance reasons you should better implement
them yourself. 

For a complete (level 2) RFC2518 compliand server you also have to
provide locking support by implementing LOCK(), UNLOCK() and
checklock().

Authentication is not really part of the WebDAV specification and
should be handled on the HTTP level. You can do so by means of, for
example, .htaccess files or similar services provided by your web
server. But you can also make use of the authentication features
offered by PHP by implementing the check_auth() method.
Using the check_auth() method you can create a dynamic interface
to any authentication system protecting the data you want to serve.


<WARNING> 
  the following reference information may be outdated and/or
  incomplete ...
</WARNING>

bool PROPINFO($options, &$files)

  options[path]  - Resource-Path
  options[depth] - Depth of search requested: "0", "1", or "infinity"
  options[props] - "all", "names", or an arry of requested properties
                   each property array element is either a string 
                   (which implies the default "DAV:" namespace) or
                   an array with the two elements "name" and "xmlns"
                   for the properties name and XML namespace
									                        
  &$files - storage array for property results with the following elements:

          "files" -> array of found properties forresources. elements are:

               "path" -> path of the resource
               "props" -> properties array
							            each property array element is either a string 
												  (which implies the default "DAV:" namespace) or
                          an array with the two elements "name" and "xmlns"
                          for the properties name and XML namespace
            
                          you should at least support the following
                          list of properties from the "DAV:" namespave:

                          - resourcetype:     "collection" oder ""
                          - creationdate:     unix-timestamp
                          - getcontentlength: integer                
                          - getlastmodified:  unix-timestamp

													You may want to add support for these "DAV:"
													properties, too:											

                          - getcontenttype:   mime-type
                          - displayname:      string

                          for a compliant server you also have to be
                          able to return any property from other 
                          namespaces that has been stored using 
                          PROPPATCH
 

  return-value: true / false
  



string MKCOL($option)

  options[path] - path of the new collection to be created

  return-value: string 
                HTTP status and status message, possible values are
                * 201 Success
                * 403 Forbidden
                * 405 Method not allowed
                * 409 Conflict
                * 415 Unsupported media type
                * 507 Insufficient Storage
                (see also RFC2518 8.3.2)




string GET(&$options)

  $options['path']   - path to the requested resource 
  $options['ranges'] - optional array of range specifications for 
                       partial access. range specs are arrays that 
                       consist of either a 'start' and 'end' element
                       (where 'end' can be empty to indicate a request
                       up to the actual end of the resource) or a
                       'last' element to access the last n bytes of
											 a resource without knowing its actual size in
                       advance
                       
  Return-value: true bei Erfolg, false wenn not found

  (TODO: andere stati berücksichtigen)

  Content-Type, Content-Length header müssen von der Methode selbst
  erzeugt werden  (TODO: outdated) 




string PUT($options)

  options[path] - path to the requested resource
  options[content_length] - size of request data in bytes
  options[stream] - a PHP stream providing the input data

  return-value: string 
                HTTP status, possible values are:
								* 201 Created    -> the resource did not exist before
                                    and has been successfully created  
                * 204 No Content -> a previously existing resource has 
                                    successfully been modified
                * 409 Conflict
                ...




string COPY($options)

  options[path]      - path to the resource to be copied
  options[depth]     - "0" or "infinity" (applies only to directories)
  options[overwrite] - true / false
  options[dest]      - path to the destination resource if local
  options[dest_url]  - non-local destination path 

  return-value: string 
                HTTP status, see RFC2518 8.8.5





string MOVE($options)

  options[path]      - path to the resource to be moved
  options[overwrite] - true / false
  options[dest]      - path to the destination resource if local
  options[dest_url]  - non-local destination path 

  return-value: string 
                HTTP status, see RFC2518 8.9.4




string DELETE($options)

  options[path] - path to the resource to be removed

  return-value: string 
                HTTP status, see RFC2518 8.6.2
  




bool check_auth($type, $user, $passwd)

  $type: HTTP-Auth type, i.A. "Basic"
  $user: HTTP Username
  $passwd: HTTP Passwort

  return-value: true bei success, sonst false
  (ToDo: array mit Auth-Type und Realm String zulassen bei fehler)