<?php
  /**************************************************************************\
  * eGroupWare API - WebDAV                                                  *
  * This file written by Jonathon Sim (for Zeald Ltd) <jsim@free.net.nz>     *
  * Provides methods for manipulating an RFC 2518 DAV repository             *
  * Copyright (C) 2002 Zeald Ltd                                             *
  * -------------------------------------------------------------------------*
  * This library is part of the eGroupWare API                               *
  * http://www.egroupware.org/api                                            *
  * ------------------------------------------------------------------------ *
  * This library is free software; you can redistribute it and/or modify it  *
  * under the terms of the GNU Lesser General Public License as published by *
  * the Free Software Foundation; either version 2.1 of the License,         *
  * or any later version.                                                    *
  * This library is distributed in the hope that it will be useful, but      *
  * WITHOUT ANY WARRANTY; without even the implied warranty of               *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                     *
  * See the GNU Lesser General Public License for more details.              *
  * You should have received a copy of the GNU Lesser General Public License *
  * along with this library; if not, write to the Free Software Foundation,  *
  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA            *
  \**************************************************************************/


  /*At the moment much of this is simply a wrapper around the NET_HTTP_Client class,
  with some other methods for parsing the returned XML etc
  Ideally this will eventually use groupware's inbuilt HTTP class
  */

  define ('DEBUG_DAV_CLIENT', 0);
  define ('DEBUG_DAV_XML', 0);
  define ('DEBUG_CACHE', 0);


##############################################################
# 'Private' classes - these are only used internally and should
# not be used by external code
##############################################################

	/*
	PHP STILL doesnt have any sort of stable DOM parser.  So lets make our
	own XML parser, that parses XML into a tree of arrays (I know, it could do
	something resembling DOM, but it doesnt!)
	*/
	class xml_tree_parser
	{
		var $namespaces;
		var $current_element;
		var $num = 1;
		var $tree = NULL;

		/*
		This is the only end-user function in the class.  Call parse with an XML string, and
		you will get back the tree of 'element' arrays
		*/
		function parse($xml_string)
		{
			$this->xml_parser = xml_parser_create();
			xml_set_element_handler($this->xml_parser,array(&$this,"start_element"),array(&$this,"end_element"));
			xml_set_character_data_handler($this->xml_parser,array(&$this,"parse_data"));

			$this->parser_result=array();
			$this->xml = $xml_string;
			xml_parse($this->xml_parser,$xml_string);
			xml_parser_free($this->xml_parser);
			if (DEBUG_DAV_XML) 
			{
				echo '<pre>'.htmlentities($xml_string).'</pre>';
				echo 'parsed to:' ; $this->print_tree();
			}
			return $this->tree;
		}
		
		//a useful function for debug output - will print the tree after parsing
		function print_tree($element=NULL, $prefix='|', $processed=array()) 
		{	
		
			if ($processed[$element['id']])
			{
				echo '<b>***RECURSION!!***</b></br>';	
				die();
			}
			else
			{
				$processed[$element['id']] = true;
			}
			
			if ($element == NULL)
			{
				$element = $this->tree;
			}
			echo $prefix.$element['namespace'].':'.$element['name'].' '.$element['start'].'->'.$element['end'].'<br>';
			$prefix .= '-->';
			if ($element['data'])
			{
				echo $prefix.$element['data'].'<br>';
			}

			foreach ($element['children'] as $id=>$child)
			{
				$this->print_tree($child, $prefix, &$processed);
			}
			
		}
		
		//called by the xml parser at the start of an element, it creates that elements node in the tree
		function start_element($parser,$name,$attr)
		{
			
			if (preg_match('/(.*):(.*)/', $name, $matches))
			{
				$ns = $this->namespaces[$matches[1]];
				$element = $matches[2];
			}
			else
			{
				$element = $name;
			}
			
			if ($this->tree == NULL) 
			{
				$this->tree = array(
					'namespace'=>$ns,
					'name' => $element,
					'attributes' => $attr,
					'data' => '',
					'children' => array(),
					'parent' => NULL,
					'type' => 'xml_element',
					'id' => $this->num
					);
				$this->current_element = &$this->tree;
			}
			else
			{	
				$parent = &$this->current_element;	
				$parent['children'][$this->num]=array(
					'namespace'=>$ns,
					'name' => $element,
					'attributes' => $attr,
					'data' => '',
					'children' => array(),
					'parent' => &$parent,
					'type' => 'xml_element',
					'id' => $this->num
					);
				$this->current_element = &$parent['children'][$this->num];				
			}
			$this->num++;
			$this->current_element['start'] = xml_get_current_byte_index($parser);
			foreach ($attr as $name => $value)
			{
				if (ereg('^XMLNS:(.*)', $name, $matches) )
				{
					$this->namespaces[$matches[1]] = $value;
				}
			}
		}

		//at the end of an element, stores the start and end positions in the xml stream, and moves up the tree
		function end_element($parser,$name)
		{
			$curr = xml_get_current_byte_index($parser);
			$this->current_element['end'] =strpos($this->xml, '>', $curr);
			$this->current_element = &$this->current_element['parent'];		
			
		}

		//if there is a CDATA element, puts it into the parent elements node
		function parse_data($parser,$data)
		{
			$this->current_element['data']=$data;
		}
		
	}
	
	/*This class uses a bunch of recursive functions to process the DAV XML tree
	digging out the relevent information and putting it into an array
	*/
	class dav_processor
	{
		function dav_processor($xml_string)
		{
			$this->xml = $xml_string;
			$this->dav_parser = new xml_tree_parser();
			$this->tree = $this->dav_parser->parse($xml_string);
			
		}
		
		function process_tree(&$element, &$result_array)
		{
	
			//This lets us mark a node as 'done' and provides protection against infinite loops
			if ($this->processed[$element['id']])
			{
				return $result_array;	
			}
			else
			{
				$this->processed[$element['id']] = true;
			}
			
			if ( $element['namespace'] == 'DAV:')
			{
				if ($element['name'] == 'RESPONSE')
				{
						$result = array( 		
							'size' => 0,
							'getcontenttype' => 'application/octet-stream',
							'is_dir' => 0
					);
					foreach ($element['children'] as $id=>$child)
					{
						$this->process_properties($child, $result);
					}
					$result_array[$result['full_name']] = $result;
					
				}
			}
			// ->recursion
			foreach ($element['children'] as $id=>$child)
			{
				$this->process_tree($child, $result_array);
			}
			return $result_array;
		}
		
		function process_properties($element, &$result_array)
		{	
			if ($this->processed[$element['id']])
			{
				return $result_array;	
			}
			else
			{
				$this->processed[$element['id']] = true;
			}

			if ( $element['namespace'] == 'DAV:')
			{
				switch ($element['name'])
				{
					case 'HREF':
						$string = $element['data'];
						$idx=strrpos($string,SEP);
						if($idx && $idx==strlen($string)-1)
						{
							$this->current_ref=substr($string,0,$idx);
						}
						else
						{
							$this->current_ref=$string;
						}
						$result_array['name']=basename($string);
						$result_array['directory']=dirname($string);
						$result_array['full_name'] = $this->current_ref;
					break;
					case 'SUPPORTEDLOCK':
						if (count($element['children'])) //There are active locks
						{
							$result_array['supported_locks'] = array();
							foreach ($element['children'] as $id=>$child)
							{
								$this->process_properties($child, $result_array['supported_locks']);
							}
						}	
					break;
					case 'LOCKDISCOVERY':
						if (count($element['children'])) //There are active locks
						{
							$result_array['locks'] = array();
							foreach ($element['children'] as $id=>$child)
							{
								$this->process_properties($child, $result_array['locks']);
							}
					}	
					break;
					case 'LOCKENTRY':
						if (count($element['children'])) 
						{
							$result_array[$element['id']] = array();
							foreach ($element['children'] as $id=>$child)
							{
								$this->process_properties($child, $result_array[$element['id']] );
							}
					}	
					break;
					case 'ACTIVELOCK':
						if (count($element['children'])) 
						{
							$result_array[$element['id']] = array();
							foreach ($element['children'] as $id=>$child)
							{
								$this->process_properties($child, $result_array[$element['id']] );
							}
					}	
					break;
					case 'OWNER':
						$result_array['owner'] = array();

						foreach ($element['children'] as $child) 
						{
							$this->process_verbatim($child, &$result_array['owner'][]);							
						}
						
						//print_r($element);die();
						//die();
						$result_array['owner_xml'] = substr($this->xml, $element['start'], $element['end']-$element['start']+1);
						return $result_array; //No need to process this branch further
					break;	
					case 'LOCKTOKEN':
						if (count($element['children'])) 
						{
							
							foreach ($element['children'] as $id=>$child)
							{
								$this->process_properties($child, $tmp_result , $processed);
								$result_array['lock_tokens'][$tmp_result['full_name']] = $tmp_result;
							}
					}	
					break;
					case 'LOCKTYPE':
						$child = end($element['children']);
						if ($child) 
						{
							$this->processed[$child['id']] = true;
							$result_array['locktype'] = $child['name'];
						}
					break;
					case 'LOCKSCOPE':
						$child = end($element['children']);
						if ($child) 
						{
							$this->processed[$child['id']] = true;
							$result_array['lockscope'] = $child['name'];
						}
					break;
					default:
						if (trim($element['data']))
						{
							$result_array[strtolower($element['name'])] = $element['data'];
						}
				}
			}
			else
			{
				if (trim($element['data']))
				{
					$result_array[strtolower($element['name'])] = $element['data'];
				}
			}

			foreach ($element['children'] as $id=>$child)
			{
				$this->process_properties($child, $result_array);
			}
			
			return $result_array;
		}	
		
		function process_verbatim($element, &$result_array)
		{	
			if ($this->processed[$element['id']])
			{
				return $result_array;	
			}
			else
			{
				$this->processed[$element['id']] = true;
			}
			
			foreach ( $element as $key => $value)
			{
				//The parent link is death to naive programmers (eg me) :)
				if (!( $key == 'children' || $key == 'parent') )
				{
					$result_array[$key] = $value;
				}
			}
			$result_array['children'] = array();		
			foreach ($element['children'] as $id=>$child)
			{
				echo 'processing child:';
				$this->process_verbatim($child, $result_array['children']);
			}
			return $result_array;
		}
	}
	
#####################################################
#This is the actual public interface of this class
#####################################################
	class http_dav_client 
	{
		var $attributes=array();
		var $vfs_property_map = array();
		var $cached_props =  array();
		function http_dav_client()
		{
			$this->http_client = CreateObject('phpgwapi.net_http_client');
			$this->set_debug(0);
		}
		
		//TODO:  Get rid of this
		//A quick, temporary debug output function
		function debug($info) {

			if (DEBUG_DAV_CLIENT)
			{
				echo '<b> http_dav_client debug:<em> ';
				if (is_array($info))
				{
					print_r($info);
				}
				else
				{
					echo $info;
				}
				echo '</em></b><br>';
			}
		}
		/*!
		@function glue_url
		@abstract glues a parsed url (ie parsed using PHP's parse_url) back
			together
		@param $url	The parsed url (its an array)
		*/
		
		function glue_url ($url){
			if (!is_array($url))
			{
				return false;
			}
			// scheme
			$uri = (!empty($url['scheme'])) ? $url['scheme'].'://' : '';
			// user & pass
			if (!empty($url['user']))
			{
				$uri .= $url['user'];
				if (!empty($url['pass']))
				{
					$uri .=':'.$url['pass'];
				}
				$uri .='@'; 
			}
			// host 
			$uri .= $url['host'];
			// port 
			$port = (!empty($url['port'])) ? ':'.$url['port'] : '';
			$uri .= $port; 
			// path 
			$uri .= $url['path'];
			// fragment or query
			if (isset($url['fragment']))
			{
				$uri .= '#'.$url['fragment'];
			} elseif (isset($url['query']))
			{
				$uri .= '?'.$url['query'];
			}
			return $uri;
		}	
		
		/*!
		@function encodeurl
		@abstract encodes a url from its "display name" to something the dav server will accept
		@param uri The unencoded uri
		@discussion
			Deals with "url"s which may contain spaces and other unsavoury characters,
			by using appropriate %20s
		*/			
		function encodeurl($uri)
		{
			$parsed_uri =  parse_url($uri);
			if (empty($parsed_uri['scheme']))
			{
				$path = $uri;
			}
			else
			{
				$path = $parsed_uri['path'];
			}
			$fixed_array = array();
			foreach (explode('/', $path) as $name)
			{
				$fixed_array[] = rawurlencode($name);
			}
			$fixed_path = implode('/', $fixed_array);
			if (!empty($parsed_uri['scheme']))
			{
				$parsed_uri['path'] = $fixed_path;
				$newuri = $this->glue_url($parsed_uri);
			}
			else
			{
				$newuri = $fixed_path;
			}			
			return $newuri;
			
		}
		/*!
		@function decodeurl
		@abstract decodes a url to its "display name"
		@param uri The encoded uri
		@discussion
			Deals with "url"s which may contain spaces and other unsavoury characters,
			by using appropriate %20s
		*/		
		function decodeurl($uri)
		{
			$parsed_uri =  parse_url($uri);
			if (empty($parsed_uri['scheme']))
			{
				$path = $uri;
			}
			else
			{
				$path = $parsed_uri['path'];
			}
			$fixed_array = array();
			foreach (explode('/', $path) as $name)
			{
				$fixed_array[]  = rawurldecode($name);
			}
			$fixed_path = implode('/', $fixed_array);
			if (!empty($parsed_uri['scheme']))
			{
				$parsed_uri['path'] = $fixed_path;
				$newuri = $this->glue_url($parsed_uri);
			}
			else
			{
				$newuri = $fixed_path;
			}			
			return $newuri;
			
		}
		/*!
		@function set_attributes
		@abstract Sets the "attribute map"
		@param attributes Attributes to extract "as-is" from the DAV properties
		@param dav_map A mapping of dav_property_name => attribute_name for attributes 
			with different names in DAV and the desired name space.
		@discussion
			This is mainly for use by VFS, where the VFS attributes (eg size) differ
			from the corresponding DAV ones ("getcontentlength")
		*/
		function set_attributes($attributes, $dav_map)
		{
			$this->vfs_property_map = $dav_map;
			$this->attributes = $attributes;
		}
		
		/*!
		@function set_credentials
		@abstract Sets authentication credentials for HTTP AUTH
		@param username The username to connect with
		@param password The password to connect with
		@discussion
			The only supported authentication type is "basic"
		*/
		function set_credentials( $username, $password )
		{
			$this->http_client->setCredentials($username, $password );
		}

		/*!
		@function connect
		@abstract connects to the server
		@param dav_host The host to connect to
		@param dav_port The port to connect to
		@discussion
			If the server requires authentication you will need to set credentials
			with set_credentials first
		*/

		function connect($dav_host,$dav_port)
		{
			$this->dav_host = $dav_host;
			$this->dav_port = $dav_port;
			$this->http_client->addHeader('Host',$this->dav_host);
			$this->http_client->addHeader('Connection','close');
			//$this->http_client->addHeader('transfer-encoding','identity');
	//		$this->http_client->addHeader('Connection','keep-alive');
	//		$this->http_client->addHeader('Keep-Alive','timeout=20, state="Accept,Accept-Language"');
			$this->http_client->addHeader('Accept-Encoding','chunked');
			$this->http_client->setProtocolVersion( '1.1' );
			$this->http_client->addHeader( 'user-agent', 'Mozilla/5.0 (compatible; PHPGroupware dav_client/1; Linux)');
			return $this->http_client->Connect($dav_host,$dav_port);
		}
		function set_debug($debug)
		{
			$this->http_client->setDebug($debug);
		}

		/*!
		@function disconnect
		@abstract disconnect from the server
		@discussion
			When doing HTTP 1.1 we frequently close/reopen the connection
			anyway, so this function needs to be called after any other DAV calls
			(since if they find the connection closed, they just reopen it)
		*/

		function disconnect()
		{
			$this->http_client->Disconnect();
		}
		
		/*!
		@function get_properties
		@abstract a high-level method of getting DAV properties
		@param url The URL to get properties for
		@param scope the 'depth' to recuse subdirectories (default 1)
		@param sorted whether we should sort the rsulting array (default True)
		@result array of file->property arra
		@discussion
			This function performs all the necessary XML parsing etc to convert DAV properties (ie XML nodes)
			into associative arrays of properties - including doing mappings
			from DAV property names to any desired property name format (eg the VFS one)
			This is controlled by the attribute arrays set in the set_attributes function.
		*/
		function get_properties($url,$scope=1){
			$request_id = $url.'//'.$scope.'//'.$sorted; //A unique id for this request (for caching)
			if ($this->cached_props[$request_id])
			{
if (DEBUG_CACHE) echo'Cache hit : cache id:'.$request_id;
				return $this->cached_props[$request_id];
			}
			else if (! $sorted && $this->cached_props[$url.'//'.$scope.'//1'])
			{
if (DEBUG_CACHE) echo ' Cache hit : cache id: '.$request_id;
				return $this->cached_props[$url.'//'.$scope.'//1'];
			}
if (DEBUG_CACHE) 
{
	echo ' <b>Cache miss </b>: cache id: '.$request_id;
/*	echo " cache:<pre>";
	print_r($this->cached_props);
	echo '</pre>';*/
}
	

			if($this->propfind($url,$scope) != 207)
			{
				if($this->propfind($url.'/',$scope) != 207)
				{
					return array();
				}
			}
			$xml_result=$this->http_client->getBody();
			$result_array = array();
			$dav_processor = new dav_processor($xml_result);
			$tmp_list = $dav_processor->process_tree($dav_processor->tree, $result_array);

			foreach($tmp_list as $name=>$item) {
				$fixed_name = $this->decodeurl($name);
				$newitem = $item;
				$newitem['is_dir']= ($item['getcontenttype'] =='httpd/unix-directory' ? 1 : 0);
				$item['directory'] = $this->decodeurl($item['directory']);
				//Since above we sawed off the protocol and host portions of the url, lets readd them.
				if (strlen($item['directory'])) {
					$path = $item['directory'];
					$host = $this->dav_host;
					$newitem['directory'] = $host.$path;
				}

				//Get any extra properties that may share the vfs name
				foreach ($this->attributes as $num=>$vfs_name)
				{
					if ($item[$vfs_name])
					{
						$newitem[$vfs_name] = $item[$vfs_name];
					}
				}

				//Map some DAV properties onto VFS ones.
				foreach ($this->vfs_property_map as $dav_name=>$vfs_name)
				{
					if ($item[$dav_name])
					{
						$newitem[$vfs_name] = $item[$dav_name];
					}
				}
				
				if ($newitem['is_dir'] == 1)
				{
					$newitem['mime_type']='Directory';
				}
				
				$this->debug('<br><br>properties:<br>');
				$this->debug($newitem);
				$newitem['name'] = $this->decodeurl($newitem['name']);
				$result[$fixed_name]=$newitem;
				if ($newitem['is_dir']==1)
				{
					$this->cached_props[$name.'//0//1'] = array($fixed_name=>$newitem);
				}
				else
				{
					$this->cached_props[$name.'//1//1'] = array($fixed_name=>$newitem);
				}
			}
			if ($sorted)
			{
				ksort($result);
			}
			$this->cached_props[$request_id] = $result;
			return $result;
		}
		
		function get($uri)
		{
			$uri = $this->encodeurl($uri);
			return $this->http_client->Get($uri);
		}

		/*!
		@function get_body
		@abstract return the response body
		@result string body content
		@discussion
			invoke it after a Get() call for instance, to retrieve the response
		*/
		function get_body()
		{
			return $this->http_client->getBody();
		}

		/*!
		@function get_headers
		@abstract return the response headers
		@result array headers received from server in the form headername => value
		@discussion
			to be called after a Get() or Head() call
		*/
		function get_headers()
		{
			return $this->http_client->getHeaders();
		}

		/*!
		@function copy
		@abstract PUT is the method to sending a file on the server.
		@param uri the location of the file on the server. dont forget the heading "/"
		@param data the content of the file. binary content accepted
		@result string response status code 201 (Created) if ok
		*/
		function put($uri, $data, $token='')
		{
		$uri = $this->encodeurl($uri);
if (DEBUG_CACHE) echo '<b>cache cleared</b>';
		if (strlen($token)) 
		{
			$this->http_client->addHeader('If', '<'.$uri.'>'.' (<'.$token.'>)');
		}

		$this->cached_props = array();
		$result = $this->http_client->Put($uri, $data);
		$this->http_client->removeHeader('If');
		return $result;
		}
		
		/*!
		@function copy
		@abstract Copy a file -allready on the server- into a new location
		@param srcUri the current file location on the server. dont forget the heading "/"
		@param destUri the destination location on the server. this is *not* a full URL
		@param overwrite boolean - true to overwrite an existing destination - overwrite by default
		@result Returns the HTTP status code
		@discussion
			returns response status code 204 (Unchanged) if ok
		*/
		function copy( $srcUri, $destUri, $overwrite=true, $scope=0, $token='')
		{
			$srcUri = $this->encodeurl($srcUri);
			$destUri = $this->encodeurl($destUri);
if (DEBUG_CACHE) echo '<b>cache cleared</b>';
			if (strlen($token)) 
			{
				$this->http_client->addHeader('If', '<'.$uri.'>'.' (<'.$token.'>)');
			}
			$this->cached_props = array();
			$result = $this->http_client->Copy( $srcUri, $destUri, $overwrite, $scope);
			$this->http_client->removeHeader('If');
			return $result;
		}

		/*!
		@function move
		@abstract Moves a WEBDAV resource on the server
		@param srcUri the current file location on the server. dont forget the heading "/"
		@param destUri the destination location on the server. this is *not* a full URL
		@param overwrite boolean - true to overwrite an existing destination (default is yes)
		@result Returns the HTTP status code
		@discussion
			returns response status code 204 (Unchanged) if ok
		*/
		function move( $srcUri, $destUri, $overwrite=true, $scope=0, $token='' )
		{
			$srcUri = $this->encodeurl($srcUri);
			$destUri = $this->encodeurl($destUri);
if (DEBUG_CACHE) echo '<b>cache cleared</b>';
			if (strlen($token)) 
			{
				$this->http_client->addHeader('If', '<'.$uri.'>'.' (<'.$token.'>)');
			}
			$this->cached_props = array();
			$result = $this->http_client->Move( $srcUri, $destUri, $overwrite, $scope);
			$this->http_client->removeHeader('If');
			return $result;
		}

		/*!
		@function delete
		@abstract Deletes a WEBDAV resource
		@param uri The URI we are deleting
		@result Returns the HTTP status code
		@discussion
			returns response status code 204 (Unchanged) if ok
		*/
		function delete( $uri, $scope=0, $token='')
		{
			$uri = $this->encodeurl($uri);
if (DEBUG_CACHE) echo '<b>cache cleared</b>';
			if (strlen($token)) 
			{
				$this->http_client->addHeader('If', '<'.$uri.'>'.' (<'.$token.'>)');
			}
			
			$this->cached_props = array();
			$result = $this->http_client->Delete( $uri, $scope);
			$this->http_client->removeHeader('If');
			return $result;
		}
		
		/*!
		@function mkcol
		@abstract Creates a WEBDAV collection (AKA a directory)
		@param uri The URI to create
		@result Returns the HTTP status code
		*/
		function mkcol( $uri, $token='' )
		{
			$uri = $this->encodeurl($uri);
if (DEBUG_CACHE) echo '<b>cache cleared</b>';
			if (strlen($token)) 
			{
				$this->http_client->addHeader('If', '<'.$uri.'>'.' (<'.$token.'>)');
			}
			$this->cached_props = array();
			return $this->http_client->MkCol( $uri );
			$this->http_client->removeHeader('If');
		}

		/*!
		@function propfind
		@abstract Queries WEBDAV properties
		@param uri uri of resource whose properties we are changing
		@param scope Specifies how "deep" to search (0=just this file/dir 1=subfiles/dirs etc)
		@result Returns the HTTP status code
		@discussion
			to get the result XML call get_body()
		*/
		function propfind( $uri, $scope=0 )
		{
			$uri = $this->encodeurl($uri);
			return $this->http_client->PropFind( $uri, $scope);
		}
		/*!
		@function proppatch
		@abstract Sets DAV properties
		@param uri uri of resource whose properties we are changing
		@param attributes An array of attributes and values.
		@param namespaces Extra namespace definitions that apply to the properties
		@result Returns the HTTP status code
		@discussion
			To make DAV properties useful it helps to use a well established XML dialect
			such as the "Dublin Core"

		*/
		function proppatch($uri, $attributes,  $namespaces='', $token='')
		{
			$uri = $this->encodeurl($uri);
if (DEBUG_CACHE) echo '<b>cache cleared</b>';
			if (strlen($token)) 
			{
				$this->http_client->addHeader('If', '<'.$uri.'>'.' (<'.$token.'>)');
			}
			$this->cached_props = array();
			//Begin evil nastiness
			$davxml = '<?xml version="1.0" encoding="utf-8" ?>
<D:propertyupdate xmlns:D="DAV:"';

			if ($namespaces)
			{
				$davxml .= ' ' . $namespaces;
			}
			$davxml .= ' >';
			foreach ($attributes as $name => $value)
			{
				$davxml .= '
  <D:set>
    <D:prop>
       <'.$name.'>'.utf8_encode(htmlspecialchars($value)).'</'.$name.'>
    </D:prop>
  </D:set>
';
			}
			$davxml .= '
</D:propertyupdate>';

			if (DEBUG_DAV_XML) {
				echo '<b>send</b><pre>'.htmlentities($davxml).'</pre>';
			}
			$this->http_client->requestBody = $davxml;
			if( $this->http_client->sendCommand( 'PROPPATCH '.$uri.' HTTP/1.1' ) )
			{
				$this->http_client->processReply();
			}

			if (DEBUG_DAV_XML) {
				echo '<b>Recieve</b><pre>'.htmlentities($this->http_client->getBody()).'</pre>';
			}
			$this->http_client->removeHeader('If');
			return $this->http_client->reply;
		}
		
		/*!
		@function unlock
		@abstract unlocks a locked resource on the DAV server
		@param uri uri of the resource we are unlocking
		@param a 'token' for the lock (to get the token, do a propfind)
		@result true if successfull
		@discussion
			Not all DAV servers support locking (its in the RFC, but many common
			DAV servers only implement "DAV class 1" (no locking)
		*/	
				
		function unlock($uri, $token)
		{
			$uri = $this->encodeurl($uri);
if (DEBUG_CACHE) echo '<b>cache cleared</b>';
			$this->cached_props = array();
			$this->http_client->addHeader('Lock-Token', '<'.$token.'>');
			$this->http_client->sendCommand( 'UNLOCK '.$uri.' HTTP/1.1');
			$this->http_client->removeHeader('Lock-Token');
			$this->http_client->processReply();
			if ( $this->http_client->reply  == '204')
			{
				return true;
			}
			else
			{
				$headers = $this->http_client->getHeaders();
				echo $this->http_client->getBody();
				if ($headers['Content-Type'] == 'text/html')
				{
					echo $this->http_client->getBody();
					die();
				}
				else
				{
					return false;
				}
			}
		}
		
		/*!
		@function lock
		@abstract locks a resource on the DAV server
		@param uri uri of the resource we are locking
		@param owner the 'owner' information for the lock (purely informative)
		@param depth the depth to which we lock collections
		@result true if successfull
		@discussion
			Not all DAV servers support locking (its in the RFC, but many common
			DAV servers only implement "DAV class 1" (no locking)
		*/	
		function lock($uri, $owner, $depth=0, $timeout='infinity')
		{
			$uri = $this->encodeurl($uri);
if (DEBUG_CACHE) echo '<b>cache cleared</b>';
			$this->cached_props = array();
			$body = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>
<D:lockinfo xmlns:D='DAV:'>
<D:lockscope><D:exclusive/></D:lockscope>\n<D:locktype><D:write/></D:locktype>
	<D:owner><D:href>$owner</D:href></D:owner>
</D:lockinfo>\n";
		
		$this->http_client->requestBody = utf8_encode( $body );
		$this->http_client->addHeader('Depth', $depth);
		if (! (strtolower(trim($timeout)) == 'infinite'))
		{
			$timeout = 'Second-'.$timeout;
		}
		$this->http_client->addHeader('Timeout', $timeout);
		
		if( $this->http_client->sendCommand( "LOCK $uri HTTP/1.1" ) )
			$this->http_client->processReply();
			$this->http_client->removeHeader('timeout');
			if ( $this->http_client->reply  == '200')
			{
				return true;
			}
			else
			{
				$headers = $this->http_client->getHeaders();
				echo $this->http_client->getBody();
				return false;

			}

		}
		/*!
		@function options
		@abstract determines the optional HTTP features supported by a server
		@param uri uri of the resource we are seeking options for (or * for the whole server)
		@result Returns an array of option values
		@discussion
			Interesting options include "ACCESS" (whether you can read a file) and
			DAV (DAV features)

		*/
		function options($uri)
		{
			$uri = $this->encodeurl($uri);
			if( $this->http_client->sendCommand( 'OPTIONS '.$uri.' HTTP/1.1' ) == '200' )
			{
				$this->http_client->processReply();
				$headers = $this->http_client->getHeaders();
				return $headers;
			}
			else
			{
				return False;
			}
		}
		/*!
		@function dav_features
		@abstract determines the features of a DAV server
		@param uri uri of resource whose properties we are changing
		@result Returns an array of option values
		@discussion
			Likely return codes include NULL (this isnt a dav server!), 1 
			(This is a dav server, supporting all standard DAV features except locking)
			2, (additionally supports locking (should also return 1)) and 
			'version-control' (this server supports versioning extensions for this resource)
		*/		
		function dav_features($uri)
		{
			$uri = $this->encodeurl($uri);
			$options = $this->options($uri);
			$dav_options = $options['DAV'];
			if ($dav_options)
			{
				$features=explode(',', $dav_options);
			}
			else
			{
				$features = NULL;
			}
			return $features;
		}
/**************************************************************
 RFC 3253 DeltaV versioning extensions 
 **************************************************************
 These are 100% untested, and almost certainly dont work yet...
 eventually they will be made to work with subversion...
 */
	
		/*!
		@function report
		@abstract Report is a kind of extended PROPFIND - it queries properties accros versions etc
		@param uri uri of resource whose properties we are changing
		@param report the type of report desired eg DAV:version-tree, DAV:expand-property etc (see http://greenbytes.de/tech/webdav/rfc3253.html#METHOD_REPORT)
		@param namespace any extra XML namespaces needed for the specified properties
		@result Returns an array of option values
		@discussion
			From the relevent RFC:
			"A REPORT request is an extensible mechanism for obtaining information about
			a resource. Unlike a resource property, which has a single value, the value 
			of a report can depend on additional information specified in the REPORT 
			request body and in the REPORT request headers."
		*/		
		function report($uri, $report, $properties,  $namespaces='')
		{
			$uri = $this->encodeurl($uri);
			$davxml = '<?xml version="1.0" encoding="utf-8" ?>
<D:'.$report . 'xmlns:D="DAV:"';
			if ($namespaces)
			{
				$davxml .= ' ' . $namespaces;
			}
			$davxml .= ' >
	<D:prop>';
			foreach($properties as $property) 
			{
				$davxml .= '<'.$property.'/>\n';
			}
			$davxml .= '\t<D:/prop>\n<D:/'.$report.'>';		
			if (DEBUG_DAV_XML) {
				echo '<b>send</b><pre>'.htmlentities($davxml).'</pre>';
			}
			$this->http_client->requestBody = $davxml;
			if( $this->http_client->sendCommand( 'REPORT '.$uri.' HTTP/1.1' ) )
			{
				$this->http_client->processReply();
			}

			if (DEBUG_DAV_XML) {
				echo '<b>Recieve</b><pre>'.htmlentities($this->http_client->getBody()).'</pre>';
			}
			return $this->http_client->reply;		
		}
	
	}