Version 3.2.3

upload/ips_kernel/sabre/LICENSE

@@ -0,0 +1,28 @@
+Copyright (C) 2007-2011 Rooftop Solutions.
+Copyright (C) 2007-2009 FileMobile inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of the SabreDAV nor the names of its contributors
+      may be used to endorse or promote products derived from this software 
+      without specific prior written permission.
+     
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+    POSSIBILITY OF SUCH DAMAGE.

upload/ips_kernel/sabre/Sabre.autoload.php

@@ -0,0 +1,16 @@
+<?php
+
+/**
+ * SabreDAV's PHP autoloader
+ *
+ * Warning: this file is deprecated. Please use Sabre/autoload.php instead.
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @deprecated
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+
+include dirname(__FILE__) . '/Sabre/autoload.php';/*noLibHook*/

upload/ips_kernel/sabre/Sabre.includes.php

@@ -0,0 +1,127 @@
+<?php
+
+/**
+ * Library include file
+ *
+ * This file contains all includes to the rest of the SabreDAV library
+ * Make sure the lib/ directory is in PHP's include_path
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+
+/* Utilities */
+include 'Sabre/HTTP/Util.php';/*noLibHook*/
+include 'Sabre/HTTP/Response.php';/*noLibHook*/
+include 'Sabre/HTTP/Request.php';/*noLibHook*/
+include 'Sabre/HTTP/AbstractAuth.php';/*noLibHook*/
+include 'Sabre/HTTP/BasicAuth.php';/*noLibHook*/
+include 'Sabre/HTTP/DigestAuth.php';/*noLibHook*/
+include 'Sabre/HTTP/AWSAuth.php';/*noLibHook*/
+
+/* Version */
+include 'Sabre/DAV/Version.php';/*noLibHook*/
+include 'Sabre/HTTP/Version.php';/*noLibHook*/
+
+/* Exceptions */
+include 'Sabre/DAV/Exception.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/BadRequest.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/Conflict.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/FileNotFound.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/InsufficientStorage.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/Locked.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/LockTokenMatchesRequestUri.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/MethodNotAllowed.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/NotImplemented.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/Forbidden.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/PreconditionFailed.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/RequestedRangeNotSatisfiable.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/UnsupportedMediaType.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/NotAuthenticated.php';/*noLibHook*/
+
+include 'Sabre/DAV/Exception/ConflictingLock.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/ReportNotImplemented.php';/*noLibHook*/
+include 'Sabre/DAV/Exception/InvalidResourceType.php';/*noLibHook*/
+
+/* Properties */
+include 'Sabre/DAV/Property.php';/*noLibHook*/
+include 'Sabre/DAV/Property/GetLastModified.php';/*noLibHook*/
+include 'Sabre/DAV/Property/ResourceType.php';/*noLibHook*/
+include 'Sabre/DAV/Property/SupportedLock.php';/*noLibHook*/
+include 'Sabre/DAV/Property/LockDiscovery.php';/*noLibHook*/
+include 'Sabre/DAV/Property/IHref.php';/*noLibHook*/
+include 'Sabre/DAV/Property/Href.php';/*noLibHook*/
+include 'Sabre/DAV/Property/SupportedReportSet.php';/*noLibHook*/
+include 'Sabre/DAV/Property/Response.php';/*noLibHook*/
+include 'Sabre/DAV/Property/Principal.php';/*noLibHook*/
+
+/* Node interfaces */
+include 'Sabre/DAV/INode.php';/*noLibHook*/
+include 'Sabre/DAV/IFile.php';/*noLibHook*/
+include 'Sabre/DAV/ICollection.php';/*noLibHook*/
+include 'Sabre/DAV/IProperties.php';/*noLibHook*/
+include 'Sabre/DAV/ILockable.php';/*noLibHook*/
+include 'Sabre/DAV/IQuota.php';/*noLibHook*/
+include 'Sabre/DAV/IExtendedCollection.php';/*noLibHook*/
+
+/* Node abstract implementations */
+include 'Sabre/DAV/Node.php';/*noLibHook*/
+include 'Sabre/DAV/File.php';/*noLibHook*/
+include 'Sabre/DAV/Directory.php';/*noLibHook*/
+
+/* Utilities */
+include 'Sabre/DAV/SimpleDirectory.php';/*noLibHook*/
+include 'Sabre/DAV/XMLUtil.php';/*noLibHook*/
+include 'Sabre/DAV/URLUtil.php';/*noLibHook*/
+
+/* Filesystem implementation */
+include 'Sabre/DAV/FS/Node.php';/*noLibHook*/
+include 'Sabre/DAV/FS/File.php';/*noLibHook*/
+include 'Sabre/DAV/FS/Directory.php';/*noLibHook*/
+
+/* Advanced filesystem implementation */
+include 'Sabre/DAV/FSExt/Node.php';/*noLibHook*/
+include 'Sabre/DAV/FSExt/File.php';/*noLibHook*/
+include 'Sabre/DAV/FSExt/Directory.php';/*noLibHook*/
+
+/* Trees */
+include 'Sabre/DAV/Tree.php';/*noLibHook*/
+include 'Sabre/DAV/ObjectTree.php';/*noLibHook*/
+include 'Sabre/DAV/Tree/Filesystem.php';/*noLibHook*/
+
+/* Server */
+include 'Sabre/DAV/Server.php';/*noLibHook*/
+include 'Sabre/DAV/ServerPlugin.php';/*noLibHook*/
+
+/* Browser */
+include 'Sabre/DAV/Browser/Plugin.php';/*noLibHook*/
+include 'Sabre/DAV/Browser/MapGetToPropFind.php';/*noLibHook*/
+include 'Sabre/DAV/Browser/GuessContentType.php';/*noLibHook*/
+
+/* Locks */
+include 'Sabre/DAV/Locks/LockInfo.php';/*noLibHook*/
+include 'Sabre/DAV/Locks/Plugin.php';/*noLibHook*/
+include 'Sabre/DAV/Locks/Backend/Abstract.php';/*noLibHook*/
+include 'Sabre/DAV/Locks/Backend/FS.php';/*noLibHook*/
+include 'Sabre/DAV/Locks/Backend/PDO.php';/*noLibHook*/
+
+/* Temporary File Filter plugin */
+include 'Sabre/DAV/TemporaryFileFilterPlugin.php';/*noLibHook*/
+
+/* Authentication plugin */
+include 'Sabre/DAV/Auth/Plugin.php';/*noLibHook*/
+include 'Sabre/DAV/Auth/Backend/Abstract.php';/*noLibHook*/
+include 'Sabre/DAV/Auth/Backend/AbstractDigest.php';/*noLibHook*/
+include 'Sabre/DAV/Auth/Backend/File.php';/*noLibHook*/
+include 'Sabre/DAV/Auth/Backend/PDO.php';/*noLibHook*/
+
+include 'Sabre/DAV/Auth/Principal.php';/*noLibHook*/
+include 'Sabre/DAV/Auth/PrincipalCollection.php';/*noLibHook*/
+
+/* DavMount plugin */
+include 'Sabre/DAV/Mount/Plugin.php';/*noLibHook*/
+
+

upload/ips_kernel/sabre/Sabre/CalDAV/Backend/Abstract.php

@@ -0,0 +1,151 @@
+<?php
+
+/**
+ * Abstract Calendaring backend. Extend this class to create your own backends.
+ * 
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_CalDAV_Backend_Abstract {
+
+    /**
+     * Returns a list of calendars for a principal.
+     *
+     * Every project is an array with the following keys:
+     *  * id, a unique id that will be used by other functions to modify the
+     *    calendar. This can be the same as the uri or a database key.
+     *  * uri, which the basename of the uri with which the calendar is 
+     *    accessed.
+     *  * principalUri. The owner of the calendar. Almost always the same as
+     *    principalUri passed to this method.
+     *
+     * Furthermore it can contain webdav properties in clark notation. A very
+     * common one is '{DAV:}displayname'. 
+     *
+     * @param string $principalUri 
+     * @return array 
+     */
+    abstract function getCalendarsForUser($principalUri);
+
+    /**
+     * Creates a new calendar for a principal.
+     *
+     * If the creation was a success, an id must be returned that can be used to reference
+     * this calendar in other methods, such as updateCalendar.
+     *
+     * This function must return a server-wide unique id that can be used 
+     * later to reference the calendar.
+     *
+     * @param string $principalUri
+     * @param string $calendarUri
+     * @param array $properties
+     * @return string|int 
+     */
+    abstract function createCalendar($principalUri,$calendarUri,array $properties); 
+
+    /**
+     * Updates properties on this node,
+     *
+     * The properties array uses the propertyName in clark-notation as key,
+     * and the array value for the property value. In the case a property
+     * should be deleted, the property value will be null.
+     *
+     * This method must be atomic. If one property cannot be changed, the
+     * entire operation must fail.
+     *
+     * If the operation was successful, true can be returned.
+     * If the operation failed, false can be returned.
+     *
+     * Deletion of a non-existant property is always succesful.
+     *
+     * Lastly, it is optional to return detailed information about any
+     * failures. In this case an array should be returned with the following
+     * structure:
+     *
+     * array(
+     *   403 => array(
+     *      '{DAV:}displayname' => null,
+     *   ),
+     *   424 => array(
+     *      '{DAV:}owner' => null,
+     *   )
+     * )
+     *
+     * In this example it was forbidden to update {DAV:}displayname. 
+     * (403 Forbidden), which in turn also caused {DAV:}owner to fail
+     * (424 Failed Dependency) because the request needs to be atomic.
+     *
+     * @param string $calendarId
+     * @param array $properties
+     * @return bool|array 
+     */
+    public function updateCalendar($calendarId, array $properties) {
+        
+        return false; 
+
+    }
+
+    /**
+     * Delete a calendar and all it's objects 
+     * 
+     * @param string $calendarId 
+     * @return void
+     */
+    abstract function deleteCalendar($calendarId);
+
+    /**
+     * Returns all calendar objects within a calendar object.
+     *
+     * Every item contains an array with the following keys:
+     *   * id - unique identifier which will be used for subsequent updates
+     *   * calendardata - The iCalendar-compatible calnedar data
+     *   * uri - a unique key which will be used to construct the uri. This can be any arbitrary string.
+     *   * lastmodified - a timestamp of the last modification time
+     * 
+     * @param string $calendarId 
+     * @return array 
+     */
+    abstract function getCalendarObjects($calendarId);
+
+    /**
+     * Returns information from a single calendar object, based on it's object uri. 
+     * 
+     * @param string $calendarId 
+     * @param string $objectUri 
+     * @return array 
+     */
+    abstract function getCalendarObject($calendarId,$objectUri);
+
+    /**
+     * Creates a new calendar object. 
+     * 
+     * @param string $calendarId 
+     * @param string $objectUri 
+     * @param string $calendarData 
+     * @return void
+     */
+    abstract function createCalendarObject($calendarId,$objectUri,$calendarData);
+
+    /**
+     * Updates an existing calendarobject, based on it's uri. 
+     * 
+     * @param string $calendarId 
+     * @param string $objectUri 
+     * @param string $calendarData 
+     * @return void
+     */
+    abstract function updateCalendarObject($calendarId,$objectUri,$calendarData);
+
+    /**
+     * Deletes an existing calendar object. 
+     * 
+     * @param string $calendarId 
+     * @param string $objectUri 
+     * @return void
+     */
+    abstract function deleteCalendarObject($calendarId,$objectUri);
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/Backend/PDO.php

@@ -0,0 +1,356 @@
+<?php
+
+/**
+ * PDO CalDAV backend
+ *
+ * This backend is used to store calendar-data in a PDO database, such as 
+ * sqlite or MySQL
+ * 
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_Backend_PDO extends Sabre_CalDAV_Backend_Abstract {
+
+    /**
+     * pdo 
+     * 
+     * @var PDO
+     */
+    private $pdo;
+
+    /**
+     * List of CalDAV properties, and how they map to database fieldnames
+     *
+     * Add your own properties by simply adding on to this array
+     * 
+     * @var array
+     */
+    public $propertyMap = array(
+        '{DAV:}displayname'                          => 'displayname',
+        '{urn:ietf:params:xml:ns:caldav}calendar-description' => 'description',
+        '{urn:ietf:params:xml:ns:caldav}calendar-timezone'    => 'timezone',
+        '{http://apple.com/ns/ical/}calendar-order'  => 'calendarorder',
+        '{http://apple.com/ns/ical/}calendar-color'  => 'calendarcolor',
+    );
+
+    /**
+     * Creates the backend 
+     * 
+     * @param PDO $pdo 
+     */
+    public function __construct(PDO $pdo) {
+
+        $this->pdo = $pdo;
+
+    }
+
+    /**
+     * Returns a list of calendars for a principal.
+     *
+     * Every project is an array with the following keys:
+     *  * id, a unique id that will be used by other functions to modify the
+     *    calendar. This can be the same as the uri or a database key.
+     *  * uri, which the basename of the uri with which the calendar is 
+     *    accessed.
+     *  * principalUri. The owner of the calendar. Almost always the same as
+     *    principalUri passed to this method.
+     *
+     * Furthermore it can contain webdav properties in clark notation. A very
+     * common one is '{DAV:}displayname'. 
+     *
+     * @param string $principalUri 
+     * @return array 
+     */
+    public function getCalendarsForUser($principalUri) {
+
+        $fields = array_values($this->propertyMap);
+        $fields[] = 'id';
+        $fields[] = 'uri';
+        $fields[] = 'ctag';
+        $fields[] = 'components';
+        $fields[] = 'principaluri';
+
+        // Making fields a comma-delimited list 
+        $fields = implode(', ', $fields);
+        $stmt = $this->pdo->prepare("SELECT " . $fields . " FROM calendars WHERE principaluri = ?"); 
+        $stmt->execute(array($principalUri));
+
+        $calendars = array();
+        while($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
+
+            $components = explode(',',$row['components']);
+
+            $calendar = array(
+                'id' => $row['id'],
+                'uri' => $row['uri'],
+                'principaluri' => $row['principaluri'],
+                '{' . Sabre_CalDAV_Plugin::NS_CALENDARSERVER . '}getctag' => $row['ctag']?$row['ctag']:'0',
+                '{' . Sabre_CalDAV_Plugin::NS_CALDAV . '}supported-calendar-component-set' => new Sabre_CalDAV_Property_SupportedCalendarComponentSet($components),
+            );
+        
+
+            foreach($this->propertyMap as $xmlName=>$dbName) {
+                $calendar[$xmlName] = $row[$dbName];
+            }
+
+            $calendars[] = $calendar;
+
+        }
+
+        return $calendars;
+
+    }
+
+    /**
+     * Creates a new calendar for a principal.
+     *
+     * If the creation was a success, an id must be returned that can be used to reference
+     * this calendar in other methods, such as updateCalendar
+     *
+     * @param string $principalUri
+     * @param string $calendarUri
+     * @param array $properties
+     * @return mixed
+     */
+    public function createCalendar($principalUri,$calendarUri, array $properties) {
+
+        $fieldNames = array(
+            'principaluri',
+            'uri',
+            'ctag',
+        );
+        $values = array(
+            ':principaluri' => $principalUri,
+            ':uri'          => $calendarUri,
+            ':ctag'         => 1,
+        );
+
+        // Default value
+        $sccs = '{urn:ietf:params:xml:ns:caldav}supported-calendar-component-set';
+        $fieldNames[] = 'components';
+        if (!isset($properties[$sccs])) {
+            $values[':components'] = 'VEVENT,VTODO';
+        } else {
+            if (!($properties[$sccs] instanceof Sabre_CalDAV_Property_SupportedCalendarComponentSet)) {
+                throw new Sabre_DAV_Exception('The ' . $sccs . ' property must be of type: Sabre_CalDAV_Property_SupportedCalendarComponentSet');
+            }
+            $values[':components'] = implode(',',$properties[$sccs]->getValue());
+        }
+
+        foreach($this->propertyMap as $xmlName=>$dbName) {
+            if (isset($properties[$xmlName])) {
+
+                $myValue = $properties[$xmlName];
+                $values[':' . $dbName] = $properties[$xmlName];
+                $fieldNames[] = $dbName;
+            }
+        }
+
+        $stmt = $this->pdo->prepare("INSERT INTO calendars (".implode(', ', $fieldNames).") VALUES (".implode(', ',array_keys($values)).")");
+        $stmt->execute($values);
+
+        return $this->pdo->lastInsertId();
+
+    }
+
+    /**
+     * Updates a calendars properties 
+     *
+     * The properties array uses the propertyName in clark-notation as key,
+     * and the array value for the property value. In the case a property
+     * should be deleted, the property value will be null.
+     *
+     * This method must be atomic. If one property cannot be changed, the
+     * entire operation must fail.
+     *
+     * If the operation was successful, true can be returned.
+     * If the operation failed, false can be returned.
+     *
+     * Deletion of a non-existant property is always succesful.
+     *
+     * Lastly, it is optional to return detailed information about any
+     * failures. In this case an array should be returned with the following
+     * structure:
+     *
+     * array(
+     *   403 => array(
+     *      '{DAV:}displayname' => null,
+     *   ),
+     *   424 => array(
+     *      '{DAV:}owner' => null,
+     *   )
+     * )
+     *
+     * In this example it was forbidden to update {DAV:}displayname. 
+     * (403 Forbidden), which in turn also caused {DAV:}owner to fail
+     * (424 Failed Dependency) because the request needs to be atomic.
+     *
+     * @param string $calendarId
+     * @param array $properties
+     * @return bool|array 
+     */
+    public function updateCalendar($calendarId, array $properties) {
+
+        $newValues = array();
+        $result = array(
+            200 => array(), // Ok
+            403 => array(), // Forbidden
+            424 => array(), // Failed Dependency
+        );
+
+        $hasError = false;
+
+        foreach($properties as $propertyName=>$propertyValue) {
+
+            // We don't know about this property. 
+            if (!isset($this->propertyMap[$propertyName])) {
+                $hasError = true;
+                $result[403][$propertyName] = null;
+                unset($properties[$propertyName]);
+                continue;
+            }
+
+            $fieldName = $this->propertyMap[$propertyName];
+            $newValues[$fieldName] = $propertyValue;
+                
+        }
+
+        // If there were any errors we need to fail the request
+        if ($hasError) {
+            // Properties has the remaining properties
+            foreach($properties as $propertyName=>$propertyValue) {
+                $result[424][$propertyName] = null;
+            }
+
+            // Removing unused statuscodes for cleanliness
+            foreach($result as $status=>$properties) {
+                if (is_array($properties) && count($properties)===0) unset($result[$status]);
+            }
+
+            return $result;
+
+        }
+
+        // Success
+
+        // Now we're generating the sql query.
+        $valuesSql = array();
+        foreach($newValues as $fieldName=>$value) {
+            $valuesSql[] = $fieldName . ' = ?';
+        }
+        $valuesSql[] = 'ctag = ctag + 1';
+
+        $stmt = $this->pdo->prepare("UPDATE calendars SET " . implode(', ',$valuesSql) . " WHERE id = ?");
+        $newValues['id'] = $calendarId; 
+        $stmt->execute(array_values($newValues));
+
+        return true; 
+
+    }
+
+    /**
+     * Delete a calendar and all it's objects 
+     * 
+     * @param string $calendarId 
+     * @return void
+     */
+    public function deleteCalendar($calendarId) {
+
+        $stmt = $this->pdo->prepare('DELETE FROM calendarobjects WHERE calendarid = ?');
+        $stmt->execute(array($calendarId));
+
+        $stmt = $this->pdo->prepare('DELETE FROM calendars WHERE id = ?');
+        $stmt->execute(array($calendarId));
+
+    }
+
+    /**
+     * Returns all calendar objects within a calendar object.
+     *
+     * Every item contains an array with the following keys:
+     *   * id - unique identifier which will be used for subsequent updates
+     *   * calendardata - The iCalendar-compatible calnedar data
+     *   * uri - a unique key which will be used to construct the uri. This can be any arbitrary string.
+     *   * lastmodified - a timestamp of the last modification time
+     * 
+     * @param string $calendarId 
+     * @return array 
+     */
+    public function getCalendarObjects($calendarId) {
+
+        $stmt = $this->pdo->prepare('SELECT * FROM calendarobjects WHERE calendarid = ?');
+        $stmt->execute(array($calendarId));
+        return $stmt->fetchAll();
+
+    }
+
+    /**
+     * Returns information from a single calendar object, based on it's object uri. 
+     * 
+     * @param string $calendarId 
+     * @param string $objectUri 
+     * @return array 
+     */
+    public function getCalendarObject($calendarId,$objectUri) {
+
+        $stmt = $this->pdo->prepare('SELECT * FROM calendarobjects WHERE calendarid = ? AND uri = ?');
+        $stmt->execute(array($calendarId, $objectUri));
+        return $stmt->fetch();
+
+    }
+
+    /**
+     * Creates a new calendar object. 
+     * 
+     * @param string $calendarId 
+     * @param string $objectUri 
+     * @param string $calendarData 
+     * @return void
+     */
+    public function createCalendarObject($calendarId,$objectUri,$calendarData) {
+
+        $stmt = $this->pdo->prepare('INSERT INTO calendarobjects (calendarid, uri, calendardata, lastmodified) VALUES (?,?,?,?)');
+        $stmt->execute(array($calendarId,$objectUri,$calendarData,time()));
+        $stmt = $this->pdo->prepare('UPDATE calendars SET ctag = ctag + 1 WHERE id = ?');
+        $stmt->execute(array($calendarId));
+
+    }
+
+    /**
+     * Updates an existing calendarobject, based on it's uri. 
+     * 
+     * @param string $calendarId 
+     * @param string $objectUri 
+     * @param string $calendarData 
+     * @return void
+     */
+    public function updateCalendarObject($calendarId,$objectUri,$calendarData) {
+
+        $stmt = $this->pdo->prepare('UPDATE calendarobjects SET calendardata = ?, lastmodified = ? WHERE calendarid = ? AND uri = ?');
+        $stmt->execute(array($calendarData,time(),$calendarId,$objectUri));
+        $stmt = $this->pdo->prepare('UPDATE calendars SET ctag = ctag + 1 WHERE id = ?');
+        $stmt->execute(array($calendarId));
+
+    }
+
+    /**
+     * Deletes an existing calendar object. 
+     * 
+     * @param string $calendarId 
+     * @param string $objectUri 
+     * @return void
+     */
+    public function deleteCalendarObject($calendarId,$objectUri) {
+
+        $stmt = $this->pdo->prepare('DELETE FROM calendarobjects WHERE calendarid = ? AND uri = ?');
+        $stmt->execute(array($calendarId,$objectUri));
+        $stmt = $this->pdo->prepare('UPDATE calendars SET ctag = ctag + 1 WHERE id = ?');
+        $stmt->execute(array($calendarId));
+
+    }
+
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/Backend/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/CalDAV/Calendar.php

@@ -0,0 +1,254 @@
+<?php
+
+/**
+ * This object represents a CalDAV calendar.
+ *
+ * A calendar can contain multiple TODO and or Events. These are represented
+ * as Sabre_CalDAV_CalendarObject objects.
+ * 
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_Calendar implements Sabre_DAV_ICollection, Sabre_DAV_IProperties {
+
+    /**
+     * This is an array with calendar information 
+     * 
+     * @var array 
+     */
+    private $calendarInfo;
+
+    /**
+     * CalDAV backend 
+     * 
+     * @var Sabre_CalDAV_Backend_Abstract 
+     */
+    private $caldavBackend;
+
+    /**
+     * Authentication backend
+     * 
+     * @var Sabre_DAV_Auth_Backend_Abstract 
+     */
+    private $authBackend;
+
+    /**
+     * Constructor 
+     * 
+     * @param Sabre_CalDAV_Backend_Abstract $caldavBackend 
+     * @param array $calendarInfo 
+     * @return void
+     */
+    public function __construct(Sabre_DAV_Auth_Backend_Abstract $authBackend, Sabre_CalDAV_Backend_Abstract $caldavBackend,$calendarInfo) {
+
+        $this->caldavBackend = $caldavBackend;
+        $this->authBackend = $authBackend;
+        $this->calendarInfo = $calendarInfo;
+
+
+    }
+
+    /**
+     * Returns the name of the calendar 
+     * 
+     * @return string 
+     */
+    public function getName() {
+
+        return $this->calendarInfo['uri'];
+
+    }
+
+    /**
+     * Updates properties such as the display name and description 
+     * 
+     * @param array $mutations 
+     * @return array 
+     */
+    public function updateProperties($mutations) {
+
+        if (!$this->hasPrivilege()) throw new Sabre_DAV_Exception_Forbidden('Permission denied to access this calendar');
+        return $this->caldavBackend->updateCalendar($this->calendarInfo['id'],$mutations);
+
+    }
+
+    /**
+     * Returns the list of properties 
+     * 
+     * @param array $properties 
+     * @return array 
+     */
+    public function getProperties($requestedProperties) {
+
+        $response = array();
+
+        if (!$this->hasPrivilege()) return array(); 
+
+        foreach($requestedProperties as $prop) switch($prop) {
+
+            case '{DAV:}resourcetype' : 
+                $response[$prop] =  new Sabre_DAV_Property_ResourceType(array('{urn:ietf:params:xml:ns:caldav}calendar','{DAV:}collection')); 
+                break;
+            case '{urn:ietf:params:xml:ns:caldav}supported-calendar-data' : 
+                $response[$prop] = new Sabre_CalDAV_Property_SupportedCalendarData(); 
+                break;
+            case '{urn:ietf:params:xml:ns:caldav}supported-collation-set' : 
+                $response[$prop] =  new Sabre_CalDAV_Property_SupportedCollationSet(); 
+                break;
+            case '{DAV:}owner' :
+                $response[$prop] = new Sabre_DAV_Property_Principal(Sabre_DAV_Property_Principal::HREF,$this->calendarInfo['principaluri']);
+                break;
+            default : 
+                if (isset($this->calendarInfo[$prop])) $response[$prop] = $this->calendarInfo[$prop];
+                break;
+
+        }
+        return $response;
+
+    }
+
+    /**
+     * Returns a calendar object
+     *
+     * The contained calendar objects are for example Events or Todo's.
+     * 
+     * @param string $name 
+     * @return Sabre_DAV_ICalendarObject 
+     */
+    public function getChild($name) {
+
+        if (!$this->hasPrivilege()) throw new Sabre_DAV_Exception_Forbidden('Permission denied to access this calendar');
+        $obj = $this->caldavBackend->getCalendarObject($this->calendarInfo['id'],$name);
+        if (!$obj) throw new Sabre_DAV_Exception_FileNotFound('Calendar object not found');
+        return new Sabre_CalDAV_CalendarObject($this->caldavBackend,$this->calendarInfo,$obj);
+
+    }
+
+    /**
+     * Returns the full list of calendar objects  
+     * 
+     * @return array 
+     */
+    public function getChildren() {
+
+        if (!$this->hasPrivilege()) throw new Sabre_DAV_Exception_Forbidden('Permission denied to access this calendar');
+        $objs = $this->caldavBackend->getCalendarObjects($this->calendarInfo['id']);
+        $children = array();
+        foreach($objs as $obj) {
+            $children[] = new Sabre_CalDAV_CalendarObject($this->caldavBackend,$this->calendarInfo,$obj);
+        }
+        return $children;
+
+    }
+
+    /**
+     * Checks if a child-node exists. 
+     * 
+     * @param string $name 
+     * @return bool 
+     */
+    public function childExists($name) {
+
+        if (!$this->hasPrivilege()) throw new Sabre_DAV_Exception_Forbidden('Permission denied to access this calendar');
+        $obj = $this->caldavBackend->getCalendarObject($this->calendarInfo['id'],$name);
+        if (!$obj) 
+            return false;
+        else 
+            return true;
+
+    }
+
+    /**
+     * Creates a new directory
+     *
+     * We actually block this, as subdirectories are not allowed in calendars.
+     * 
+     * @param string $name 
+     * @return void
+     */
+    public function createDirectory($name) {
+
+        if (!$this->hasPrivilege()) throw new Sabre_DAV_Exception_Forbidden('Permission denied to access this calendar');
+        throw new Sabre_DAV_Exception_MethodNotAllowed('Creating collections in calendar objects is not allowed');
+
+    }
+
+    /**
+     * Creates a new file
+     *
+     * The contents of the new file must be a valid ICalendar string.
+     * 
+     * @param string $name 
+     * @param resource $calendarData 
+     * @return void
+     */
+    public function createFile($name,$calendarData = null) {
+
+        if (!$this->hasPrivilege()) throw new Sabre_DAV_Exception_Forbidden('Permission denied to access this calendar');
+        $calendarData = stream_get_contents($calendarData);
+
+        $supportedComponents = $this->calendarInfo['{' . Sabre_CalDAV_Plugin::NS_CALDAV . '}supported-calendar-component-set']->getValue();
+        Sabre_CalDAV_ICalendarUtil::validateICalendarObject($calendarData, $supportedComponents);
+
+        $this->caldavBackend->createCalendarObject($this->calendarInfo['id'],$name,$calendarData);
+
+    }
+
+    /**
+     * Deletes the calendar. 
+     * 
+     * @return void
+     */
+    public function delete() {
+
+        if (!$this->hasPrivilege()) throw new Sabre_DAV_Exception_Forbidden('Permission denied to access this calendar');
+        $this->caldavBackend->deleteCalendar($this->calendarInfo['id']);
+
+    }
+
+    /**
+     * Renames the calendar. Note that most calendars use the 
+     * {DAV:}displayname to display a name to display a name. 
+     * 
+     * @param string $newName 
+     * @return void
+     */
+    public function setName($newName) {
+
+        if (!$this->hasPrivilege()) throw new Sabre_DAV_Exception_Forbidden('Permission denied to access this calendar');
+        throw new Sabre_DAV_Exception_MethodNotAllowed('Renaming calendars is not yet supported');
+
+    }
+
+    /**
+     * Returns the last modification date as a unix timestamp.
+     * 
+     * @return void
+     */
+    public function getLastModified() {
+
+        return null;
+
+    }
+
+    /**
+     * Check if user has access.
+     *
+     * This method does a check if the currently logged in user
+     * has permission to access this calendar. There is only read-write
+     * access, so you're in or you're out.
+     * 
+     * @return bool 
+     */
+    protected function hasPrivilege() {
+
+        if (!$user = $this->authBackend->getCurrentUser()) return false;
+        if ($user['uri']!==$this->calendarInfo['principaluri']) return false;
+        return true;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/CalendarObject.php

@@ -0,0 +1,176 @@
+<?php
+
+/**
+ * The CalendarObject represents a single VEVENT or VTODO within a Calendar. 
+ * 
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_CalendarObject extends Sabre_DAV_File implements Sabre_DAV_IProperties {
+
+    /**
+     * Sabre_CalDAV_Backend_Abstract 
+     * 
+     * @var array 
+     */
+    private $caldavBackend;
+
+    /**
+     * Array with information about this CalendarObject 
+     * 
+     * @var array 
+     */
+    private $objectData;
+
+    /**
+     * Array with information about the containing calendar
+     * 
+     * @var array 
+     */
+    private $calendarInfo;
+
+    /**
+     * Constructor 
+     * 
+     * @param Sabre_CalDAV_Backend_Abstract $caldavBackend 
+     * @param array $objectData 
+     */
+    public function __construct(Sabre_CalDAV_Backend_Abstract $caldavBackend,$calendarInfo,$objectData) {
+
+        $this->caldavBackend = $caldavBackend;
+        $this->calendarInfo = $calendarInfo;
+        $this->objectData = $objectData;
+
+    }
+
+    /**
+     * Returns the uri for this object 
+     * 
+     * @return string 
+     */
+    public function getName() {
+
+        return $this->objectData['uri'];
+
+    }
+
+    /**
+     * Returns the ICalendar-formatted object 
+     * 
+     * @return string 
+     */
+    public function get() {
+
+        return $this->objectData['calendardata'];
+
+    }
+
+    /**
+     * Updates the ICalendar-formatted object 
+     * 
+     * @param string $calendarData 
+     * @return void 
+     */
+    public function put($calendarData) {
+
+        if (is_resource($calendarData))
+            $calendarData = stream_get_contents($calendarData);
+
+        $supportedComponents = $this->calendarInfo['{' . Sabre_CalDAV_Plugin::NS_CALDAV . '}supported-calendar-component-set']->getValue();
+        Sabre_CalDAV_ICalendarUtil::validateICalendarObject($calendarData, $supportedComponents);
+
+        $this->caldavBackend->updateCalendarObject($this->calendarInfo['id'],$this->objectData['uri'],$calendarData);
+        $this->objectData['calendardata'] = $calendarData;
+
+    }
+
+    /**
+     * Deletes the calendar object 
+     * 
+     * @return void
+     */
+    public function delete() {
+
+        $this->caldavBackend->deleteCalendarObject($this->calendarInfo['id'],$this->objectData['uri']);
+
+    }
+
+    /**
+     * Returns the mime content-type 
+     * 
+     * @return string 
+     */
+    public function getContentType() {
+
+        return 'text/calendar';
+
+    }
+
+    /**
+     * Returns an ETag for this object.
+     *
+     * The ETag is an arbritrary string, but MUST be surrounded by double-quotes.
+     * 
+     * @return string 
+     */
+    public function getETag() {
+
+        return '"' . md5($this->objectData['calendardata']). '"';
+
+    }
+
+    /**
+     * Returns the list of properties for this object
+     * 
+     * @param array $properties 
+     * @return array 
+     */
+    public function getProperties($properties) {
+
+        $response = array();
+        if (in_array('{urn:ietf:params:xml:ns:caldav}calendar-data',$properties)) 
+            $response['{urn:ietf:params:xml:ns:caldav}calendar-data'] = str_replace("\r","",$this->objectData['calendardata']);
+       
+
+        return $response;
+
+    }
+
+    /**
+     * Updates properties
+     * 
+     * @param array $properties
+     * @return array 
+     */
+    public function updateProperties($properties) {
+
+        return false;
+
+    }
+
+    /**
+     * Returns the last modification date as a unix timestamp
+     * 
+     * @return time 
+     */
+    public function getLastModified() {
+
+        return strtotime($this->objectData['lastmodified']);
+
+    }
+
+    /**
+     * Returns the size of this object in bytes 
+     * 
+     * @return int
+     */
+    public function getSize() {
+
+        return strlen($this->objectData['calendardata']);
+
+    }
+}
+

upload/ips_kernel/sabre/Sabre/CalDAV/CalendarRootNode.php

@@ -0,0 +1,74 @@
+<?php
+
+/**
+ * Users collection 
+ *
+ * This object is responsible for generating a collection of users.
+ *
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_CalendarRootNode extends Sabre_DAV_Directory {
+
+    /**
+     * Authentication Backend 
+     * 
+     * @var Sabre_DAV_Auth_Backend_Abstract 
+     */
+    protected $authBackend;
+
+    /**
+     * CalDAV backend 
+     * 
+     * @var Sabre_CalDAV_Backend_Abstract 
+     */
+    protected $caldavBackend;
+
+    /**
+     * Constructor 
+     *
+     * This constructor needs both an authentication and a caldav backend.
+     *
+     * @param Sabre_DAV_Auth_Backend_Abstract $authBackend 
+     * @param Sabre_CalDAV_Backend_Abstract $caldavBackend 
+     */
+    public function __construct(Sabre_DAV_Auth_Backend_Abstract $authBackend,Sabre_CalDAV_Backend_Abstract $caldavBackend) {
+
+        $this->authBackend = $authBackend;
+        $this->caldavBackend = $caldavBackend;
+
+    }
+
+    /**
+     * Returns the name of the node 
+     * 
+     * @return string 
+     */
+    public function getName() {
+
+        return Sabre_CalDAV_Plugin::CALENDAR_ROOT;
+
+    }
+
+    /**
+     * Returns the list of users as Sabre_CalDAV_User objects. 
+     * 
+     * @return array 
+     */
+    public function getChildren() {
+
+        $users = $this->authBackend->getUsers();
+        $children = array();
+        foreach($users as $user) {
+
+            $children[] = new Sabre_CalDAV_UserCalendars($this->authBackend, $this->caldavBackend, $user['uri']);
+
+        }
+        return $children;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/Exception/InvalidICalendarObject.php

@@ -0,0 +1,18 @@
+<?php
+
+/**
+ * InvalidICalendarObject
+ *
+ * This exception is thrown when an attempt is made to create or update
+ * an invalid ICalendar object
+ * 
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_Exception_InvalidICalendarObject extends Sabre_DAV_Exception_PreconditionFailed {
+
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/Exception/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/CalDAV/ICalendarUtil.php

@@ -0,0 +1,154 @@
+<?php
+
+/**
+ * This class contains several utilities related to the ICalendar (rfc2445) format
+ *
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_ICalendarUtil {
+
+    /**
+     * Validates an ICalendar object
+     *
+     * This method makes sure this ICalendar object is properly formatted.
+     * If we can't parse it, we'll throw exceptions.
+     * 
+     * @param string $icalData 
+     * @param array $allowedComponents 
+     * @return bool 
+     */
+    static function validateICalendarObject($icalData, array $allowedComponents) {
+
+        $xcal = simplexml_load_string(self::toXCal($icalData));
+        if (!$xcal) throw new Sabre_CalDAV_Exception_InvalidICalendarObject('Invalid calendarobject format');
+
+        $xcal->registerXPathNameSpace('cal','urn:ietf:params:xml:ns:xcal');
+        
+        // Check if there's only 1 component
+        $components = array('vevent','vtodo','vjournal','vfreebusy');
+        $componentsFound = array();
+
+        foreach($components as $component) {
+            $test = $xcal->xpath('/cal:iCalendar/cal:vcalendar/cal:' . $component);
+            if (is_array($test)) $componentsFound = array_merge($componentsFound, $test);
+        }
+        if (count($componentsFound)>1) {
+            throw new Sabre_CalDAV_Exception_InvalidICalendarObject('Only 1 of VEVENT, VTODO, VJOURNAL or VFREEBUSY may be specified per calendar object');
+        }
+        if (count($componentsFound)<1) {
+            throw new Sabre_CalDAV_Exception_InvalidICalendarObject('One VEVENT, VTODO, VJOURNAL or VFREEBUSY must be specified. 0 found.');
+        }
+        $component = $componentsFound[0];
+        
+        // Check if the component is allowed
+        $name = $component->getName();
+        if (!in_array(strtoupper($name),$allowedComponents)) {
+            throw new Sabre_CalDAV_Exception_InvalidICalendarObject(strtoupper($name) . ' is not allowed in this calendar.');
+        }
+
+        if (count($xcal->xpath('/cal:iCalendar/cal:vcalendar/cal:method'))>0) {
+            throw new Sabre_CalDAV_Exception_InvalidICalendarObject('The METHOD property is not allowed in calendar objects');
+        }
+
+        return true;
+
+    }
+
+    /**
+     * Converts ICalendar data to XML.
+     *
+     * Properties are converted to lowercase xml elements. Parameters are;
+     * converted to attributes. BEGIN:VEVENT is converted to <vevent> and
+     * END:VEVENT </vevent> as well as other components.
+     *
+     * It's a very loose parser. If any line does not conform to the spec, it
+     * will simply be ignored. It will try to detect if \r\n or \n line endings
+     * are used.
+     *
+     * @todo Currently quoted attributes are not parsed correctly.
+     * @see http://tools.ietf.org/html/draft-royer-calsch-xcal-03
+     * @param string $icalData 
+     * @return string. 
+     */
+    static function toXCAL($icalData) {
+
+        // Detecting line endings
+        $lb="\r\n";
+        if (strpos($icalData,"\r\n")!==false) $lb = "\r\n";
+        elseif (strpos($icalData,"\n")!==false) $lb = "\n";
+
+        // Splitting up items per line
+        $lines = explode($lb,$icalData);
+
+        // Properties can be folded over 2 lines. In this case the second
+        // line will be preceeded by a space or tab.
+        $lines2 = array();
+        foreach($lines as $line) {
+
+            if (!$line) continue;
+            if ($line[0]===" " || $line[0]==="\t") {
+                $lines2[count($lines2)-1].=substr($line,1);
+                continue;
+            }
+
+            $lines2[]=$line;
+
+        }
+
+        $xml = '<?xml version="1.0"?>' . "\n";
+        $xml.= "<iCalendar xmlns=\"urn:ietf:params:xml:ns:xcal\">\n";
+
+        $spaces = 2;
+        foreach($lines2 as $line) {
+
+            $matches = array();
+            // This matches PROPERTYNAME;ATTRIBUTES:VALUE
+            if (!preg_match('/^([^:^;]*)(?:;([^:]*))?:(.*)$/',$line,$matches))
+                continue;
+
+            $propertyName = strtolower($matches[1]);
+            $attributes = $matches[2];
+            $value = $matches[3];
+
+            // If the line was in the format BEGIN:COMPONENT or END:COMPONENT, we need to special case it.
+            if ($propertyName === 'begin') {
+                $xml.=str_repeat(" ",$spaces);
+                $xml.='<' . strtolower($value) . ">\n";
+                $spaces+=2;
+                continue;
+            } elseif ($propertyName === 'end') {
+                $spaces-=2;
+                $xml.=str_repeat(" ",$spaces);
+                $xml.='</' . strtolower($value) . ">\n";
+                continue;
+            }
+
+            $xml.=str_repeat(" ",$spaces);
+            $xml.='<' . $propertyName;
+            if ($attributes) {
+                // There can be multiple attributes
+                $attributes = explode(';',$attributes);
+                foreach($attributes as $att) {
+  
+                    list($attName,$attValue) = explode('=',$att,2);
+                    $attName = strtolower($attName);
+                    if ($attName === 'language') $attName='xml:lang';
+                    $xml.=' ' . $attName . '="' . htmlspecialchars($attValue) . '"';
+
+                }
+            }
+
+            $xml.='>'. htmlspecialchars(trim($value)) . '</' . $propertyName . ">\n";
+          
+        }
+        $xml.="</iCalendar>";
+        return $xml;
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/CalDAV/Plugin.php

@@ -0,0 +1,707 @@
+<?php
+
+/**
+ * CalDAV plugin
+ *
+ * This plugin provides functionality added by CalDAV (RFC 4791)
+ * It implements new reports, and the MKCALENDAR method.
+ *
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_Plugin extends Sabre_DAV_ServerPlugin {
+
+    /**
+     * This is the official CalDAV namespace
+     */
+    const NS_CALDAV = 'urn:ietf:params:xml:ns:caldav';
+    
+    /**
+     * This is the namespace for the proprietary calendarserver extensions
+     */
+    const NS_CALENDARSERVER = 'http://calendarserver.org/ns/';
+
+    /**
+     * The following constants are used to differentiate
+     * the various filters for the calendar-query report
+     */
+    const FILTER_COMPFILTER   = 1;
+    const FILTER_TIMERANGE    = 3;
+    const FILTER_PROPFILTER   = 4;
+    const FILTER_PARAMFILTER  = 5;
+    const FILTER_TEXTMATCH    = 6;
+
+    /**
+     * The hardcoded root for calendar objects. It is unfortunate
+     * that we're stuck with it, but it will have to do for now
+     */
+    const CALENDAR_ROOT = 'calendars';
+
+    /**
+     * Reference to server object 
+     * 
+     * @var Sabre_DAV_Server 
+     */
+    private $server;
+
+    /**
+     * Use this method to tell the server this plugin defines additional
+     * HTTP methods.
+     *
+     * This method is passed a uri. It should only return HTTP methods that are 
+     * available for the specified uri.
+     *
+     * @param string $uri
+     * @return array 
+     */
+    public function getHTTPMethods($uri) {
+
+        // The MKCALENDAR is only available on unmapped uri's, whose
+        // parents extend IExtendedCollection
+        list($parent, $name) = Sabre_DAV_URLUtil::splitPath($uri);
+
+        $node = $this->server->tree->getNodeForPath($parent);
+
+        if ($node instanceof Sabre_DAV_IExtendedCollection) {
+            try {
+                $node->getChild($name);
+            } catch (Sabre_DAV_Exception_FileNotFound $e) {
+                return array('MKCALENDAR');
+            }
+        }
+        return array();
+
+    }
+
+    /**
+     * Returns a list of features for the DAV: HTTP header. 
+     * 
+     * @return array 
+     */
+    public function getFeatures() {
+
+        return array('calendar-access');
+
+    }
+
+    /**
+     * Initializes the plugin 
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @return void
+     */
+    public function initialize(Sabre_DAV_Server $server) {
+
+        $this->server = $server;
+        $server->subscribeEvent('unknownMethod',array($this,'unknownMethod'));
+        //$server->subscribeEvent('unknownMethod',array($this,'unknownMethod2'),1000);
+        $server->subscribeEvent('report',array($this,'report'));
+        $server->subscribeEvent('afterGetProperties',array($this,'afterGetProperties'));
+
+        $server->xmlNamespaces[self::NS_CALDAV] = 'cal';
+        $server->xmlNamespaces[self::NS_CALENDARSERVER] = 'cs';
+
+        $server->propertyMap['{' . self::NS_CALDAV . '}supported-calendar-component-set'] = 'Sabre_CalDAV_Property_SupportedCalendarComponentSet';
+
+        array_push($server->protectedProperties,
+
+            '{' . self::NS_CALDAV . '}supported-calendar-component-set',
+            '{' . self::NS_CALDAV . '}supported-calendar-data',
+            '{' . self::NS_CALDAV . '}max-resource-size',
+            '{' . self::NS_CALDAV . '}min-date-time',
+            '{' . self::NS_CALDAV . '}max-date-time',
+            '{' . self::NS_CALDAV . '}max-instances',
+            '{' . self::NS_CALDAV . '}max-attendees-per-instance',
+            '{' . self::NS_CALDAV . '}calendar-home-set',
+            '{' . self::NS_CALDAV . '}supported-collation-set',
+
+            // scheduling extension
+            '{' . self::NS_CALDAV . '}calendar-user-address-set'
+
+        );
+    }
+
+    /**
+     * This function handles support for the MKCALENDAR method
+     * 
+     * @param string $method 
+     * @return bool 
+     */
+    public function unknownMethod($method, $uri) {
+
+        if ($method!=='MKCALENDAR') return;
+
+        $this->httpMkCalendar($uri);
+        // false is returned to stop the unknownMethod event
+        return false;
+
+    }
+
+    /**
+     * This functions handles REPORT requests specific to CalDAV 
+     * 
+     * @param string $reportName 
+     * @param DOMNode $dom 
+     * @return bool 
+     */
+    public function report($reportName,$dom) {
+
+        switch($reportName) { 
+            case '{'.self::NS_CALDAV.'}calendar-multiget' :
+                $this->calendarMultiGetReport($dom);
+                return false;
+            case '{'.self::NS_CALDAV.'}calendar-query' :
+                $this->calendarQueryReport($dom);
+                return false;
+            default :
+                return true;
+
+        }
+
+
+    }
+
+    /**
+     * This function handles the MKCALENDAR HTTP method, which creates
+     * a new calendar.
+     * 
+     * @param string $uri
+     * @return void 
+     */
+    public function httpMkCalendar($uri) {
+
+        // Due to unforgivable bugs in iCal, we're completely disabling MKCALENDAR support
+        // for clients matching iCal in the user agent
+        //$ua = $this->server->httpRequest->getHeader('User-Agent');
+        //if (strpos($ua,'iCal/')!==false) {
+        //    throw new Sabre_DAV_Exception_Forbidden('iCal has major bugs in it\'s RFC3744 support. Therefore we are left with no other choice but disabling this feature.');
+        //}
+
+        $body = $this->server->httpRequest->getBody(true);
+        $dom = Sabre_DAV_XMLUtil::loadDOMDocument($body);
+
+        $properties = array();
+        foreach($dom->firstChild->childNodes as $child) {
+
+            if (Sabre_DAV_XMLUtil::toClarkNotation($child)!=='{DAV:}set') continue;
+            foreach(Sabre_DAV_XMLUtil::parseProperties($child,$this->server->propertyMap) as $k=>$prop) {
+                $properties[$k] = $prop;
+            }
+        
+        }
+
+        $resourceType = array('{DAV:}collection','{urn:ietf:params:xml:ns:caldav}calendar');
+
+        $this->server->createCollection($uri,$resourceType,$properties);
+
+        $this->server->httpResponse->sendStatus(201);
+        $this->server->httpResponse->setHeader('Content-Length',0);
+    }
+
+    /**
+     * afterGetProperties
+     *
+     * This method handler is invoked after properties for a specific resource
+     * are received. This allows us to add any properties that might have been
+     * missing.
+     * 
+     * @param string $path
+     * @param array $properties 
+     * @return void
+     */
+    public function afterGetProperties($path, &$properties) {
+
+        // Find out if we are currently looking at a principal resource
+        $currentNode = $this->server->tree->getNodeForPath($path);
+        if ($currentNode instanceof Sabre_DAV_Auth_Principal) {
+
+            // calendar-home-set property
+            $calHome = '{' . self::NS_CALDAV . '}calendar-home-set';
+            if (array_key_exists($calHome,$properties[404])) {
+                $principalId = $currentNode->getName(); 
+                $calendarHomePath = self::CALENDAR_ROOT . '/' . $principalId . '/';
+                unset($properties[404][$calHome]);
+                $properties[200][$calHome] = new Sabre_DAV_Property_Href($calendarHomePath);
+            }
+
+            // calendar-user-address-set property
+            $calProp = '{' . self::NS_CALDAV . '}calendar-user-address-set';
+            if (array_key_exists($calProp,$properties[404])) {
+
+                // Do we have an email address?
+                $props = $currentNode->getProperties(array('{http://sabredav.org/ns}email-address'));
+                if (isset($props['{http://sabredav.org/ns}email-address'])) {
+                    $email = $props['{http://sabredav.org/ns}email-address'];
+                } else {
+                    // We're going to make up an emailaddress
+                    $email = $currentNode->getName() . '.sabredav@' . $this->server->httpRequest->getHeader('host');
+                }
+                $properties[200][$calProp] = new Sabre_DAV_Property_Href('mailto:' . $email, false);
+                unset($properties[404][$calProp]);
+
+            }
+
+
+        }
+
+        if ($currentNode instanceof Sabre_CalDAV_Calendar || $currentNode instanceof Sabre_CalDAV_CalendarObject) {
+            if (array_key_exists('{DAV:}supported-report-set', $properties[200])) {
+                $properties[200]['{DAV:}supported-report-set']->addReport(array(
+                     '{' . self::NS_CALDAV . '}calendar-multiget',
+                     '{' . self::NS_CALDAV . '}calendar-query',
+                //     '{' . self::NS_CALDAV . '}supported-collation-set',
+                //     '{' . self::NS_CALDAV . '}free-busy-query',
+                ));
+            }
+        }
+
+        
+    }
+
+    /**
+     * This function handles the calendar-multiget REPORT.
+     *
+     * This report is used by the client to fetch the content of a series
+     * of urls. Effectively avoiding a lot of redundant requests.
+     * 
+     * @param DOMNode $dom 
+     * @return void
+     */
+    public function calendarMultiGetReport($dom) {
+
+        $properties = array_keys(Sabre_DAV_XMLUtil::parseProperties($dom->firstChild));
+
+        $hrefElems = $dom->getElementsByTagNameNS('urn:DAV','href');
+        foreach($hrefElems as $elem) {
+            $uri = $this->server->calculateUri($elem->nodeValue);
+            list($objProps) = $this->server->getPropertiesForPath($uri,$properties);
+            $propertyList[]=$objProps;
+
+        }
+
+        $this->server->httpResponse->sendStatus(207);
+        $this->server->httpResponse->setHeader('Content-Type','application/xml; charset=utf-8');
+        $this->server->httpResponse->sendBody($this->server->generateMultiStatus($propertyList));
+
+    }
+
+    /**
+     * This function handles the calendar-query REPORT
+     *
+     * This report is used by clients to request calendar objects based on
+     * complex conditions.
+     * 
+     * @param DOMNode $dom 
+     * @return void
+     */
+    public function calendarQueryReport($dom) {
+
+        $requestedProperties = array_keys(Sabre_DAV_XMLUtil::parseProperties($dom->firstChild));
+
+        $filterNode = $dom->getElementsByTagNameNS('urn:ietf:params:xml:ns:caldav','filter');
+        if ($filterNode->length!==1) {
+            throw new Sabre_DAV_Exception_BadRequest('The calendar-query report must have a filter element');
+        }
+        $filters = Sabre_CalDAV_XMLUtil::parseCalendarQueryFilters($filterNode->item(0));
+
+        $requestedCalendarData = true;
+
+        if (!in_array('{urn:ietf:params:xml:ns:caldav}calendar-data', $requestedProperties)) {
+            // We always retrieve calendar-data, as we need it for filtering.
+            $requestedProperties[] = '{urn:ietf:params:xml:ns:caldav}calendar-data';
+
+            // If calendar-data wasn't explicitly requested, we need to remove 
+            // it after processing.
+            $requestedCalendarData = false;
+        }
+
+        // These are the list of nodes that potentially match the requirement
+        $candidateNodes = $this->server->getPropertiesForPath($this->server->getRequestUri(),$requestedProperties,$this->server->getHTTPDepth(0));
+
+        $verifiedNodes = array();
+
+        foreach($candidateNodes as $node) {
+
+            // If the node didn't have a calendar-data property, it must not be a calendar object
+            if (!isset($node[200]['{urn:ietf:params:xml:ns:caldav}calendar-data'])) continue;
+
+            if ($this->validateFilters($node[200]['{urn:ietf:params:xml:ns:caldav}calendar-data'],$filters)) {
+                
+                if (!$requestedCalendarData) {
+                    unset($node[200]['{urn:ietf:params:xml:ns:caldav}calendar-data']);
+                }
+                $verifiedNodes[] = $node;
+            } 
+
+        }
+
+        $this->server->httpResponse->sendStatus(207);
+        $this->server->httpResponse->setHeader('Content-Type','application/xml; charset=utf-8');
+        $this->server->httpResponse->sendBody($this->server->generateMultiStatus($verifiedNodes));
+
+    }
+
+
+    /**
+     * Verify if a list of filters applies to the calendar data object 
+     *
+     * The calendarData object must be a valid iCalendar blob. The list of 
+     * filters must be formatted as parsed by Sabre_CalDAV_Plugin::parseCalendarQueryFilters
+     *
+     * @param string $calendarData 
+     * @param array $filters 
+     * @return bool 
+     */
+    public function validateFilters($calendarData,$filters) {
+
+        // We are converting the calendar object to an XML structure
+        // This makes it far easier to parse
+        $xCalendarData = Sabre_CalDAV_ICalendarUtil::toXCal($calendarData);
+        $xml = simplexml_load_string($xCalendarData);
+        $xml->registerXPathNamespace('c','urn:ietf:params:xml:ns:xcal');
+
+        foreach($filters as $xpath=>$filter) {
+
+            // if-not-defined comes first
+            if (isset($filter['is-not-defined'])) {
+                if (!$xml->xpath($xpath))
+                    continue;
+                else
+                    return false;
+                
+            }
+
+            $elem = $xml->xpath($xpath);
+            
+            if (!$elem) return false;
+            $elem = $elem[0];
+
+            if (isset($filter['time-range'])) {
+
+                switch($elem->getName()) {
+                    case 'vevent' :
+                        $result = $this->validateTimeRangeFilterForEvent($xml,$xpath,$filter);
+                        if ($result===false) return false;
+                        break;
+                    case 'vtodo' :
+                        $result = $this->validateTimeRangeFilterForTodo($xml,$xpath,$filter);
+                        if ($result===false) return false;
+                        break;
+                    case 'vjournal' :
+                        // TODO: not implemented
+                        break;
+                        $result = $this->validateTimeRangeFilterForJournal($xml,$xpath,$filter);
+                        if ($result===false) return false;
+                        break;
+                    case 'vfreebusy' :
+                        // TODO: not implemented
+                        break;
+                        $result = $this->validateTimeRangeFilterForFreeBusy($xml,$xpath,$filter);
+                        if ($result===false) return false;
+                        break;
+                    case 'valarm' :
+                        // TODO: not implemented
+                        break;
+                        $result = $this->validateTimeRangeFilterForAlarm($xml,$xpath,$filter);
+                        if ($result===false) return false;
+                        break;
+
+                }
+
+            } 
+
+            if (isset($filter['text-match'])) {
+                $currentString = (string)$elem;
+
+                $isMatching = $this->substringMatch($currentString, $filter['text-match']['value'], $filter['text-match']['collation']);
+                if ($filter['text-match']['negate-condition'] && $isMatching) return false;
+                if (!$filter['text-match']['negate-condition'] && !$isMatching) return false;
+                
+            }
+
+        }
+        return true;
+        
+    }
+
+    private function validateTimeRangeFilterForEvent(SimpleXMLElement $xml,$currentXPath,array $currentFilter) {
+
+        // Grabbing the DTSTART property
+        $xdtstart = $xml->xpath($currentXPath.'/c:dtstart');
+        if (!count($xdtstart)) {
+            throw new Sabre_DAV_Exception_BadRequest('DTSTART property missing from calendar object');
+        }
+
+        // The dtstart can be both a date, or datetime property
+        if ((string)$xdtstart[0]['value']==='DATE') {
+            $isDateTime = false;
+        } else {
+            $isDateTime = true;
+        }
+
+        // Determining the timezone
+        if ($tzid = (string)$xdtstart[0]['tzid']) {
+            $tz = new DateTimeZone($tzid);
+        } else {
+            $tz = null;
+        }
+        if ($isDateTime) {
+            $dtstart = Sabre_CalDAV_XMLUtil::parseICalendarDateTime((string)$xdtstart[0],$tz);
+        } else {
+            $dtstart = Sabre_CalDAV_XMLUtil::parseICalendarDate((string)$xdtstart[0]);
+        }
+
+
+        // Grabbing the DTEND property
+        $xdtend = $xml->xpath($currentXPath.'/c:dtend');
+        $dtend = null;
+
+        if (count($xdtend)) {
+            // Determining the timezone
+            if ($tzid = (string)$xdtend[0]['tzid']) {
+                $tz = new DateTimeZone($tzid);
+            } else {
+                $tz = null;
+            }
+
+            // Since the VALUE parameter of both DTSTART and DTEND must be the same
+            // we can assume we don't need to check the VALUE paramter of DTEND.
+            if ($isDateTime) {
+                $dtend = Sabre_CalDAV_XMLUtil::parseICalendarDateTime((string)$xdtend[0],$tz);
+            } else {
+                $dtend = Sabre_CalDAV_XMLUtil::parseICalendarDate((string)$xdtend[0],$tz);
+            }
+
+        } 
+        
+        if (is_null($dtend)) {
+            // The DTEND property was not found. We will first see if the event has a duration
+            // property
+
+            $xduration = $xml->xpath($currentXPath.'/c:duration');
+            if (count($xduration)) {
+                $duration = Sabre_CalDAV_XMLUtil::parseICalendarDuration((string)$xduration[0]);
+
+                // Making sure that the duration is bigger than 0 seconds.
+                $tempDT = clone $dtstart;
+                $tempDT->modify($duration);
+                if ($tempDT > $dtstart) {
+
+                    // use DTEND = DTSTART + DURATION 
+                    $dtend = $tempDT;
+                } else {
+                    // use DTEND = DTSTART
+                    $dtend = $dtstart;
+                }
+
+            }
+        }
+
+        if (is_null($dtend)) {
+            if ($isDateTime) {
+                // DTEND = DTSTART
+                $dtend = $dtstart;
+            } else {
+                // DTEND = DTSTART + 1 DAY
+                $dtend = clone $dtstart;
+                $dtend->modify('+1 day');
+            }
+        }
+       
+        if (!is_null($currentFilter['time-range']['start']) && $currentFilter['time-range']['start'] >= $dtend)  return false;
+        if (!is_null($currentFilter['time-range']['end'])   && $currentFilter['time-range']['end']   <= $dtstart) return false;
+        return true;
+    
+    }
+
+    private function validateTimeRangeFilterForTodo(SimpleXMLElement $xml,$currentXPath,array $filter) {
+
+        // Gathering all relevant elements
+
+        $dtStart = null;
+        $duration = null;
+        $due = null;
+        $completed = null;
+        $created = null;
+
+        $xdt = $xml->xpath($currentXPath.'/c:dtstart');
+        if (count($xdt)) {
+            // The dtstart can be both a date, or datetime property
+            if ((string)$xdt[0]['value']==='DATE') {
+                $isDateTime = false;
+            } else {
+                $isDateTime = true;
+            }
+
+            // Determining the timezone
+            if ($tzid = (string)$xdt[0]['tzid']) {
+                $tz = new DateTimeZone($tzid);
+            } else {
+                $tz = null;
+            }
+            if ($isDateTime) {
+                $dtStart = Sabre_CalDAV_XMLUtil::parseICalendarDateTime((string)$xdt[0],$tz);
+            } else {
+                $dtStart = Sabre_CalDAV_XMLUtil::parseICalendarDate((string)$xdt[0]);
+            }
+        }
+
+        // Only need to grab duration if dtStart is set
+        if (!is_null($dtStart)) {
+
+            $xduration = $xml->xpath($currentXPath.'/c:duration');
+            if (count($xduration)) {
+                $duration = Sabre_CalDAV_XMLUtil::parseICalendarDuration((string)$xduration[0]);
+            }
+
+        }
+
+        if (!is_null($dtStart) && !is_null($duration)) {
+
+            // Comparision from RFC 4791:
+            // (start <= DTSTART+DURATION) AND ((end > DTSTART) OR (end >= DTSTART+DURATION))
+
+            $end = clone $dtStart;
+            $end->modify($duration);
+
+            if( (is_null($filter['time-range']['start']) || $filter['time-range']['start'] <= $end) &&
+                (is_null($filter['time-range']['end']) || $filter['time-range']['end'] > $dtStart || $filter['time-range']['end'] >= $end) ) {
+                return true;
+            } else {
+                return false;
+            }
+
+        }
+
+        // Need to grab the DUE property
+        $xdt = $xml->xpath($currentXPath.'/c:due');
+        if (count($xdt)) {
+            // The due property can be both a date, or datetime property
+            if ((string)$xdt[0]['value']==='DATE') {
+                $isDateTime = false;
+            } else {
+                $isDateTime = true;
+            }
+            // Determining the timezone
+            if ($tzid = (string)$xdt[0]['tzid']) {
+                $tz = new DateTimeZone($tzid);
+            } else {
+                $tz = null;
+            }
+            if ($isDateTime) {
+                $due = Sabre_CalDAV_XMLUtil::parseICalendarDateTime((string)$xdt[0],$tz);
+            } else {
+                $due = Sabre_CalDAV_XMLUtil::parseICalendarDate((string)$xdt[0]);
+            }
+        }
+
+        if (!is_null($dtStart) && !is_null($due)) {
+
+            // Comparision from RFC 4791:
+            // ((start < DUE) OR (start <= DTSTART)) AND ((end > DTSTART) OR (end >= DUE))
+            
+            if( (is_null($filter['time-range']['start']) || $filter['time-range']['start'] < $due || $filter['time-range']['start'] < $dtstart) &&
+                (is_null($filter['time-range']['end'])   || $filter['time-range']['end'] >= $due) ) {
+                return true;
+            } else {
+                return false;
+            }
+
+        }
+
+        if (!is_null($dtStart)) {
+            
+            // Comparision from RFC 4791
+            // (start <= DTSTART)  AND (end > DTSTART)
+            if ( (is_null($filter['time-range']['start']) || $filter['time-range']['start'] <= $dtStart) &&
+                 (is_null($filter['time-range']['end'])   || $filter['time-range']['end'] > $dtStart) ) {
+                 return true;
+            } else {
+                return false;
+            }
+
+        }
+
+        if (!is_null($due)) {
+            
+            // Comparison from RFC 4791
+            // (start < DUE) AND (end >= DUE)
+            if ( (is_null($filter['time-range']['start']) || $filter['time-range']['start'] < $due) &&
+                 (is_null($filter['time-range']['end'])   || $filter['time-range']['end'] >= $due) ) {
+                 return true;
+            } else {
+                return false;
+            }
+
+        }
+        // Need to grab the COMPLETED property
+        $xdt = $xml->xpath($currentXPath.'/c:completed');
+        if (count($xdt)) {
+            $completed = Sabre_CalDAV_XMLUtil::parseICalendarDateTime((string)$xdt[0]);
+        }
+        // Need to grab the CREATED property
+        $xdt = $xml->xpath($currentXPath.'/c:created');
+        if (count($xdt)) {
+            $created = Sabre_CalDAV_XMLUtil::parseICalendarDateTime((string)$xdt[0]);
+        }
+
+        if (!is_null($completed) && !is_null($created)) {
+            // Comparison from RFC 4791
+            // ((start <= CREATED) OR (start <= COMPLETED)) AND ((end >= CREATED) OR (end >= COMPLETED))
+            if( (is_null($filter['time-range']['start']) || $filter['time-range']['start'] <= $created || $filter['time-range']['start'] <= $completed) &&
+                (is_null($filter['time-range']['end'])   || $filter['time-range']['end'] >= $created   || $filter['time-range']['end'] >= $completed)) {
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        if (!is_null($completed)) {
+            // Comparison from RFC 4791
+            // (start <= COMPLETED) AND (end  >= COMPLETED)
+            if( (is_null($filter['time-range']['start']) || $filter['time-range']['start'] <= $completed) &&
+                (is_null($filter['time-range']['end'])   || $filter['time-range']['end'] >= $completed)) {
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        if (!is_null($created)) {
+            // Comparison from RFC 4791
+            // (end > CREATED)
+            if( (is_null($filter['time-range']['end']) || $filter['time-range']['end'] > $created) ) {
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        // Everything else is TRUE
+        return true;
+
+    }
+
+    public function substringMatch($haystack, $needle, $collation) {
+
+        switch($collation) {
+            case 'i;ascii-casemap' :
+                // default strtolower takes locale into consideration
+                // we don't want this.
+                $haystack = str_replace(range('a','z'), range('A','Z'), $haystack);
+                $needle = str_replace(range('a','z'), range('A','Z'), $needle);
+                return strpos($haystack, $needle)!==false;
+
+            case 'i;octet' :
+                return strpos($haystack, $needle)!==false;
+            
+            default:
+                throw new Sabre_DAV_Exception_BadRequest('Unknown collation: ' . $collation);
+        }                
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/Property/SupportedCalendarComponentSet.php

@@ -0,0 +1,85 @@
+<?php
+
+/**
+ * Supported component set property
+ *
+ * This property is a representation of the supported-calendar_component-set 
+ * property in the CalDAV namespace. It simply requires an array of components,
+ * such as VEVENT, VTODO
+ *
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_Property_SupportedCalendarComponentSet extends Sabre_DAV_Property {
+
+    /**
+     * List of supported components, such as "VEVENT, VTODO" 
+     * 
+     * @var array 
+     */
+    private $components;
+
+    /**
+     * Creates the property 
+     * 
+     * @param array $components 
+     */
+    public function __construct(array $components) {
+
+       $this->components = $components; 
+
+    }
+
+    /**
+     * Returns the list of supported components 
+     * 
+     * @return array 
+     */
+    public function getValue() {
+
+        return $this->components;
+
+    }
+
+    /**
+     * Serializes the property in a DOMDocument 
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @param DOMElement $node 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $node) {
+
+       $doc = $node->ownerDocument;
+       foreach($this->components as $component) {
+
+            $xcomp = $doc->createElement('cal:comp');
+            $xcomp->setAttribute('name',$component);
+            $node->appendChild($xcomp); 
+
+       }
+
+    }
+
+    /**
+     * Unserializes the DOMElement back into a Property class.
+     * 
+     * @param DOMElement $node 
+     * @return void
+     */
+    static function unserialize(DOMElement $node) {
+
+        $components = array();
+        foreach($node->childNodes as $childNode) {
+            if (Sabre_DAV_XMLUtil::toClarkNotation($childNode)==='{' . Sabre_CalDAV_Plugin::NS_CALDAV . '}comp') {
+                $components[] = $childNode->getAttribute('name');
+            }
+        }
+        return new self($components);
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/Property/SupportedCalendarData.php

@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * Supported-calendar-data property
+ *
+ * This property is a representation of the supported-calendar-data property
+ * in the CalDAV namespace. SabreDAV only has support for text/calendar;2.0
+ * so the value is currently hardcoded.
+ *
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_Property_SupportedCalendarData extends Sabre_DAV_Property {
+
+    /**
+     * Serializes the property in a DOMDocument 
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @param DOMElement $node 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $node) {
+
+        $doc = $node->ownerDocument;
+
+        $prefix = isset($server->xmlNamespaces[Sabre_CalDAV_Plugin::NS_CALDAV])?$server->xmlNamespaces[Sabre_CalDAV_Plugin::NS_CALDAV]:'cal';
+
+        $caldata = $doc->createElement($prefix . ':calendar-data');
+        $caldata->setAttribute('content-type','text/calendar');
+        $caldata->setAttribute('version','2.0');
+
+        $node->appendChild($caldata); 
+    }
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/Property/SupportedCollationSet.php

@@ -0,0 +1,34 @@
+<?php
+
+/**
+ * supported-collation-set property
+ *
+ * This property is a representation of the supported-collation-set property
+ * in the CalDAV namespace. 
+ *
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_Property_SupportedCollationSet extends Sabre_DAV_Property {
+
+    function serialize(Sabre_DAV_Server $server,DOMElement $node) {
+
+        $doc = $node->ownerDocument;
+        
+        $prefix = $node->lookupPrefix('urn:ietf:params:xml:ns:caldav');
+        if (!$prefix) $prefix = 'cal';
+
+        $node->appendChild(
+            $doc->createElement($prefix . ':supported-collation','i;ascii-casemap')
+        );
+        $node->appendChild(
+            $doc->createElement($prefix . ':supported-collation','i;octet')
+        );
+
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/Property/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/CalDAV/Server.php

@@ -0,0 +1,50 @@
+<?php
+
+/**
+ * CalDAV server
+ *
+ * This script is a convenience script. It quickly sets up a WebDAV server
+ * with caldav and ACL support, and it creates the root 'principals' and
+ * 'calendars' collections.
+ * 
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_Server extends Sabre_DAV_Server {
+
+    /**
+     * Sets up the object. A PDO object must be passed to setup all the backends.
+     * 
+     * @param PDO $pdo 
+     */
+    public function __construct(PDO $pdo) {
+
+        /* Backends */
+        $authBackend = new Sabre_DAV_Auth_Backend_PDO($pdo);
+        $calendarBackend = new Sabre_CalDAV_Backend_PDO($pdo);
+
+        /* Directory structure */
+        $root = new Sabre_DAV_SimpleDirectory('root');
+        $principals = new Sabre_DAV_Auth_PrincipalCollection($authBackend);
+        $root->addChild($principals);
+        $calendars = new Sabre_CalDAV_CalendarRootNode($authBackend, $calendarBackend);
+        $root->addChild($calendars);
+
+        $objectTree = new Sabre_DAV_ObjectTree($root);
+        
+        /* Initializing server */
+        parent::__construct($objectTree);
+
+        /* Server Plugins */
+        $authPlugin = new Sabre_DAV_Auth_Plugin($authBackend,'SabreDAV');
+        $this->addPlugin($authPlugin);
+
+        $caldavPlugin = new Sabre_CalDAV_Plugin();
+        $this->addPlugin($caldavPlugin);
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/UserCalendars.php

@@ -0,0 +1,193 @@
+<?php
+
+/**
+ * The UserCalenders class contains all calendars associated to one user 
+ * 
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_UserCalendars implements Sabre_DAV_IExtendedCollection {
+
+    /**
+     * Authentication backend 
+     * 
+     * @var Sabre_DAV_Auth_Backend_Abstract 
+     */
+    protected $authBackend;
+
+    /**
+     * Array with user information 
+     * 
+     * @var array 
+     */
+    protected $userUri;
+
+    /**
+     * CalDAV backend
+     * 
+     * @var Sabre_CalDAV_Backend_Abstract
+     */
+    protected $caldavBackend;
+    
+    /**
+     * Constructor 
+     * 
+     * @param Sabre_DAV_Auth_Backend_Abstract $authBackend 
+     * @param Sabre_CalDAV_Backend_Abstract $caldavBackend 
+     * @param mixed $userUri 
+     */
+    public function __construct(Sabre_DAV_Auth_Backend_Abstract $authBackend, Sabre_CalDAV_Backend_Abstract $caldavBackend, $userUri) {
+
+        $this->authBackend = $authBackend;
+        $this->caldavBackend = $caldavBackend;
+        $this->userUri = $userUri;
+       
+    }
+
+    /**
+     * Returns the name of this object 
+     * 
+     * @return string
+     */
+    public function getName() {
+      
+        list(,$name) = Sabre_DAV_URLUtil::splitPath($this->userUri);
+        return $name; 
+
+    }
+
+    /**
+     * Updates the name of this object 
+     * 
+     * @param string $name 
+     * @return void
+     */
+    public function setName($name) {
+
+        throw new Sabre_DAV_Exception_Forbidden();
+
+    }
+
+    /**
+     * Deletes this object 
+     * 
+     * @return void
+     */
+    public function delete() {
+
+        throw new Sabre_DAV_Exception_Forbidden();
+
+    }
+
+    /**
+     * Returns the last modification date 
+     * 
+     * @return int 
+     */
+    public function getLastModified() {
+
+        return null; 
+
+    }
+
+    /**
+     * Creates a new file under this object.
+     *
+     * This is currently not allowed
+     * 
+     * @param string $filename 
+     * @param resource $data 
+     * @return void
+     */
+    public function createFile($filename, $data=null) {
+
+        throw new Sabre_DAV_Exception_MethodNotAllowed('Creating new files in this collection is not supported');
+
+    }
+
+    /**
+     * Creates a new directory under this object.
+     *
+     * This is currently not allowed.
+     * 
+     * @param string $filename 
+     * @return void
+     */
+    public function createDirectory($filename) {
+
+        throw new Sabre_DAV_Exception_MethodNotAllowed('Creating new collections in this collection is not supported');
+
+    }
+
+    /**
+     * Returns a single calendar, by name 
+     * 
+     * @param string $name
+     * @todo needs optimizing
+     * @return Sabre_CalDAV_Calendar 
+     */
+    public function getChild($name) {
+
+        foreach($this->getChildren() as $child) {
+            if ($name==$child->getName())
+                return $child;
+
+        }
+        throw new Sabre_DAV_Exception_FileNotFound('Calendar with name \'' . $name . '\' could not be found');
+
+    }
+
+    /**
+     * Checks if a calendar exists.
+     * 
+     * @param string $name
+     * @todo needs optimizing
+     * @return bool 
+     */
+    public function childExists($name) {
+
+        foreach($this->getChildren() as $child) {
+            if ($name==$child->getName())
+                return true; 
+
+        }
+        return false;
+
+    }
+
+    /**
+     * Returns a list of calendars
+     * 
+     * @return array 
+     */
+    public function getChildren() {
+
+        $calendars = $this->caldavBackend->getCalendarsForUser($this->userUri);
+        $objs = array();
+        foreach($calendars as $calendar) {
+            $objs[] = new Sabre_CalDAV_Calendar($this->authBackend, $this->caldavBackend, $calendar);
+        }
+        return $objs;
+
+    }
+
+    /**
+     * Creates a new calendar
+     * 
+     * @param string $name 
+     * @param string $properties 
+     * @return void
+     */
+    public function createExtendedCollection($name, array $resourceType, array $properties) {
+
+        if (!in_array('{urn:ietf:params:xml:ns:caldav}calendar',$resourceType) || count($resourceType)!==2) {
+            throw new Sabre_DAV_Exception_InvalidResourceType('Unknown resourceType for this collection');
+        }
+        $this->caldavBackend->createCalendar($this->userUri, $name, $properties);
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/Version.php

@@ -0,0 +1,24 @@
+<?php
+
+/**
+ * This class contains the Sabre_CalDAV version constants.
+ * 
+ * @package Sabre
+ * @subpackage CalDAV 
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/)
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_Version {
+
+    /**
+     * Full version number
+     */
+    const VERSION = '1.3.0';
+
+    /**
+     * Stability : alpha, beta, stable
+     */
+    const STABILITY = 'stable';
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/XMLUtil.php

@@ -0,0 +1,208 @@
+<?php
+
+/**
+ * XML utilities for CalDAV 
+ *
+ * This class contains a few static methods used for parsing certain CalDAV 
+ * requests.
+ *
+ * @package Sabre
+ * @subpackage CalDAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_CalDAV_XMLUtil {
+
+    /**
+     * This function parses the calendar-query report request body
+     *
+     * The body is quite complicated, so we're turning it into a PHP
+     * array.
+     *
+     * The resulting associative array has xpath expressions as keys.
+     * By default the xpath expressions should simply be checked for existance
+     * The xpath expressions can point to elements or attributes.
+     * 
+     * The array values can contain a number of items, which alters the query
+     * filter. 
+     *
+     * * time-range. Must also check if the todo or event falls within the
+     *               specified timerange. How this is interpreted depends on
+     *               the type of object (VTODO, VEVENT, VJOURNAL, etc)
+     * * is-not-defined
+     *               Instead of checking if the attribute or element exist,
+     *               we must check if it doesn't.
+     * * text-match
+     *               Checks if the value of the attribute or element matches
+     *               the specified value. This is actually another array with
+     *               the 'collation', 'value' and 'negate-condition' items.
+     *
+     * Refer to the CalDAV spec for more information.
+     * 
+     * @param DOMNode $domNode 
+     * @param string $basePath used for recursive calls.
+     * @param array $filters used for recursive calls.
+     * @return array 
+     */
+    static public function parseCalendarQueryFilters($domNode,$basePath = '/c:iCalendar', &$filters = array()) {
+
+        foreach($domNode->childNodes as $child) {
+
+            switch(Sabre_DAV_XMLUtil::toClarkNotation($child)) {
+
+                case '{urn:ietf:params:xml:ns:caldav}comp-filter' :
+                case '{urn:ietf:params:xml:ns:caldav}prop-filter' :
+                   
+                    $filterName = $basePath . '/' . 'c:' . strtolower($child->getAttribute('name'));
+                    $filters[$filterName] = array(); 
+
+                    self::parseCalendarQueryFilters($child, $filterName,$filters);
+                    break;
+
+                case '{urn:ietf:params:xml:ns:caldav}time-range' :
+               
+                    if ($start = $child->getAttribute('start')) {
+                        $start = self::parseICalendarDateTime($start);
+                    } else {
+                        $start = null;
+                    }
+                    if ($end = $child->getAttribute('end')) {
+                        $end = self::parseICalendarDateTime($end);
+                    } else {
+                        $end = null;
+                    }
+
+                    if (!is_null($start) && !is_null($end) && $end <= $start) {
+                        throw new Sabre_DAV_Exception_BadRequest('The end-date must be larger than the start-date in the time-range filter');
+                    }
+
+                    $filters[$basePath]['time-range'] = array(
+                        'start' => $start,
+                        'end'   => $end
+                    );
+                    break;
+
+                case '{urn:ietf:params:xml:ns:caldav}is-not-defined' :
+                    $filters[$basePath]['is-not-defined'] = true;
+                    break;
+
+                case '{urn:ietf:params:xml:ns:caldav}param-filter' :
+               
+                    $filterName = $basePath . '/@' . strtolower($child->getAttribute('name'));
+                    $filters[$filterName] = array();
+                    self::parseCalendarQueryFilters($child, $filterName, $filters);
+                    break;
+
+                case '{urn:ietf:params:xml:ns:caldav}text-match' :
+               
+                    $collation = $child->getAttribute('collation');
+                    if (!$collation) $collation = 'i;ascii-casemap';
+
+                    $filters[$basePath]['text-match'] = array(
+                        'collation' => $collation,
+                        'negate-condition' => $child->getAttribute('negate-condition')==='yes',
+                        'value' => $child->nodeValue,
+                    );
+                    break;
+
+            }
+
+        }
+
+        return $filters;
+
+    }
+
+    /**
+     * Parses an iCalendar (rfc5545) formatted datetime and returns a DateTime object
+     *
+     * Specifying a reference timezone is optional. It will only be used
+     * if the non-UTC format is used. The argument is used as a reference, the 
+     * returned DateTime object will still be in the UTC timezone.
+     *
+     * @param string $dt 
+     * @param DateTimeZone $tz 
+     * @return DateTime 
+     */
+    static public function parseICalendarDateTime($dt,DateTimeZone $tz = null) {
+
+        // Format is YYYYMMDD + "T" + hhmmss 
+        $result = preg_match('/^([1-3][0-9]{3})([0-1][0-9])([0-3][0-9])T([0-2][0-9])([0-5][0-9])([0-5][0-9])([Z]?)$/',$dt,$matches);
+
+        if (!$result) {
+            throw new Sabre_DAV_Exception_BadRequest('The supplied iCalendar datetime value is incorrect: ' . $dt);
+        }
+
+        if ($matches[7]==='Z' || is_null($tz)) {
+            $tz = new DateTimeZone('UTC');
+        } 
+        $date = new DateTime($matches[1] . '-' . $matches[2] . '-' . $matches[3] . ' ' . $matches[4] . ':' . $matches[5] .':' . $matches[6], $tz);
+
+        // Still resetting the timezone, to normalize everything to UTC
+        $date->setTimeZone(new DateTimeZone('UTC'));
+        return $date;
+
+    }
+
+    /**
+     * Parses an iCalendar (rfc5545) formatted datetime and returns a DateTime object
+     *
+     * @param string $date 
+     * @param DateTimeZone $tz 
+     * @return DateTime 
+     */
+    static public function parseICalendarDate($date) {
+
+        // Format is YYYYMMDD
+        $result = preg_match('/^([1-3][0-9]{3})([0-1][0-9])([0-3][0-9])$/',$date,$matches);
+
+        if (!$result) {
+            throw new Sabre_DAV_Exception_BadRequest('The supplied iCalendar date value is incorrect: ' . $date);
+        }
+
+        $date = new DateTime($matches[1] . '-' . $matches[2] . '-' . $matches[3], new DateTimeZone('UTC'));
+        return $date;
+
+    }
+   
+    /**
+     * Parses an iCalendar (RFC5545) formatted duration and returns a string suitable
+     * for strtotime or DateTime::modify.
+     *
+     * NOTE: When we require PHP 5.3 this can be replaced by the DateTimeInterval object, which
+     * supports ISO 8601 Intervals, which is a superset of ICalendar durations.
+     *
+     * For now though, we're just gonna live with this messy system
+     *
+     * @param string $duration
+     * @return string
+     */
+    static public function parseICalendarDuration($duration) {
+
+        $result = preg_match('/^(?P<plusminus>\+|-)?P((?P<week>\d+)W)?((?P<day>\d+)D)?(T((?P<hour>\d+)H)?((?P<minute>\d+)M)?((?P<second>\d+)S)?)?$/', $duration, $matches);
+        if (!$result) {
+            throw new Sabre_DAV_Exception_BadRequest('The supplied iCalendar duration value is incorrect: ' . $duration);
+        }
+       
+        $parts = array(
+            'week',
+            'day',
+            'hour',
+            'minute',
+            'second',
+        );
+
+        $newDur = '';
+        foreach($parts as $part) {
+            if (isset($matches[$part]) && $matches[$part]) {
+                $newDur.=' '.$matches[$part] . ' ' . $part . 's';
+            }
+        }
+
+        $newDur = ($matches['plusminus']==='-'?'-':'+') . trim($newDur);
+        return $newDur;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/CalDAV/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/DAV/Auth/Backend/Abstract.php

@@ -0,0 +1,49 @@
+<?php
+
+/**
+ * This is the base class for any authentication object.
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_Auth_Backend_Abstract {
+
+    /**
+     * Authenticates the user based on the current request.
+     *
+     * If authentication is succesful, true must be returned.
+     * If authentication fails, an exception must be thrown.
+     *
+     * @return bool 
+     */
+    abstract public function authenticate(Sabre_DAV_Server $server,$realm); 
+
+    /**
+     * Returns information about the currently logged in user.
+     *
+     * If nobody is currently logged in, this method should return null.
+     * 
+     * @return array|null
+     */
+    abstract public function getCurrentUser();
+
+    /**
+     * Returns the full list of users.
+     *
+     * This method must at least return a uri for each user.
+     *
+     * It is optional to implement this.
+     * 
+     * @return array 
+     */
+    public function getUsers() {
+
+        return array();
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Auth/Backend/AbstractBasic.php

@@ -0,0 +1,85 @@
+<?php
+/**
+ * HTTP Basic authentication backend class
+ *
+ * This class can be used by authentication objects wishing to use HTTP Basic
+ * Most of the digest logic is handled, implementors just need to worry about
+ * the authenticateInternal and getUserInfo methods
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author James David Low (http://jameslow.com/)
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_Auth_Backend_AbstractBasic extends Sabre_DAV_Auth_Backend_Abstract {
+
+    /**
+     * This variable holds information about the currently
+     * logged in user.
+     *
+     * @var array|null
+     */
+    protected $currentUser;
+
+    /**
+     * Validates a username and password
+     *
+     * If the username and password were correct, this method must return
+     * an array with at least a 'uri' key.  
+     *
+     * If the credentials are incorrect, this method must return false.
+     *
+     * @return bool|array
+     */
+    abstract protected function validateUserPass($username, $password);
+
+    /**
+     * Returns information about the currently logged in user.
+     *
+     * If nobody is currently logged in, this method should return null.
+     *
+     * @return array|null
+     */
+    public function getCurrentUser() {
+        return $this->currentUser;
+    }
+
+
+    /**
+     * Authenticates the user based on the current request.
+     *
+     * If authentication is succesful, true must be returned.
+     * If authentication fails, an exception must be thrown.
+     *
+     * @throws Sabre_DAV_Exception_NotAuthenticated
+     * @return bool
+     */
+    public function authenticate(Sabre_DAV_Server $server,$realm) {
+
+        $auth = new Sabre_HTTP_BasicAuth();
+        $auth->setHTTPRequest($server->httpRequest);
+        $auth->setHTTPResponse($server->httpResponse);
+        $auth->setRealm($realm);
+        $userpass = $auth->getUserPass();
+        if (!$userpass) {
+            $auth->requireLogin();
+            throw new Sabre_DAV_Exception_NotAuthenticated('No basic authentication headers were found');
+        }
+
+        // Authenticates the user
+        if (!($userData = $this->validateUserPass($userpass[0],$userpass[1]))) {
+            $auth->requireLogin();
+            throw new Sabre_DAV_Exception_NotAuthenticated('Username or password does not match');
+        }
+        if (!isset($userData['uri'])) {
+            throw new Sabre_DAV_Exception('The returned array from validateUserPass must contain at a uri element');
+        }
+        $this->currentUser = $userData;
+        return true;
+    }
+
+
+} 
+

upload/ips_kernel/sabre/Sabre/DAV/Auth/Backend/AbstractDigest.php

@@ -0,0 +1,105 @@
+<?php
+
+/**
+ * HTTP Digest authentication backend class
+ *
+ * This class can be used by authentication objects wishing to use HTTP Digest
+ * Most of the digest logic is handled, implementors just need to worry about 
+ * the getUserInfo method 
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_Auth_Backend_AbstractDigest extends Sabre_DAV_Auth_Backend_Abstract {
+
+    /**
+     * This variable holds information about the currently
+     * logged in user.
+     * 
+     * @var array|null
+     */
+    protected $currentUser;
+
+    /**
+     * Returns a users information based on its username
+     *
+     * The returned struct must contain at least a uri 
+     * element (which can be identical to username) as well as a digestHash
+     * element.
+     *
+     * If the user was not known, false must be returned. 
+     * 
+     * @param string $realm
+     * @param string $username 
+     * @return array 
+     */
+    abstract public function getUserInfo($realm, $username);
+
+    /**
+     * Authenticates the user based on the current request.
+     *
+     * If authentication is succesful, true must be returned.
+     * If authentication fails, an exception must be thrown.
+     *
+     * @throws Sabre_DAV_Exception_NotAuthenticated
+     * @return bool 
+     */
+    public function authenticate(Sabre_DAV_Server $server,$realm) {
+
+        $digest = new Sabre_HTTP_DigestAuth();
+
+        // Hooking up request and response objects
+        $digest->setHTTPRequest($server->httpRequest);
+        $digest->setHTTPResponse($server->httpResponse);
+
+        $digest->setRealm($realm);
+        $digest->init();
+
+        $username = $digest->getUsername();
+
+        // No username was given
+        if (!$username) {
+            $digest->requireLogin();
+            throw new Sabre_DAV_Exception_NotAuthenticated('No digest authentication headers were found');
+        }
+
+        $userData = $this->getUserInfo($realm, $username);
+        // If this was false, the user account didn't exist
+        if ($userData===false) {
+            $digest->requireLogin();
+            throw new Sabre_DAV_Exception_NotAuthenticated('The supplied username was not on file');
+        }
+        if (!is_array($userData)) {
+            throw new Sabre_DAV_Exception('The returntype for getUserInfo must be either false or an array');
+        }
+
+        if (!isset($userData['uri']) || !isset($userData['digestHash'])) {
+            throw new Sabre_DAV_Exception('The returned array from getUserInfo must contain at least a uri and digestHash element');
+        }
+
+        // If this was false, the password or part of the hash was incorrect.
+        if (!$digest->validateA1($userData['digestHash'])) {
+            $digest->requireLogin();
+            throw new Sabre_DAV_Exception_NotAuthenticated('Incorrect username');
+        }
+
+        $this->currentUser = $userData;
+        return true;
+
+    }
+
+    /**
+     * Returns information about the currently logged in user. 
+     * 
+     * @return array|null 
+     */
+    public function getCurrentUser() {
+
+        return $this->currentUser;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Auth/Backend/Apache.php

@@ -0,0 +1,77 @@
+<?php
+
+/**
+ * Apache authenticator
+ *
+ * This authentication backend assumes that auhtentication has been
+ * conifgured in apache, rather than within SabreDAV.
+ *
+ * Make sure apache is properly configured for this to work.
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Auth_Backend_Apache extends Sabre_DAV_Auth_Backend_Abstract {
+
+    /**
+     * Current apache user 
+     * 
+     * @var string 
+     */
+    protected $remoteUser;
+    
+    /**
+     * Authenticates the user based on the current request.
+     *
+     * If authentication is succesful, true must be returned.
+     * If authentication fails, an exception must be thrown.
+     *
+     * @return bool 
+     */
+    public function authenticate(Sabre_DAV_Server $server,$realm) {
+
+        $remoteUser = $server->httpRequest->getRawServerValue('REMOTE_USER');
+        if (is_null($remoteUser)) {
+            throw new Sabre_DAV_Exception('We did not receive the $_SERVER[REMOTE_USER] property. This means that apache might have been misconfigured');
+        }
+
+        $this->remoteUser = $remoteUser;
+        return true;
+
+    }
+
+    /**
+     * Returns information about the currently logged in user.
+     *
+     * If nobody is currently logged in, this method should return null.
+     * 
+     * @return array|null
+     */
+    public function getCurrentUser() {
+
+        return array(
+            'uri' => 'principals/' . $this->remoteUser,
+        );
+
+    }
+
+    /**
+     * Returns the full list of users.
+     *
+     * This method must at least return a uri for each user.
+     *
+     * It is optional to implement this.
+     * 
+     * @return array 
+     */
+    public function getUsers() {
+
+        return array($this->getCurrentUser());
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Auth/Backend/File.php

@@ -0,0 +1,102 @@
+<?php
+
+/**
+ * This is an authentication backend that uses a file to manage passwords.
+ *
+ * The backend file must conform to Apache's htdigest format
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Auth_Backend_File extends Sabre_DAV_Auth_Backend_AbstractDigest {
+
+    /**
+     * List of users 
+     * 
+     * @var array
+     */
+    protected $users = array();
+
+    /**
+     * Creates the backend object. 
+     *
+     * If the filename argument is passed in, it will parse out the specified file fist.
+     * 
+     * @param string $filename 
+     * @return void
+     */
+    public function __construct($filename=null) {
+
+        if (!is_null($filename))
+            $this->loadFile($filename);
+
+    }
+
+    /**
+     * Loads an htdigest-formatted file. This method can be called multiple times if
+     * more than 1 file is used.
+     * 
+     * @param string $filename 
+     * @return void
+     */
+    public function loadFile($filename) {
+
+        foreach(file($filename,FILE_IGNORE_NEW_LINES) as $line) {
+
+            if (substr_count($line, ":") !== 2) 
+                throw new Sabre_DAV_Exception('Malformed htdigest file. Every line should contain 2 colons');
+            
+            list($username,$realm,$A1) = explode(':',$line);
+
+            if (!preg_match('/^[a-zA-Z0-9]{32}$/', $A1))
+                throw new Sabre_DAV_Exception('Malformed htdigest file. Invalid md5 hash');
+                
+            $this->users[$username] = array(
+                'digestHash' => $A1,
+                'uri'        => 'principals/' . $username
+            );
+
+        }
+
+    }
+
+    /**
+     * Returns a users' information
+     * 
+     * @param string $realm 
+     * @param string $username 
+     * @return string 
+     */
+    public function getUserInfo($realm, $username) {
+
+        return isset($this->users[$username])?$this->users[$username]:false;
+
+    }
+
+
+    /**
+     * Returns the full list of users.
+     *
+     * This method must at least return a uri for each user.
+     * 
+     * @return array 
+     */
+    public function getUsers() {
+
+        $re = array();
+        foreach($this->users as $userName=>$A1) {
+
+            $re[] = array(
+                'uri'=>'principals/' . $userName
+            );
+
+        }
+
+        return $re;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Auth/Backend/PDO.php

@@ -0,0 +1,79 @@
+<?php
+
+/**
+ * This is an authentication backend that uses a file to manage passwords.
+ *
+ * The backend file must conform to Apache's htdigest format
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Auth_Backend_PDO extends Sabre_DAV_Auth_Backend_AbstractDigest {
+
+    private $pdo;
+
+    /**
+     * Creates the backend object. 
+     *
+     * If the filename argument is passed in, it will parse out the specified file fist.
+     * 
+     * @param string $filename 
+     * @return void
+     */
+    public function __construct(PDO $pdo) {
+
+        $this->pdo = $pdo;
+
+    }
+
+    /**
+     * Returns a users' information 
+     * 
+     * @param string $realm 
+     * @param string $username 
+     * @return string 
+     */
+    public function getUserInfo($realm,$username) {
+
+        $stmt = $this->pdo->prepare('SELECT username, digesta1, email FROM users WHERE username = ?');
+        $stmt->execute(array($username));
+        $result = $stmt->fetchAll();
+
+        if (!count($result)) return false;
+        $user = array(
+            'uri' => 'principals/' . $result[0]['username'],
+            'digestHash' => $result[0]['digesta1'],
+        );
+        if ($result[0]['email']) $user['{http://sabredav.org/ns}email-address'] = $result[0]['email'];
+        return $user;
+
+    }
+
+    /**
+     * Returns a list of all users
+     *
+     * @return array
+     */
+    public function getUsers() {
+
+        $result = $this->pdo->query('SELECT username, email FROM users')->fetchAll();
+        
+        $rv = array();
+        foreach($result as $user) {
+
+            $r = array(
+                'uri' => 'principals/' . $user['username'],
+            );
+            if ($user['email']) $r['{http://sabredav.org/ns}email-address'] = $user['email'];
+            $rv[] = $r;
+
+        }
+
+        return $rv;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Auth/Backend/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/DAV/Auth/Plugin.php

@@ -0,0 +1,434 @@
+<?php
+
+/**
+ * This plugin provides Authentication for a WebDAV server.
+ * 
+ * It relies on a Backend object, which provides user information.
+ *
+ * Additionally, it provides support for:
+ *  * {DAV:}current-user-principal property from RFC5397
+ *  * {DAV:}principal-collection-set property from RFC3744
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Auth_Plugin extends Sabre_DAV_ServerPlugin {
+
+    /**
+     * Reference to main server object 
+     * 
+     * @var Sabre_DAV_Server 
+     */
+    private $server;
+
+    /**
+     * Authentication backend
+     * 
+     * @var Sabre_DAV_Auth_Backend_Abstract 
+     */
+    private $authBackend;
+
+    /**
+     * The authentication realm. 
+     * 
+     * @var string 
+     */
+    private $realm;
+
+    /**
+     * __construct 
+     * 
+     * @param Sabre_DAV_Auth_Backend_Abstract $authBackend 
+     * @param string $realm 
+     * @return void
+     */
+    public function __construct(Sabre_DAV_Auth_Backend_Abstract $authBackend, $realm) {
+
+        $this->authBackend = $authBackend;
+        $this->realm = $realm;
+
+    }
+
+    /**
+     * Initializes the plugin. This function is automatically called by the server  
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @return void
+     */
+    public function initialize(Sabre_DAV_Server $server) {
+
+        $this->server = $server;
+        $this->server->subscribeEvent('beforeMethod',array($this,'beforeMethod'),10);
+        $this->server->subscribeEvent('afterGetProperties',array($this,'afterGetProperties'));
+        $this->server->subscribeEvent('report',array($this,'report'));
+
+    }
+
+    /**
+     * This method intercepts calls to PROPFIND and similar lookups 
+     * 
+     * This is done to inject the current-user-principal if this is requested.
+     *
+     * @todo support for 'unauthenticated'
+     * @return void  
+     */
+    public function afterGetProperties($href, &$properties) {
+
+        if (array_key_exists('{DAV:}current-user-principal', $properties[404])) {
+            if ($ui = $this->authBackend->getCurrentUser()) {
+                $properties[200]['{DAV:}current-user-principal'] = new Sabre_DAV_Property_Principal(Sabre_DAV_Property_Principal::HREF, $ui['uri']);
+            } else {
+                $properties[200]['{DAV:}current-user-principal'] = new Sabre_DAV_Property_Principal(Sabre_DAV_Property_Principal::UNAUTHENTICATED);
+            }
+            unset($properties[404]['{DAV:}current-user-principal']);
+        }
+        if (array_key_exists('{DAV:}principal-collection-set', $properties[404])) {
+            $properties[200]['{DAV:}principal-collection-set'] = new Sabre_DAV_Property_Href('principals');
+            unset($properties[404]['{DAV:}principal-collection-set']);
+        }
+        if (array_key_exists('{DAV:}supported-report-set', $properties[200])) {
+            $properties[200]['{DAV:}supported-report-set']->addReport(array(
+                '{DAV:}expand-property',
+            ));
+        }
+
+
+    }
+
+    /**
+     * This method is called before any HTTP method and forces users to be authenticated
+     * 
+     * @param string $method
+     * @throws Sabre_DAV_Exception_NotAuthenticated
+     * @return bool 
+     */
+    public function beforeMethod($method, $uri) {
+
+        $this->authBackend->authenticate($this->server,$this->realm);
+
+    }
+
+    /**
+     * This functions handles REPORT requests 
+     * 
+     * @param string $reportName 
+     * @param DOMNode $dom 
+     * @return bool|null 
+     */
+    public function report($reportName,$dom) {
+
+        switch($reportName) { 
+            case '{DAV:}expand-property' :
+                $this->expandPropertyReport($dom);
+                return false;
+            case '{DAV:}principal-property-search' :
+                if ($this->server->getRequestUri()==='principals') {
+                    $this->principalPropertySearchReport($dom);
+                    return false;
+                }
+                break;
+            case '{DAV:}principal-search-property-set' :
+                if ($this->server->getRequestUri()==='principals') {
+                    $this->principalSearchPropertySetReport($dom);
+                    return false;
+                }
+                break;
+                 
+        }
+    
+    }
+
+    /**
+     * The expand-property report is defined in RFC3253 section 3-8. 
+     *
+     * This report is very similar to a standard PROPFIND. The difference is
+     * that it has the additional ability to look at properties containing a
+     * {DAV:}href element, follow that property and grab additional elements
+     * there.
+     *
+     * Other rfc's, such as ACL rely on this report, so it made sense to put
+     * it in this plugin.
+     *
+     * @param DOMElement $dom 
+     * @return void
+     */
+    protected function expandPropertyReport($dom) {
+
+        $requestedProperties = $this->parseExpandPropertyReportRequest($dom->firstChild->firstChild);
+        $depth = $this->server->getHTTPDepth(0);
+        $requestUri = $this->server->getRequestUri();
+
+        $result = $this->expandProperties($requestUri,$requestedProperties,$depth);
+
+        $dom = new DOMDocument('1.0','utf-8');
+        $dom->formatOutput = true;
+        $multiStatus = $dom->createElement('d:multistatus');
+        $dom->appendChild($multiStatus);
+
+        // Adding in default namespaces
+        foreach($this->server->xmlNamespaces as $namespace=>$prefix) {
+
+            $multiStatus->setAttribute('xmlns:' . $prefix,$namespace);
+
+        }
+
+        foreach($result as $entry) {
+
+            $entry->serialize($this->server,$multiStatus);
+
+        }
+
+        $xml = $dom->saveXML();
+        $this->server->httpResponse->setHeader('Content-Type','application/xml; charset=utf-8');
+        $this->server->httpResponse->sendStatus(207);
+        $this->server->httpResponse->sendBody($xml);
+
+        // Make sure the event chain is broken
+        return false;
+
+    }
+
+    /**
+     * This method is used by expandPropertyReport to parse
+     * out the entire HTTP request.
+     * 
+     * @param DOMElement $node 
+     * @return array 
+     */
+    protected function parseExpandPropertyReportRequest($node) {
+
+        $requestedProperties = array();
+        do {
+
+            if (Sabre_DAV_XMLUtil::toClarkNotation($node)!=='{DAV:}property') continue;
+                
+            if ($node->firstChild) {
+                
+                $children = $this->parseExpandPropertyReportRequest($node->firstChild);
+
+            } else {
+
+                $children = array();
+
+            }
+
+            $namespace = $node->getAttribute('namespace');
+            if (!$namespace) $namespace = 'DAV:';
+
+            $propName = '{'.$namespace.'}' . $node->getAttribute('name');
+            $requestedProperties[$propName] = $children; 
+
+        } while ($node = $node->nextSibling);
+
+        return $requestedProperties;
+
+    }
+
+    /**
+     * This method expands all the properties and returns
+     * a list with property values
+     *
+     * @param array $path
+     * @param array $requestedProperties the list of required properties
+     * @param array $depth
+     */
+    protected function expandProperties($path,array $requestedProperties,$depth) { 
+
+        $foundProperties = $this->server->getPropertiesForPath($path,array_keys($requestedProperties),$depth);
+
+        $result = array();
+
+        foreach($foundProperties as $node) {
+
+            foreach($requestedProperties as $propertyName=>$childRequestedProperties) {
+
+                // We're only traversing if sub-properties were requested
+                if(count($childRequestedProperties)===0) continue;
+                
+                // We only have to do the expansion if the property was found
+                // and it contains an href element.
+                if (!array_key_exists($propertyName,$node[200])) continue;
+                if (!($node[200][$propertyName] instanceof Sabre_DAV_Property_IHref)) continue;
+
+                $href = $node[200][$propertyName]->getHref();
+                list($node[200][$propertyName]) = $this->expandProperties($href,$childRequestedProperties,0);
+
+            }
+            $result[] = new Sabre_DAV_Property_Response($path, $node);
+
+        }
+
+        return $result;
+
+    }
+
+    protected function principalSearchPropertySetReport(DOMDocument $dom) {
+
+        $searchProperties = array(
+            '{DAV:}displayname' => 'display name'
+
+        );
+
+        $httpDepth = $this->server->getHTTPDepth(0);
+        if ($httpDepth!==0) {
+            throw new Sabre_DAV_Exception_BadRequest('This report is only defined when Depth: 0');
+        }
+        
+        if ($dom->firstChild->hasChildNodes()) 
+            throw new Sabre_DAV_Exception_BadRequest('The principal-search-property-set report element is not allowed to have child elements'); 
+
+        $dom = new DOMDocument('1.0','utf-8');
+        $dom->formatOutput = true;
+        $root = $dom->createElement('d:principal-search-property-set');
+        $dom->appendChild($root);
+        // Adding in default namespaces
+        foreach($this->server->xmlNamespaces as $namespace=>$prefix) {
+
+            $root->setAttribute('xmlns:' . $prefix,$namespace);
+
+        }
+
+        $nsList = $this->server->xmlNamespaces; 
+
+        foreach($searchProperties as $propertyName=>$description) {
+
+            $psp = $dom->createElement('d:principal-search-property');
+            $root->appendChild($psp);
+
+            $prop = $dom->createElement('d:prop');
+            $psp->appendChild($prop);
+  
+            $propName = null;
+            preg_match('/^{([^}]*)}(.*)$/',$propertyName,$propName);
+
+            //if (!isset($nsList[$propName[1]])) {
+            //    $nsList[$propName[1]] = 'x' . count($nsList);
+            //}
+
+            // If the namespace was defined in the top-level xml namespaces, it means 
+            // there was already a namespace declaration, and we don't have to worry about it.
+            //if (isset($server->xmlNamespaces[$propName[1]])) {
+                $currentProperty = $dom->createElement($nsList[$propName[1]] . ':' . $propName[2]);
+            //} else {
+            //    $currentProperty = $dom->createElementNS($propName[1],$nsList[$propName[1]].':' . $propName[2]);
+            //}
+            $prop->appendChild($currentProperty);
+
+            $descriptionElem = $dom->createElement('d:description');
+            $descriptionElem->setAttribute('xml:lang','en');
+            $descriptionElem->appendChild($dom->createTextNode($description));
+            $psp->appendChild($descriptionElem);
+
+
+        }
+
+        $this->server->httpResponse->setHeader('Content-Type','application/xml; charset=utf-8');
+        $this->server->httpResponse->sendStatus(200);
+        $this->server->httpResponse->sendBody($dom->saveXML());
+
+    }
+
+    protected function principalPropertySearchReport($dom) {
+
+        $searchableProperties = array(
+            '{DAV:}displayname' => 'display name'
+
+        );
+
+        list($searchProperties, $requestedProperties) = $this->parsePrincipalPropertySearchReportRequest($dom);
+
+        $uri = $this->server->getRequestUri();
+        
+        $result = array();
+
+        $lookupResults = $this->server->getPropertiesForPath($uri, array_keys($searchProperties), 1);
+
+        // The first item in the results is the parent, so we get rid of it.
+        array_shift($lookupResults);
+
+        $matches = array();
+
+        foreach($lookupResults as $lookupResult) {
+
+            foreach($searchProperties as $searchProperty=>$searchValue) {
+                if (!isset($searchableProperties[$searchProperty])) {
+                    throw new Sabre_DAV_Exception_BadRequest('Searching for ' . $searchProperty . ' is not supported');
+                }
+                
+                if (isset($lookupResult[200][$searchProperty]) &&
+                    mb_stripos($lookupResult[200][$searchProperty], $searchValue, 0, 'UTF-8')!==false) {
+                        $matches[] = $lookupResult['href'];
+                }
+
+            }
+
+        }
+
+        $matchProperties = array();
+
+        foreach($matches as $match) {
+            
+           list($result) = $this->server->getPropertiesForPath($match, $requestedProperties, 0);
+           $matchProperties[] = $result;
+
+        }
+
+        $xml = $this->server->generateMultiStatus($matchProperties);
+        $this->server->httpResponse->setHeader('Content-Type','application/xml; charset=utf-8');
+        $this->server->httpResponse->sendStatus(207);
+        $this->server->httpResponse->sendBody($xml);
+
+    }
+
+    protected function parsePrincipalPropertySearchReportRequest($dom) {
+
+        $httpDepth = $this->server->getHTTPDepth(0);
+        if ($httpDepth!==0) {
+            throw new Sabre_DAV_Exception_BadRequest('This report is only defined when Depth: 0');
+        }
+
+        $searchProperties = array();
+
+        // Parsing the search request
+        foreach($dom->firstChild->childNodes as $searchNode) {
+
+            if (Sabre_DAV_XMLUtil::toClarkNotation($searchNode)!=='{DAV:}property-search')
+                continue;
+
+            $propertyName = null;
+            $propertyValue = null;
+
+            foreach($searchNode->childNodes as $childNode) {
+
+                switch(Sabre_DAV_XMLUtil::toClarkNotation($childNode)) {
+
+                    case '{DAV:}prop' :
+                        $property = Sabre_DAV_XMLUtil::parseProperties($searchNode);
+                        reset($property); 
+                        $propertyName = key($property);
+                        break;
+
+                    case '{DAV:}match' :
+                        $propertyValue = $childNode->textContent;
+                        break;
+
+                }
+
+
+            }
+
+            if (is_null($propertyName) || is_null($propertyValue))
+                throw new Sabre_DAV_Exception_BadRequest('Invalid search request. propertyname: ' . $propertyName . '. propertvvalue: ' . $propertyValue);
+
+            $searchProperties[$propertyName] = $propertyValue;
+
+        }
+
+        return array($searchProperties, array_keys(Sabre_DAV_XMLUtil::parseProperties($dom->firstChild)));
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Auth/Principal.php

@@ -0,0 +1,147 @@
+<?php
+
+/**
+ * Principal class
+ *
+ * This class represents a user in the directory tree.
+ * Many WebDAV specs require a user to show up in the directory 
+ * structure. The principal is defined in RFC 3744.
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Auth_Principal extends Sabre_DAV_Node implements Sabre_DAV_IProperties {
+
+    /**
+     * Full uri for this principal resource 
+     * 
+     * @var string 
+     */
+    protected $principalUri;/*noLibHook*/
+
+    /**
+     * Struct with principal information.
+     *
+     * @var array 
+     */
+    protected $principalProperties;
+
+    /**
+     * Creates the principal object 
+     *
+     * @param string $principalUri Full uri to the principal resource
+     * @param array $principalProperties
+     */
+    public function __construct($principalUri,array $principalProperties = array()) {
+
+        $this->principalUri = $principalUri;
+        $this->principalProperties = $principalProperties;
+
+    }
+
+    /**
+     * Returns the name of the element 
+     * 
+     * @return void
+     */
+    public function getName() {
+
+        list(, $name) = Sabre_DAV_URLUtil::splitPath($this->principalUri);
+        return $name;
+
+    }
+
+    /**
+     * Returns the name of the user 
+     * 
+     * @return void
+     */
+    public function getDisplayName() {
+
+        if (isset($this->principalProperties['{DAV:}displayname'])) {
+            return $this->principalProperties['{DAV:}displayname'];
+        } else {
+            return $this->getName();
+        }
+
+    }
+
+    /**
+     * Returns a list of properties 
+     * 
+     * @param array $requestedProperties 
+     * @return void
+     */
+    public function getProperties($requestedProperties) {
+
+        if (!count($requestedProperties)) {
+           
+            // If all properties were requested
+            // we will only returns properties from this list
+            $requestedProperties = array(
+                '{DAV:}resourcetype',
+                '{DAV:}displayname',
+            );
+
+        }
+
+        // We need to always return the resourcetype
+        // This is a bug in the core server, but it is easier to do it this way for now
+        $newProperties = array(
+            '{DAV:}resourcetype' => new Sabre_DAV_Property_ResourceType('{DAV:}principal')
+        );
+        foreach($requestedProperties as $propName) switch($propName) {
+            
+            case '{DAV:}alternate-URI-set' :
+                if (isset($this->principalProperties['{http://sabredav.org/ns}email-address'])) {
+                    $href = 'mailto:' . $this->principalProperties['{http://sabredav.org/ns}email-address'];
+                    $newProperties[$propName] = new Sabre_DAV_Property_Href($href);
+                } else {
+                    $newProperties[$propName] = null;
+                }
+                break;
+            case '{DAV:}group-member-set' :
+            case '{DAV:}group-membership' :
+                $newProperties[$propName] = null;
+                break;
+
+            case '{DAV:}principal-URL' :
+                $newProperties[$propName] = new Sabre_DAV_Property_Href($this->principalUri);
+                break;
+
+            case '{DAV:}displayname' :
+                $newProperties[$propName] = $this->getDisplayName();
+                break;
+
+            default :
+                if (isset($this->principalProperties[$propName])) {
+                    $newProperties[$propName] = $this->principalProperties[$propName];
+                }
+                break;
+
+        }
+
+        return $newProperties;
+        
+
+    }
+
+    /**
+     * Updates this principals properties.
+     *
+     * Currently this is not supported
+     * 
+     * @param array $properties
+     * @see Sabre_DAV_IProperties::updateProperties
+     * @return bool|array 
+     */
+    public function updateProperties($properties) {
+
+        return false;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Auth/PrincipalCollection.php

@@ -0,0 +1,74 @@
+<?php
+
+/**
+ * Principals Collection
+ *
+ * This collection represents a list of users. It uses
+ * Sabre_DAV_Auth_Backend to determine which users are available on the list.
+ *
+ * The users are instances of Sabre_DAV_Auth_Principal
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Auth_PrincipalCollection extends Sabre_DAV_Directory {
+
+    /**
+     * The name of this object. It is not adviced to change this.
+     * The plugins that depend on the principals collection to exist need to 
+     * be have a common name to find it.
+     */
+    const NODENAME = 'principals';
+
+    /**
+     * Authentication backend 
+     * 
+     * @var Sabre_DAV_Auth_Backend 
+     */
+    protected $authBackend;
+
+    /**
+     * Creates the object 
+     * 
+     * @param Sabre_DAV_Auth_Backend_Abstract $authBackend 
+     */
+    public function __construct(Sabre_DAV_Auth_Backend_Abstract $authBackend) {
+
+        $this->authBackend = $authBackend;
+
+    }
+
+    /**
+     * Returns the name of this collection. 
+     * 
+     * @return string 
+     */
+    public function getName() {
+
+        return self::NODENAME; 
+
+    }
+
+    /**
+     * Retursn the list of users 
+     * 
+     * @return void
+     */
+    public function getChildren() {
+
+        $children = array();
+        foreach($this->authBackend->getUsers() as $principalInfo) {
+
+            $principalUri = $principalInfo['uri'] . '/';
+            $children[] = new Sabre_DAV_Auth_Principal($principalUri,$principalInfo);
+
+
+        }
+        return $children; 
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Auth/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/DAV/Browser/GuessContentType.php

@@ -0,0 +1,97 @@
+<?php
+
+/**
+ * GuessContentType plugin
+ *
+ * A lot of the built-in File objects just return application/octet-stream
+ * as a content-type by default. This is a problem for some clients, because
+ * they expect a correct contenttype.
+ *
+ * There's really no accurate, fast and portable way to determine the contenttype
+ * so this extension does what the rest of the world does, and guesses it based
+ * on the file extension.
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Browser_GuessContentType extends Sabre_DAV_ServerPlugin {
+
+    /**
+     * List of recognized file extensions
+     *
+     * Feel free to add more
+     *
+     * @var array
+     */
+    public $extensionMap = array(
+
+        // images
+        'jpg' => 'image/jpeg',
+        'gif' => 'image/gif',
+        'png' => 'image/png',
+
+        // groupware
+        'ics' => 'text/calendar',
+        'vcf' => 'text/x-vcard',
+
+        // text
+        'txt' => 'text/plain',
+
+    );
+
+    /**
+     * Initializes the plugin 
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @return void
+     */
+    public function initialize(Sabre_DAV_Server $server) {
+
+        // Using a relatively low priority (200) to allow other extensions
+        // to set the content-type first.
+        $server->subscribeEvent('afterGetProperties',array($this,'afterGetProperties'),200);
+
+    }
+
+    /**
+     * Handler for teh afterGetProperties event 
+     * 
+     * @param string $path 
+     * @param array $properties 
+     * @return void
+     */
+    public function afterGetProperties($path, &$properties) {
+
+        if (array_key_exists('{DAV:}getcontenttype', $properties[404])) {
+           
+            list(, $fileName) = Sabre_DAV_URLUtil::splitPath($path);
+            $contentType = $this->getContentType($fileName);
+
+            if ($contentType) {
+                $properties[200]['{DAV:}getcontenttype'] = $contentType;
+                unset($properties[404]['{DAV:}getcontenttype']);
+            }
+
+        }
+
+    }
+
+    /**
+     * Simple method to return the contenttype
+     * 
+     * @param string $fileName 
+     * @return string 
+     */
+    protected function getContentType($fileName) {
+
+        // Just grabbing the extension
+        $extension = substr($fileName,strrpos($fileName,'.')+1);
+        if (isset($this->extensionMap[$extension]))
+            return $this->extensionMap[$extension];
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Browser/MapGetToPropFind.php

@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * This is a simple plugin that will map any GET request for non-files to 
+ * PROPFIND allprops-requests.
+ *
+ * This should allow easy debugging of PROPFIND
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/)
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Browser_MapGetToPropFind extends Sabre_DAV_ServerPlugin {
+
+    /**
+     * reference to server class 
+     * 
+     * @var Sabre_DAV_Server 
+     */
+    protected $server;
+
+    /**
+     * Initializes the plugin and subscribes to events 
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @return void
+     */
+    public function initialize(Sabre_DAV_Server $server) {
+
+        $this->server = $server;
+        $this->server->subscribeEvent('beforeMethod',array($this,'httpGetInterceptor'));
+    }
+
+    /**
+     * This method intercepts GET requests to non-files, and changes it into an HTTP PROPFIND request 
+     * 
+     * @param string $method 
+     * @return bool 
+     */
+    public function httpGetInterceptor($method, $uri) {
+
+        if ($method!='GET') return true;
+       
+        $node = $this->server->tree->getNodeForPath($uri);
+        if ($node instanceof Sabre_DAV_IFile) return;
+
+        $this->server->invokeMethod('PROPFIND',$uri);
+        return false;
+        
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Browser/Plugin.php

@@ -0,0 +1,248 @@
+<?php
+
+/**
+ * Browser Plugin
+ *
+ * This plugin provides a html representation, so that a WebDAV server may be accessed
+ * using a browser.
+ *
+ * The class intercepts GET requests to collection resources and generates a simple 
+ * html index. 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/)
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Browser_Plugin extends Sabre_DAV_ServerPlugin {
+
+    /**
+     * reference to server class 
+     * 
+     * @var Sabre_DAV_Server 
+     */
+    protected $server;
+
+    /**
+     * enableEditing
+     * 
+     * @var bool 
+     */
+    protected $enablePost = true;
+
+    /**
+     * Creates the object.
+     *
+     * By default it will allow file creation and uploads.
+     * Specify the first argument as false to disable this
+     * 
+     * @param bool $enablePost 
+     * @return void
+     */
+    public function __construct($enablePost=true) {
+
+        $this->enablePost = $enablePost; 
+
+    }
+
+    /**
+     * Initializes the plugin and subscribes to events 
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @return void
+     */
+    public function initialize(Sabre_DAV_Server $server) {
+
+        $this->server = $server;
+        $this->server->subscribeEvent('beforeMethod',array($this,'httpGetInterceptor'));
+        if ($this->enablePost) $this->server->subscribeEvent('unknownMethod',array($this,'httpPOSTHandler'));
+    }
+
+    /**
+     * This method intercepts GET requests to collections and returns the html 
+     * 
+     * @param string $method 
+     * @return bool 
+     */
+    public function httpGetInterceptor($method, $uri) {
+
+        if ($method!='GET') return true;
+        
+        $node = $this->server->tree->getNodeForPath($uri);
+        if ($node instanceof Sabre_DAV_IFile) return true;
+
+        $this->server->httpResponse->sendStatus(200);
+        $this->server->httpResponse->setHeader('Content-Type','text/html; charset=utf-8');
+
+        $this->server->httpResponse->sendBody(
+            $this->generateDirectoryIndex($uri)
+        );
+
+        return false;
+        
+    }
+
+    /**
+     * Handles POST requests for tree operations
+     * 
+     * This method is not yet used.
+     * 
+     * @param string $method 
+     * @return bool
+     */
+    public function httpPOSTHandler($method, $uri) {
+
+        if ($method!='POST') return true;
+        if (isset($_POST['action'])) switch($_POST['action']) {
+
+            case 'mkcol' :
+                if (isset($_POST['name']) && trim($_POST['name'])) {
+                    // Using basename() because we won't allow slashes
+                    list(, $folderName) = Sabre_DAV_URLUtil::splitPath(trim($_POST['name']));
+                    $this->server->createDirectory($uri . '/' . $folderName);
+                }
+                break;
+            case 'put' :
+                if ($_FILES) $file = current($_FILES);
+                else break;
+                $newName = trim($file['name']);
+                list(, $newName) = Sabre_DAV_URLUtil::splitPath(trim($file['name']));
+                if (isset($_POST['name']) && trim($_POST['name']))
+                    $newName = trim($_POST['name']);
+
+                // Making sure we only have a 'basename' component
+                list(, $newName) = Sabre_DAV_URLUtil::splitPath($newName);
+                    
+               
+                if (is_uploaded_file($file['tmp_name'])) {
+                    $parent = $this->server->tree->getNodeForPath(trim($uri,'/'));
+                    $parent->createFile($newName,fopen($file['tmp_name'],'r'));
+                }
+
+        }
+        $this->server->httpResponse->setHeader('Location',$this->server->httpRequest->getUri());
+        return false;
+
+    }
+
+    /**
+     * Escapes a string for html. 
+     * 
+     * @param string $value 
+     * @return void
+     */
+    public function escapeHTML($value) {
+
+        return htmlspecialchars($value,ENT_QUOTES,'UTF-8');
+
+    }
+
+    /**
+     * Generates the html directory index for a given url 
+     *
+     * @param string $path 
+     * @return string 
+     */
+    public function generateDirectoryIndex($path) {
+
+        $html = "<html>
+<head>
+  <title>Index for " . $this->escapeHTML($path) . "/ - SabreDAV " . Sabre_DAV_Version::VERSION . "</title>
+  <style type=\"text/css\"> body { Font-family: arial}</style>
+</head>
+<body>
+  <h1>Index for " . $this->escapeHTML($path) . "/</h1>
+  <table>
+    <tr><th>Name</th><th>Type</th><th>Size</th><th>Last modified</th></tr>
+    <tr><td colspan=\"4\"><hr /></td></tr>";
+    
+    $files = $this->server->getPropertiesForPath($path,array(
+        '{DAV:}displayname',
+        '{DAV:}resourcetype',
+        '{DAV:}getcontenttype',
+        '{DAV:}getcontentlength',
+        '{DAV:}getlastmodified',
+    ),1);
+
+    foreach($files as $k=>$file) {
+
+        // This is the current directory, we can skip it
+        if (rtrim($file['href'],'/')==$path) continue;
+
+        list(, $name) = Sabre_DAV_URLUtil::splitPath($file['href']);
+
+        $type = null;
+
+        if (isset($file[200]['{DAV:}resourcetype'])) {
+            $type = $file[200]['{DAV:}resourcetype']->getValue();
+
+            // resourcetype can have multiple values
+            if (is_array($type)) {
+                $type = implode(', ', $type);
+            }
+
+            // Some name mapping is preferred 
+            switch($type) {
+                case '{DAV:}collection' :
+                    $type = 'Collection';
+                    break;
+            }
+        }
+
+        // If no resourcetype was found, we attempt to use
+        // the contenttype property
+        if (!$type && isset($file[200]['{DAV:}getcontenttype'])) {
+            $type = $file[200]['{DAV:}getcontenttype'];
+        }
+        if (!$type) $type = 'Unknown';
+
+        $size = isset($file[200]['{DAV:}getcontentlength'])?(int)$file[200]['{DAV:}getcontentlength']:'';
+        $lastmodified = isset($file[200]['{DAV:}getlastmodified'])?$file[200]['{DAV:}getlastmodified']->getTime()->format(DateTime::ATOM):'';
+
+        $fullPath = Sabre_DAV_URLUtil::encodePath('/' . trim($this->server->getBaseUri() . ($path?$path . '/':'') . $name,'/'));
+
+        $displayName = isset($file[200]['{DAV:}displayname'])?$file[200]['{DAV:}displayname']:$name;
+
+        $name = $this->escapeHTML($name);
+        $displayName = $this->escapeHTML($displayName);
+        $type = $this->escapeHTML($type);
+
+        $html.= "<tr>
+<td><a href=\"{$fullPath}\">{$displayName}</a></td>
+<td>{$type}</td>
+<td>{$size}</td>
+<td>{$lastmodified}</td>
+</tr>";
+
+    }
+
+  $html.= "<tr><td colspan=\"4\"><hr /></td></tr>";
+
+  if ($this->enablePost) {
+      $html.= '<tr><td><form method="post" action="">
+            <h3>Create new folder</h3>
+            <input type="hidden" name="action" value="mkcol" />
+            Name: <input type="text" name="name" /><br />
+            <input type="submit" value="create" />
+            </form>
+            <form method="post" action="" enctype="multipart/form-data">
+            <h3>Upload file</h3>
+            <input type="hidden" name="action" value="put" />
+            Name (optional): <input type="text" name="name" /><br />
+            File: <input type="file" name="file" /><br />
+            <input type="submit" value="upload" />
+            </form>
+       </td></tr>';
+  }
+
+  $html.= "</table>
+  <address>Generated by SabreDAV " . Sabre_DAV_Version::VERSION ."-". Sabre_DAV_Version::STABILITY . " (c)2007-2010 <a href=\"http://code.google.com/p/sabredav/\">http://code.google.com/p/sabredav/</a></address>
+</body>
+</html>";
+
+        return $html; 
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Browser/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/DAV/Directory.php

@@ -0,0 +1,90 @@
+<?php
+
+/**
+ * Directory class
+ *
+ * This is a helper class, that should aid in getting directory classes setup.
+ * Most of its methods are implemented, and throw permission denied exceptions 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_Directory extends Sabre_DAV_Node implements Sabre_DAV_ICollection {
+
+    /**
+     * Returns a child object, by its name.
+     *
+     * This method makes use of the getChildren method to grab all the child nodes, and compares the name. 
+     * Generally its wise to override this, as this can usually be optimized
+     * 
+     * @param string $name
+     * @throws Sabre_DAV_Exception_FileNotFound
+     * @return Sabre_DAV_INode 
+     */
+    public function getChild($name) {
+
+        foreach($this->getChildren() as $child) {
+
+            if ($child->getName()==$name) return $child;
+
+        }
+        throw new Sabre_DAV_Exception_FileNotFound('File not found: ' . $name);
+
+    }
+
+    /**
+     * Checks is a child-node exists.
+     *
+     * It is generally a good idea to try and override this. Usually it can be optimized.
+     * 
+     * @param string $name 
+     * @return bool 
+     */
+    public function childExists($name) {
+
+        try {
+
+            $this->getChild($name);
+            return true;
+
+        } catch(Sabre_DAV_Exception_FileNotFound $e) {
+
+            return false;
+
+        }
+
+    }
+
+    /**
+     * Creates a new file in the directory 
+     * 
+     * @param string $name Name of the file 
+     * @param resource $data Initial payload, passed as a readable stream resource. 
+     * @throws Sabre_DAV_Exception_Forbidden
+     * @return void
+     */
+    public function createFile($name, $data = null) {
+
+        throw new Sabre_DAV_Exception_Forbidden('Permission denied to create file (filename ' . $name . ')');
+
+    }
+
+    /**
+     * Creates a new subdirectory 
+     * 
+     * @param string $name 
+     * @throws Sabre_DAV_Exception_Forbidden
+     * @return void
+     */
+    public function createDirectory($name) {
+
+        throw new Sabre_DAV_Exception_Forbidden('Permission denied to create directory');
+
+    }
+
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Exception.php

@@ -0,0 +1,63 @@
+<?php
+
+/**
+ * SabreDAV base exception
+ *
+ * This is SabreDAV's base exception file, use this to implement your own exception.
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+
+/**
+ * Main Exception class. 
+ *
+ * This class defines a getHTTPCode method, which should return the appropriate HTTP code for the Exception occured.
+ * The default for this is 500.
+ *
+ * This class also allows you to generate custom xml data for your exceptions. This will be displayed
+ * in the 'error' element in the failing response.
+ */
+class Sabre_DAV_Exception extends Exception { 
+
+    /**
+     * Returns the HTTP statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() { 
+
+        return 500;
+
+    }
+
+    /**
+     * This method allows the exception to include additonal information into the WebDAV error response 
+     *
+     * @param Sabre_DAV_Server $server
+     * @param DOMElement $errorNode 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $errorNode) {
+    
+
+    }
+
+    /**
+     * This method allows the exception to return any extra HTTP response headers.
+     *
+     * The headers must be returned as an array.
+     * 
+     * @return array 
+     */
+    public function getHTTPHeaders(Sabre_DAV_Server $server) {
+
+        return array();
+
+    } 
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Exception/BadRequest.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * BadRequest
+ *
+ * The BadRequest is thrown when the user submitted an invalid HTTP request
+ * BadRequest 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_BadRequest extends Sabre_DAV_Exception {
+
+    /**
+     * Returns the HTTP statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+
+        return 400; 
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/Conflict.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * Conflict
+ *
+ * A 409 Conflict is thrown when a user tried to make a directory over an existing
+ * file or in a parent directory that doesn't exist.
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_Conflict extends Sabre_DAV_Exception {
+
+    /**
+     * Returns the HTTP statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+
+        return 409;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/ConflictingLock.php

@@ -0,0 +1,35 @@
+<?php
+
+/**
+ * ConflictingLock 
+ *
+ * Similar to Exception_Locked, this exception thrown when a LOCK request 
+ * was made, on a resource which was already locked
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_ConflictingLock extends Sabre_DAV_Exception_Locked {
+
+    /**
+     * This method allows the exception to include additonal information into the WebDAV error response 
+     *
+     * @param Sabre_DAV_Server $server
+     * @param DOMElement $errorNode 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $errorNode) {
+        
+        if ($this->lock) {
+            $error = $errorNode->ownerDocument->createElementNS('DAV:','d:no-conflicting-lock');
+            $errorNode->appendChild($error);
+            if (!is_object($this->lock)) var_dump($this->lock);
+            $error->appendChild($errorNode->ownerDocument->createElementNS('DAV:','d:href',$this->lock->uri));
+        }
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/FileNotFound.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * FileNotFound
+ *
+ * This Exception is thrown when a Node couldn't be found. It returns HTTP error code 404
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_FileNotFound extends Sabre_DAV_Exception {
+
+    /**
+     * Returns the HTTP statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+
+        return 404;
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Exception/Forbidden.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * Forbidden
+ *
+ * This exception is thrown whenever a user tries to do an operation he's not allowed to
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_Forbidden extends Sabre_DAV_Exception {
+
+    /**
+     * Returns the HTTP statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+
+        return 403;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/InsufficientStorage.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * InsufficientStorage 
+ *
+ * This Exception can be thrown, when for example a harddisk is full or a quota is exceeded
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_InsufficientStorage extends Sabre_DAV_Exception {
+
+    /**
+     * Returns the HTTP statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+
+        return 507;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/InvalidResourceType.php

@@ -0,0 +1,33 @@
+<?php
+
+/**
+ * InvalidResourceType 
+ *
+ * This exception is thrown when the user tried to create a new collection, with
+ * a special resourcetype value that was not recognized by the server.
+ *
+ * See RFC5689 section 3.3
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_InvalidResourceType extends Sabre_DAV_Exception_Forbidden { 
+
+    /**
+     * This method allows the exception to include additonal information into the WebDAV error response 
+     *
+     * @param Sabre_DAV_Server $server
+     * @param DOMElement $errorNode 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $errorNode) {
+
+        $error = $errorNode->ownerDocument->createElementNS('DAV:','d:valid-resourcetype');
+        $errorNode->appendChild($error);
+
+    }
+    
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/LockTokenMatchesRequestUri.php

@@ -0,0 +1,39 @@
+<?php
+
+/**
+ * LockTokenMatchesRequestUri 
+ *
+ * This exception is thrown by UNLOCK if a supplied lock-token is invalid 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_LockTokenMatchesRequestUri extends Sabre_DAV_Exception_Conflict {
+
+    /**
+     * Creates the exception
+     */
+    public function __construct() {
+
+        $this->message = 'The locktoken supplied does not match any locks on this entity';
+
+    }
+
+    /**
+     * This method allows the exception to include additonal information into the WebDAV error response 
+     *
+     * @param Sabre_DAV_Server $server
+     * @param DOMElement $errorNode 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $errorNode) {
+
+        $error = $errorNode->ownerDocument->createElementNS('DAV:','d:lock-token-matches-request-uri');
+        $errorNode->appendChild($error);
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/Locked.php

@@ -0,0 +1,67 @@
+<?php
+
+/**
+ * Locked 
+ *
+ * The 423 is thrown when a client tried to access a resource that was locked, without supplying a valid lock token
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_Locked extends Sabre_DAV_Exception {
+
+    /**
+     * Lock information 
+     * 
+     * @var Sabre_DAV_Locks_LockInfo 
+     */
+    protected $lock;
+
+    /**
+     * Creates the exception
+     * 
+     * A LockInfo object should be passed if the user should be informed
+     * which lock actually has the file locked.
+     * 
+     * @param Sabre_DAV_Locks_LockInfo $lock 
+     */
+    public function __construct(Sabre_DAV_Locks_LockInfo $lock = null) {
+
+        $this->lock = $lock;
+
+    }
+
+    /**
+     * Returns the HTTP statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+
+        return 423;
+
+    }
+
+    /**
+     * This method allows the exception to include additonal information into the WebDAV error response 
+     *
+     * @param Sabre_DAV_Server $server
+     * @param DOMElement $errorNode 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $errorNode) {
+        
+        if ($this->lock) {
+            $error = $errorNode->ownerDocument->createElementNS('DAV:','d:lock-token-submitted');
+            $errorNode->appendChild($error);
+            if (!is_object($this->lock)) var_dump($this->lock);
+            $error->appendChild($errorNode->ownerDocument->createElementNS('DAV:','d:href',$this->lock->uri));
+        }
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Exception/MethodNotAllowed.php

@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * MethodNotAllowed
+ *
+ * The 405 is thrown when a client tried to create a directory on an already existing directory
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_MethodNotAllowed extends Sabre_DAV_Exception {
+
+    /**
+     * Returns the HTTP statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+
+        return 405;
+
+    }
+
+    /**
+     * This method allows the exception to return any extra HTTP response headers.
+     *
+     * The headers must be returned as an array.
+     * 
+     * @return array 
+     */
+    public function getHTTPHeaders(Sabre_DAV_Server $server) {
+
+        $methods = $server->getAllowedMethods($server->getRequestUri());
+
+        return array(
+            'Allow' => strtoupper(implode(', ',$methods)),
+        );
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/NotAuthenticated.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * NotAuthenticated
+ *
+ * This exception is thrown when the client did not provide valid
+ * authentication credentials.
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_NotAuthenticated extends Sabre_DAV_Exception {
+
+    /**
+     * Returns the HTTP statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+        
+        return 401;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/NotImplemented.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * NotImplemented
+ *
+ * This exception is thrown when the client tried to call an unsupported HTTP method or other feature
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_NotImplemented extends Sabre_DAV_Exception {
+
+    /**
+     * Returns the HTTP statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+        
+        return 501;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/PreconditionFailed.php

@@ -0,0 +1,69 @@
+<?php
+
+/**
+ * PreconditionFailed 
+ *
+ * This exception is normally thrown when a client submitted a conditional request, 
+ * like for example an If, If-None-Match or If-Match header, which caused the HTTP 
+ * request to not execute (the condition of the header failed)
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_PreconditionFailed extends Sabre_DAV_Exception {
+
+    /**
+     * When this exception is thrown, the header-name might be set.
+     * 
+     * This allows the exception-catching code to determine which HTTP header
+     * caused the exception.
+     * 
+     * @var string 
+     */
+    public $header = null;
+
+    /**
+     * Create the exception 
+     * 
+     * @param string $message 
+     * @param string $header 
+     */
+    public function __construct($message, $header=null) {
+
+        parent::__construct($message);
+        $this->header = $header;
+
+    } 
+
+    /**
+     * Returns the HTTP statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+
+        return 412; 
+
+    }
+
+    /**
+     * This method allows the exception to include additonal information into the WebDAV error response 
+     *
+     * @param Sabre_DAV_Server $server
+     * @param DOMElement $errorNode 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $errorNode) {
+        
+        if ($this->header) {
+            $prop = $errorNode->ownerDocument->createElement('s:header');
+            $prop->nodeValue = $this->header;
+            $errorNode->appendChild($prop);
+        }
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/ReportNotImplemented.php

@@ -0,0 +1,30 @@
+<?php
+
+/**
+ * ReportNotImplemented
+ *
+ * This exception is thrown when the client requested an unknown report through the REPORT method
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_ReportNotImplemented extends Sabre_DAV_Exception_NotImplemented {
+
+    /**
+     * This method allows the exception to include additonal information into the WebDAV error response 
+     *
+     * @param Sabre_DAV_Server $server
+     * @param DOMElement $errorNode 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $errorNode) {
+
+        $error = $errorNode->ownerDocument->createElementNS('DAV:','d:supported-report');
+        $errorNode->appendChild($error);
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/RequestedRangeNotSatisfiable.php

@@ -0,0 +1,29 @@
+<?php
+
+/**
+ * RequestedRangeNotSatisfiable 
+ *
+ * This exception is normally thrown when the user 
+ * request a range that is out of the entity bounds.
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_RequestedRangeNotSatisfiable extends Sabre_DAV_Exception {
+
+    /**
+     * returns the http statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+
+        return 416;
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Exception/UnsupportedMediaType.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * UnSupportedMediaType
+ *
+ * The 415 Unsupported Media Type status code is generally sent back when the client 
+ * tried to call an HTTP method, with a body the server didn't understand
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Exception_UnsupportedMediaType extends Sabre_DAV_Exception { 
+
+    /**
+     * returns the http statuscode for this exception 
+     *
+     * @return int
+     */
+    public function getHTTPCode() {
+
+        return 415;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Exception/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/DAV/FS/Directory.php

@@ -0,0 +1,121 @@
+<?php
+
+/**
+ * Directory class 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_FS_Directory extends Sabre_DAV_FS_Node implements Sabre_DAV_ICollection, Sabre_DAV_IQuota {
+
+    /**
+     * Creates a new file in the directory 
+     * 
+     * data is a readable stream resource
+     *
+     * @param string $name Name of the file 
+     * @param resource $data Initial payload 
+     * @return void
+     */
+    public function createFile($name, $data = null) {
+
+        $newPath = $this->path . '/' . $name;
+        file_put_contents($newPath,$data);
+
+    }
+
+    /**
+     * Creates a new subdirectory 
+     * 
+     * @param string $name 
+     * @return void
+     */
+    public function createDirectory($name) {
+
+        $newPath = $this->path . '/' . $name;
+        mkdir($newPath);
+
+    }
+
+    /**
+     * Returns a specific child node, referenced by its name 
+     * 
+     * @param string $name 
+     * @throws Sabre_DAV_Exception_FileNotFound
+     * @return Sabre_DAV_INode 
+     */
+    public function getChild($name) {
+
+        $path = $this->path . '/' . $name;
+
+        if (!file_exists($path)) throw new Sabre_DAV_Exception_FileNotFound('File with name ' . $path . ' could not be located');
+
+        if (is_dir($path)) {
+
+            return new Sabre_DAV_FS_Directory($path);
+
+        } else {
+
+            return new Sabre_DAV_FS_File($path);
+
+        }
+
+    }
+
+    /**
+     * Returns an array with all the child nodes 
+     * 
+     * @return Sabre_DAV_INode[] 
+     */
+    public function getChildren() {
+
+        $nodes = array();
+        foreach(scandir($this->path) as $node) if($node!='.' && $node!='..') $nodes[] = $this->getChild($node);
+        return $nodes;
+
+    }
+
+    /**
+     * Checks if a child exists. 
+     * 
+     * @param string $name 
+     * @return bool 
+     */
+    public function childExists($name) {
+
+        $path = $this->path . '/' . $name;
+        return file_exists($path);
+
+    }
+
+    /**
+     * Deletes all files in this directory, and then itself 
+     * 
+     * @return void
+     */
+    public function delete() {
+
+        foreach($this->getChildren() as $child) $child->delete();
+        rmdir($this->path);
+
+    }
+
+    /**
+     * Returns available diskspace information 
+     * 
+     * @return array 
+     */
+    public function getQuotaInfo() {
+
+        return array(
+            disk_total_space($this->path)-disk_free_space($this->path),
+            disk_free_space($this->path)
+            ); 
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/FS/File.php

@@ -0,0 +1,89 @@
+<?php
+
+/**
+ * File class 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_FS_File extends Sabre_DAV_FS_Node implements Sabre_DAV_IFile {
+
+    /**
+     * Updates the data 
+     * 
+     * @param resource $data 
+     * @return void 
+     */
+    public function put($data) {
+
+        file_put_contents($this->path,$data);
+
+    }
+
+    /**
+     * Returns the data 
+     * 
+     * @return string 
+     */
+    public function get() {
+
+        return fopen($this->path,'r');
+
+    }
+
+    /**
+     * Delete the current file
+     *
+     * @return void 
+     */
+    public function delete() {
+
+        unlink($this->path);
+
+    }
+
+    /**
+     * Returns the size of the node, in bytes 
+     * 
+     * @return int 
+     */
+    public function getSize() {
+        
+        return filesize($this->path);
+
+    }
+
+    /**
+     * Returns the ETag for a file
+     *
+     * An ETag is a unique identifier representing the current version of the file. If the file changes, the ETag MUST change.
+     * The ETag is an arbritrary string, but MUST be surrounded by double-quotes.
+     *
+     * Return null if the ETag can not effectively be determined
+     * 
+     * @return mixed
+     */
+    public function getETag() {
+
+        return null;
+
+    }
+
+    /**
+     * Returns the mime-type for a file
+     *
+     * If null is returned, we'll assume application/octet-stream
+     *
+     * @return mixed 
+     */ 
+    public function getContentType() {
+
+        return null;
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/FS/Node.php

@@ -0,0 +1,81 @@
+<?php
+
+/**
+ * Base node-class 
+ *
+ * The node class implements the method used by both the File and the Directory classes 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_FS_Node implements Sabre_DAV_INode {
+
+    /**
+     * The path to the current node
+     * 
+     * @var string 
+     */
+    protected $path; 
+
+    /**
+     * Sets up the node, expects a full path name 
+     * 
+     * @param string $path 
+     * @return void
+     */
+    public function __construct($path) {
+
+        $this->path = $path;
+
+    }
+
+
+
+    /**
+     * Returns the name of the node 
+     * 
+     * @return string 
+     */
+    public function getName() {
+
+        list(, $name)  = Sabre_DAV_URLUtil::splitPath($this->path);
+        return $name;
+
+    }
+
+    /**
+     * Renames the node
+     *
+     * @param string $name The new name
+     * @return void
+     */
+    public function setName($name) {
+
+        list($parentPath, ) = Sabre_DAV_URLUtil::splitPath($this->path);
+        list(, $newName) = Sabre_DAV_URLUtil::splitPath($name);
+
+        $newPath = $parentPath . '/' . $newName;
+        rename($this->path,$newPath);
+        
+        $this->path = $newPath;
+
+    }
+
+
+
+    /**
+     * Returns the last modification time, as a unix timestamp 
+     * 
+     * @return int 
+     */
+    public function getLastModified() {
+
+        return filemtime($this->path);
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/FS/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/DAV/FSExt/Directory.php

@@ -0,0 +1,135 @@
+<?php
+
+/**
+ * Directory class 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_FSExt_Directory extends Sabre_DAV_FSExt_Node implements Sabre_DAV_ICollection, Sabre_DAV_IQuota {
+
+    /**
+     * Creates a new file in the directory 
+     * 
+     * @param string $name Name of the file 
+     * @param resource $data Initial payload 
+     * @return void
+     */
+    public function createFile($name, $data = null) {
+
+        // We're not allowing dots
+        if ($name=='.' || $name=='..') throw new Sabre_DAV_Exception_Forbidden('Permission denied to . and ..');
+        $newPath = $this->path . '/' . $name;
+        file_put_contents($newPath,$data);
+
+    }
+
+    /**
+     * Creates a new subdirectory 
+     * 
+     * @param string $name 
+     * @return void
+     */
+    public function createDirectory($name) {
+
+        // We're not allowing dots
+        if ($name=='.' || $name=='..') throw new Sabre_DAV_Exception_Forbidden('Permission denied to . and ..');
+        $newPath = $this->path . '/' . $name;
+        mkdir($newPath);
+
+    }
+
+    /**
+     * Returns a specific child node, referenced by its name 
+     * 
+     * @param string $name 
+     * @throws Sabre_DAV_Exception_FileNotFound
+     * @return Sabre_DAV_INode 
+     */
+    public function getChild($name) {
+
+        $path = $this->path . '/' . $name;
+
+        if (!file_exists($path)) throw new Sabre_DAV_Exception_FileNotFound('File could not be located');
+        if ($name=='.' || $name=='..') throw new Sabre_DAV_Exception_Forbidden('Permission denied to . and ..'); 
+
+        if (is_dir($path)) {
+
+            return new Sabre_DAV_FSExt_Directory($path);
+
+        } else {
+
+            return new Sabre_DAV_FSExt_File($path);
+
+        }
+
+    }
+
+    /**
+     * Checks if a child exists. 
+     * 
+     * @param string $name 
+     * @return bool 
+     */
+    public function childExists($name) {
+
+        if ($name=='.' || $name=='..')
+            throw new Sabre_DAV_Exception_Forbidden('Permission denied to . and ..');
+
+        $path = $this->path . '/' . $name;
+        return file_exists($path);
+
+    }
+
+    /**
+     * Returns an array with all the child nodes 
+     * 
+     * @return Sabre_DAV_INode[] 
+     */
+    public function getChildren() {
+
+        $nodes = array();
+        foreach(scandir($this->path) as $node) if($node!='.' && $node!='..' && $node!='.sabredav') $nodes[] = $this->getChild($node);
+        return $nodes;
+
+    }
+
+    /**
+     * Deletes all files in this directory, and then itself 
+     * 
+     * @return void
+     */
+    public function delete() {
+
+        // Deleting all children
+        foreach($this->getChildren() as $child) $child->delete();
+
+        // Removing resource info, if its still around
+        if (file_exists($this->path . '/.sabredav')) unlink($this->path . '/.sabredav');
+
+        // Removing the directory itself
+        rmdir($this->path);
+
+        return parent::delete();
+
+    }
+
+    /**
+     * Returns available diskspace information 
+     * 
+     * @return array 
+     */
+    public function getQuotaInfo() {
+
+        return array(
+            disk_total_space($this->path)-disk_free_space($this->path),
+            disk_free_space($this->path)
+            ); 
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/FSExt/File.php

@@ -0,0 +1,88 @@
+<?php
+
+/**
+ * File class 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_FSExt_File extends Sabre_DAV_FSExt_Node implements Sabre_DAV_IFile {
+
+    /**
+     * Updates the data 
+     *
+     * data is a readable stream resource.
+     *
+     * @param resource $data 
+     * @return void 
+     */
+    public function put($data) {
+
+        file_put_contents($this->path,$data);
+
+    }
+
+    /**
+     * Returns the data
+     *
+     * @return string 
+     */
+    public function get() {
+
+        return fopen($this->path,'r');
+
+    }
+
+    /**
+     * Delete the current file
+     *
+     * @return void 
+     */
+    public function delete() {
+
+        unlink($this->path);
+        return parent::delete();
+
+    }
+
+    /**
+     * Returns the ETag for a file
+     *
+     * An ETag is a unique identifier representing the current version of the file. If the file changes, the ETag MUST change.
+     * The ETag is an arbritrary string, but MUST be surrounded by double-quotes.
+     *
+     * Return null if the ETag can not effectively be determined
+     */
+    public function getETag() {
+
+        return '"' . md5_file($this->path). '"';
+
+    }
+
+    /**
+     * Returns the mime-type for a file
+     *
+     * If null is returned, we'll assume application/octet-stream
+     */ 
+    public function getContentType() {
+
+        return null;
+
+    }
+
+    /**
+     * Returns the size of the file, in bytes 
+     * 
+     * @return int 
+     */
+    public function getSize() {
+
+        return filesize($this->path);
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/FSExt/Node.php

@@ -0,0 +1,276 @@
+<?php
+
+/**
+ * Base node-class 
+ *
+ * The node class implements the method used by both the File and the Directory classes 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_FSExt_Node extends Sabre_DAV_FS_Node implements Sabre_DAV_ILockable, Sabre_DAV_IProperties {
+
+    /**
+     * Returns all the locks on this node
+     * 
+     * @return array 
+     */
+    function getLocks() {
+
+        $resourceData = $this->getResourceData();
+        $locks = $resourceData['locks'];
+        foreach($locks as $k=>$lock) {
+            if (time() > $lock->timeout + $lock->created) unset($locks[$k]); 
+        }
+        return $locks;
+
+    }
+
+    /**
+     * Locks this node 
+     * 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo 
+     * @return void
+     */
+    function lock(Sabre_DAV_Locks_LockInfo $lockInfo) {
+
+        // We're making the lock timeout 30 minutes
+        $lockInfo->timeout = 1800;
+        $lockInfo->created = time();
+
+        $resourceData = $this->getResourceData();
+        if (!isset($resourceData['locks'])) $resourceData['locks'] = array();
+        $current = null;
+        foreach($resourceData['locks'] as $k=>$lock) {
+            if ($lock->token === $lockInfo->token) $current = $k;
+        }
+        if (!is_null($current)) $resourceData['locks'][$current] = $lockInfo;
+        else $resourceData['locks'][] = $lockInfo;
+
+        $this->putResourceData($resourceData);
+
+    }
+
+    /**
+     * Removes a lock from this node
+     * 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo 
+     * @return bool 
+     */
+    function unlock(Sabre_DAV_Locks_LockInfo $lockInfo) {
+
+        //throw new Sabre_DAV_Exception('bla');
+        $resourceData = $this->getResourceData();
+        foreach($resourceData['locks'] as $k=>$lock) {
+
+            if ($lock->token === $lockInfo->token) {
+
+                unset($resourceData['locks'][$k]);
+                $this->putResourceData($resourceData);
+                return true;
+
+            }
+        }
+        return false;
+
+    }
+
+    /**
+     * Updates properties on this node,
+     *
+     * @param array $mutations
+     * @see Sabre_DAV_IProperties::updateProperties
+     * @return bool|array 
+     */
+    public function updateProperties($properties) {
+
+        $resourceData = $this->getResourceData();
+        
+        $result = array();
+
+        foreach($properties as $propertyName=>$propertyValue) {
+
+            // If it was null, we need to delete the property
+            if (is_null($propertyValue)) {
+                if (isset($resourceData['properties'][$propertyName])) {
+                    unset($resourceData['properties'][$propertyName]);
+                }
+            } else {
+                $resourceData['properties'][$propertyName] = $propertyValue;
+            }
+               
+        }
+
+        $this->putResourceData($resourceData);
+        return true; 
+    }
+
+    /**
+     * Returns a list of properties for this nodes.;
+     *
+     * The properties list is a list of propertynames the client requested, encoded as xmlnamespace#tagName, for example: http://www.example.org/namespace#author
+     * If the array is empty, all properties should be returned
+     *
+     * @param array $properties 
+     * @return void
+     */
+    function getProperties($properties) {
+
+        $resourceData = $this->getResourceData();
+
+        // if the array was empty, we need to return everything
+        if (!$properties) return $resourceData['properties'];
+
+        $props = array();
+        foreach($properties as $property) {
+            if (isset($resourceData['properties'][$property])) $props[$property] = $resourceData['properties'][$property];
+        }
+
+        return $props;
+
+    }
+
+    /**
+     * Returns the path to the resource file 
+     * 
+     * @return string 
+     */
+    protected function getResourceInfoPath() {
+
+        list($parentDir) = Sabre_DAV_URLUtil::splitPath($this->path);
+        return $parentDir . '/.sabredav';
+
+    }
+
+    /**
+     * Returns all the stored resource information 
+     * 
+     * @return array 
+     */
+    protected function getResourceData() {
+
+        $path = $this->getResourceInfoPath();
+        if (!file_exists($path)) return array('locks'=>array(), 'properties' => array());
+
+        // opening up the file, and creating a shared lock
+        $handle = fopen($path,'r');
+        flock($handle,LOCK_SH);
+        $data = '';
+
+        // Reading data until the eof
+        while(!feof($handle)) {
+            $data.=fread($handle,8192);
+        }
+
+        // We're all good
+        fclose($handle);
+
+        // Unserializing and checking if the resource file contains data for this file
+        $data = unserialize($data);
+        if (!isset($data[$this->getName()])) {
+            return array('locks'=>array(), 'properties' => array());
+        }
+
+        $data = $data[$this->getName()];
+        if (!isset($data['locks'])) $data['locks'] = array();
+        if (!isset($data['properties'])) $data['properties'] = array();
+        return $data;
+
+    }
+
+    /**
+     * Updates the resource information 
+     * 
+     * @param array $newData 
+     * @return void
+     */
+    protected function putResourceData(array $newData) {
+
+        $path = $this->getResourceInfoPath();
+
+        // opening up the file, and creating a shared lock
+        $handle = fopen($path,'a+');
+        flock($handle,LOCK_EX);
+        $data = '';
+
+        rewind($handle);
+
+        // Reading data until the eof
+        while(!feof($handle)) {
+            $data.=fread($handle,8192);
+        }
+
+        // Unserializing and checking if the resource file contains data for this file
+        $data = unserialize($data);
+        $data[$this->getName()] = $newData;
+        ftruncate($handle,0);
+        rewind($handle);
+
+        fwrite($handle,serialize($data));
+        fclose($handle);
+
+    }
+
+    /**
+     * Renames the node
+     *
+     * @param string $name The new name
+     * @return void
+     */
+    public function setName($name) {
+
+        list($parentPath, ) = Sabre_DAV_URLUtil::splitPath($this->path);
+        list(, $newName) = Sabre_DAV_URLUtil::splitPath($name);
+        $newPath = $parentPath . '/' . $newName;
+
+        // We're deleting the existing resourcedata, and recreating it
+        // for the new path.
+        $resourceData = $this->getResourceData();
+        $this->deleteResourceData();
+
+        rename($this->path,$newPath);
+        $this->path = $newPath;
+        $this->putResourceData($resourceData);
+
+
+    }
+
+    public function deleteResourceData() {
+
+        // When we're deleting this node, we also need to delete any resource information
+        $path = $this->getResourceInfoPath();
+        if (!file_exists($path)) return true;
+
+        // opening up the file, and creating a shared lock
+        $handle = fopen($path,'a+');
+        flock($handle,LOCK_EX);
+        $data = '';
+
+        rewind($handle);
+
+        // Reading data until the eof
+        while(!feof($handle)) {
+            $data.=fread($handle,8192);
+        }
+
+        // Unserializing and checking if the resource file contains data for this file
+        $data = unserialize($data);
+        if (isset($data[$this->getName()])) unset($data[$this->getName()]);
+        ftruncate($handle,0);
+        rewind($handle);
+        fwrite($handle,serialize($data));
+        fclose($handle);
+
+    }
+
+    public function delete() {
+
+        return $this->deleteResourceData();
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/FSExt/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/DAV/File.php

@@ -0,0 +1,81 @@
+<?php
+
+/**
+ * File class
+ *
+ * This is a helper class, that should aid in getting file classes setup.
+ * Most of its methods are implemented, and throw permission denied exceptions 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_File extends Sabre_DAV_Node implements Sabre_DAV_IFile {
+
+    /**
+     * Updates the data
+     *
+     * data is a readable stream resource.
+     * 
+     * @param resource $data 
+     * @return void 
+     */
+    public function put($data) { 
+
+        throw new Sabre_DAV_Exception_Forbidden('Permission denied to change data');
+
+    }
+
+    /**
+     * Returns the data 
+     *
+     * This method may either return a string or a readable stream resource
+     *
+     * @return mixed 
+     */
+    public function get() { 
+
+        throw new Sabre_DAV_Exception_Forbidden('Permission denied to read this file');
+
+    }
+    
+    /**
+     * Returns the size of the file, in bytes. 
+     * 
+     * @return int 
+     */
+    public function getSize() {
+
+        return 0;
+
+    }
+
+    /**
+     * Returns the ETag for a file
+     *
+     * An ETag is a unique identifier representing the current version of the file. If the file changes, the ETag MUST change.
+     * The ETag is an arbritrary string, but MUST be surrounded by double-quotes.
+     *
+     * Return null if the ETag can not effectively be determined
+     */
+    public function getETag() {
+
+        return null;
+
+    }
+
+    /**
+     * Returns the mime-type for a file
+     *
+     * If null is returned, we'll assume application/octet-stream
+     */ 
+    public function getContentType() {
+
+        return null;
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/ICollection.php

@@ -0,0 +1,58 @@
+<?php
+
+/**
+ * The ICollection Interface
+ *
+ * This interface should be implemented by each class that represents a collection 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+interface Sabre_DAV_ICollection extends Sabre_DAV_INode {
+
+    /**
+     * Creates a new file in the directory 
+     * 
+     * data is a readable stream resource
+     *
+     * @param string $name Name of the file 
+     * @param resource $data Initial payload 
+     * @return void
+     */
+    function createFile($name, $data = null);
+
+    /**
+     * Creates a new subdirectory 
+     * 
+     * @param string $name 
+     * @return void
+     */
+    function createDirectory($name);
+
+    /**
+     * Returns a specific child node, referenced by its name 
+     * 
+     * @param string $name 
+     * @return Sabre_DAV_INode 
+     */
+    function getChild($name);
+
+    /**
+     * Returns an array with all the child nodes 
+     * 
+     * @return Sabre_DAV_INode[] 
+     */
+    function getChildren();
+
+    /**
+     * Checks if a child-node with the specified name exists 
+     * 
+     * @return bool 
+     */
+    function childExists($name);
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/IExtendedCollection.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * The IExtendedCollection interface.
+ *
+ * This interface can be used to create special-type of collection-resources
+ * as defined by RFC 5689.
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+interface Sabre_DAV_IExtendedCollection extends Sabre_DAV_ICollection {
+
+    /**
+     * Creates a new collection
+     *
+     * @param string $name 
+     * @param array $resourceType
+     * @param array $properties
+     * @return void
+     */
+    function createExtendedCollection($name, array $resourceType, array $properties);
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/IFile.php

@@ -0,0 +1,63 @@
+<?php
+
+/**
+ * This interface represents a file or leaf in the tree.
+ *
+ * The nature of a file is, as you might be aware of, that it doesn't contain sub-nodes and has contents
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+interface Sabre_DAV_IFile extends Sabre_DAV_INode {
+
+    /**
+     * Updates the data 
+     * 
+     * The data argument is a readable stream resource.
+     *
+     * @param resource $data 
+     * @return void 
+     */
+    function put($data);
+
+    /**
+     * Returns the data 
+     * 
+     * This method may either return a string or a readable stream resource
+     *
+     * @return mixed 
+     */
+    function get();
+
+    /**
+     * Returns the mime-type for a file
+     *
+     * If null is returned, we'll assume application/octet-stream
+     * 
+     * @return void
+     */
+    function getContentType();
+
+    /**
+     * Returns the ETag for a file
+     *
+     * An ETag is a unique identifier representing the current version of the file. If the file changes, the ETag MUST change.
+     *
+     * Return null if the ETag can not effectively be determined
+     * 
+     * @return void
+     */
+    function getETag();
+
+    /**
+     * Returns the size of the node, in bytes 
+     * 
+     * @return int 
+     */
+    function getSize();
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/ILockable.php

@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * Implement this class to support locking 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+interface Sabre_DAV_ILockable extends Sabre_DAV_INode {
+
+    /**
+     * Returns an array with locks currently on the node 
+     * 
+     * @return Sabre_DAV_Locks_LockInfo[] 
+     */
+    function getLocks();
+
+    /**
+     * Creates a new lock on the file.  
+     * 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo The lock information 
+     * @return void
+     */
+    function lock(Sabre_DAV_Locks_LockInfo $lockInfo);
+
+    /**
+     * Unlocks a file 
+     * 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo The lock information 
+     * @return void 
+     */
+    function unlock(Sabre_DAV_Locks_LockInfo $lockInfo);
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/INode.php

@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * The INode interface is the base interface, and the parent class of both ICollection and IFile
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+interface Sabre_DAV_INode {
+
+    /**
+     * Deleted the current node
+     *
+     * @return void 
+     */
+    function delete();
+
+    /**
+     * Returns the name of the node 
+     * 
+     * @return string 
+     */
+    function getName();
+
+    /**
+     * Renames the node
+     *
+     * @param string $name The new name
+     * @return void
+     */
+    function setName($name);
+
+    /**
+     * Returns the last modification time, as a unix timestamp 
+     * 
+     * @return int 
+     */
+    function getLastModified();
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/IProperties.php

@@ -0,0 +1,67 @@
+<?php
+
+/**
+ * IProperties interface
+ *
+ * Implement this interface to support custom WebDAV properties requested and sent from clients.
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+interface Sabre_DAV_IProperties extends Sabre_DAV_INode {
+
+    /**
+     * Updates properties on this node,
+     *
+     * The properties array uses the propertyName in clark-notation as key,
+     * and the array value for the property value. In the case a property
+     * should be deleted, the property value will be null.
+     *
+     * This method must be atomic. If one property cannot be changed, the
+     * entire operation must fail.
+     *
+     * If the operation was successful, true can be returned.
+     * If the operation failed, false can be returned.
+     *
+     * Deletion of a non-existant property is always succesful.
+     *
+     * Lastly, it is optional to return detailed information about any
+     * failures. In this case an array should be returned with the following
+     * structure:
+     *
+     * array(
+     *   403 => array(
+     *      '{DAV:}displayname' => null,
+     *   ),
+     *   424 => array(
+     *      '{DAV:}owner' => null,
+     *   )
+     * )
+     *
+     * In this example it was forbidden to update {DAV:}displayname. 
+     * (403 Forbidden), which in turn also caused {DAV:}owner to fail
+     * (424 Failed Dependency) because the request needs to be atomic.
+     *
+     * @param array $mutations 
+     * @return bool|array 
+     */
+    function updateProperties($properties);
+
+    /**
+     * Returns a list of properties for this nodes.
+     *
+     * The properties list is a list of propertynames the client requested,
+     * encoded in clark-notation {xmlnamespace}tagname
+     *
+     * If the array is empty, it means 'all properties' were requested.
+     *
+     * @param array $properties 
+     * @return void
+     */
+    function getProperties($properties);
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/IQuota.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * IQuota interface
+ *
+ * Implement this interface to add the ability to return quota information. The ObjectTree
+ * will check for quota information on any given node. If the information is not available it will 
+ * attempt to fetch the information from the root node.
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+interface Sabre_DAV_IQuota extends Sabre_DAV_ICollection {
+
+    /**
+     * Returns the quota information
+     *
+     * This method MUST return an array with 2 values, the first being the total used space,
+     * the second the available space (in bytes)
+     */
+    function getQuotaInfo(); 
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Locks/Backend/Abstract.php

@@ -0,0 +1,46 @@
+<?php
+
+/**
+ * The Lock manager allows you to handle all file-locks centrally.
+ *
+ * This is an alternative approach to doing this on a per-node basis
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_Locks_Backend_Abstract {
+
+    /**
+     * Returns a list of Sabre_DAV_Locks_LockInfo objects  
+     * 
+     * This method should return all the locks for a particular uri, including
+     * locks that might be set on a parent uri.
+     *
+     * @param string $uri 
+     * @return array 
+     */
+    abstract function getLocks($uri);
+
+    /**
+     * Locks a uri 
+     * 
+     * @param string $uri 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo 
+     * @return bool 
+     */
+    abstract function lock($uri,Sabre_DAV_Locks_LockInfo $lockInfo);
+
+    /**
+     * Removes a lock from a uri 
+     * 
+     * @param string $uri 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo 
+     * @return bool 
+     */
+    abstract function unlock($uri,Sabre_DAV_Locks_LockInfo $lockInfo);
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Locks/Backend/FS.php

@@ -0,0 +1,180 @@
+<?php
+
+/**
+ * The Lock manager allows you to handle all file-locks centrally.
+ *
+ * This Lock Manager stores all its data in the filesystem. By default it will do this in PHP's standard temporary session directory,
+ * but this can be overriden by specifiying an alternative path in the contructor
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Locks_Backend_FS extends Sabre_DAV_Locks_Backend_Abstract {
+
+    /**
+     * The default data directory 
+     * 
+     * @var string 
+     */
+    private $dataDir;
+
+    public function __construct($dataDir) {
+
+        $this->dataDir = $dataDir;
+
+    }
+
+    protected function getFileNameForUri($uri) {
+
+        return $this->dataDir . '/sabredav_' . md5($uri) . '.locks';
+
+    }
+
+
+    /**
+     * Returns a list of Sabre_DAV_Locks_LockInfo objects  
+     * 
+     * This method should return all the locks for a particular uri, including
+     * locks that might be set on a parent uri.
+     *
+     * @param string $uri 
+     * @return array 
+     */
+    public function getLocks($uri) {
+
+        $lockList = array();
+        $currentPath = '';
+
+        foreach(explode('/',$uri) as $uriPart) {
+
+            // weird algorithm that can probably be improved, but we're traversing the path top down 
+            if ($currentPath) $currentPath.='/'; 
+            $currentPath.=$uriPart;
+
+            $uriLocks = $this->getData($currentPath);
+
+            foreach($uriLocks as $uriLock) {
+
+                // Unless we're on the leaf of the uri-tree we should ingore locks with depth 0
+                if($uri==$currentPath || $uriLock->depth!=0) {
+                    $uriLock->uri = $currentPath;
+                    $lockList[] = $uriLock;
+                }
+
+            }
+
+        }
+
+        // Checking if we can remove any of these locks
+        foreach($lockList as $k=>$lock) {
+            if (time() > $lock->timeout + $lock->created) unset($lockList[$k]); 
+        }
+        return $lockList;
+
+    }
+
+    /**
+     * Locks a uri 
+     * 
+     * @param string $uri 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo 
+     * @return bool 
+     */
+    public function lock($uri,Sabre_DAV_Locks_LockInfo $lockInfo) {
+
+        // We're making the lock timeout 30 minutes
+        $lockInfo->timeout = 1800;
+        $lockInfo->created = time();
+
+        $locks = $this->getLocks($uri);
+        foreach($locks as $k=>$lock) {
+            if ($lock->token == $lockInfo->token) unset($locks[$k]);
+        }
+        $locks[] = $lockInfo;
+        $this->putData($uri,$locks);
+        return true;
+
+    }
+
+    /**
+     * Removes a lock from a uri 
+     * 
+     * @param string $uri 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo 
+     * @return bool 
+     */
+    public function unlock($uri,Sabre_DAV_Locks_LockInfo $lockInfo) {
+
+        $locks = $this->getLocks($uri);
+        foreach($locks as $k=>$lock) {
+
+            if ($lock->token == $lockInfo->token) {
+
+                unset($locks[$k]);
+                $this->putData($uri,$locks);
+                return true;
+
+            }
+        }
+        return false;
+
+    }
+
+    /**
+     * Returns the stored data for a uri
+     *
+     * @param string $uri
+     * @return array 
+     */
+    protected function getData($uri) {
+
+        $path = $this->getFilenameForUri($uri);
+        if (!file_exists($path)) return array();
+
+        // opening up the file, and creating a shared lock
+        $handle = fopen($path,'r');
+        flock($handle,LOCK_SH);
+        $data = '';
+
+        // Reading data until the eof
+        while(!feof($handle)) {
+            $data.=fread($handle,8192);
+        }
+
+        // We're all good
+        fclose($handle);
+
+        // Unserializing and checking if the resource file contains data for this file
+        $data = unserialize($data);
+        if (!$data) return array();
+        return $data;
+
+    }
+
+    /**
+     * Updates the lock information
+     *
+     * @param string $uri
+     * @param array $newData 
+     * @return void
+     */
+    protected function putData($uri,array $newData) {
+
+        $path = $this->getFileNameForUri($uri);
+
+        // opening up the file, and creating a shared lock
+        $handle = fopen($path,'a+');
+        flock($handle,LOCK_EX);
+        ftruncate($handle,0);
+        rewind($handle);
+
+        fwrite($handle,serialize($newData));
+        fclose($handle);
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Locks/Backend/PDO.php

@@ -0,0 +1,141 @@
+<?php
+
+/**
+ * The Lock manager allows you to handle all file-locks centrally.
+ *
+ * This Lock Manager stores all its data in a database. You must pass a PDO
+ * connection object in the constructor.
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Locks_Backend_PDO extends Sabre_DAV_Locks_Backend_Abstract {
+
+    /**
+     * The PDO connection object 
+     * 
+     * @var pdo 
+     */
+    private $pdo;
+
+    public function __construct(PDO $pdo) {
+
+        $this->pdo = $pdo;
+
+    }
+
+    /**
+     * Returns a list of Sabre_DAV_Locks_LockInfo objects  
+     * 
+     * This method should return all the locks for a particular uri, including
+     * locks that might be set on a parent uri.
+     *
+     * @param string $uri 
+     * @return array 
+     */
+    public function getLocks($uri) {
+
+        // NOTE: the following 10 lines or so could be easily replaced by 
+        // pure sql. MySQL's non-standard string concatination prevents us
+        // from doing this though.
+        $query = 'SELECT owner, token, timeout, created, scope, depth, uri FROM locks WHERE ((created + timeout) > CAST(? AS UNSIGNED INTEGER)) AND ((uri = ?)';
+        $params = array(time(),$uri);
+
+        // We need to check locks for every part in the uri.
+        $uriParts = explode('/',$uri);
+
+        // We already covered the last part of the uri
+        array_pop($uriParts);
+
+        $currentPath='';
+
+        foreach($uriParts as $part) {
+
+            if ($currentPath) $currentPath.='/';
+            $currentPath.=$part;
+
+            $query.=' OR (depth!=0 AND uri = ?)';
+            $params[] = $currentPath;
+
+        }
+
+        $query.=')';
+
+        $stmt = $this->pdo->prepare($query);
+        $stmt->execute($params);
+        $result = $stmt->fetchAll();
+
+        $lockList = array();
+        foreach($result as $row) {
+
+            $lockInfo = new Sabre_DAV_Locks_LockInfo();
+            $lockInfo->owner = $row['owner'];
+            $lockInfo->token = $row['token'];
+            $lockInfo->timeout = $row['timeout'];
+            $lockInfo->created = $row['created'];
+            $lockInfo->scope = $row['scope'];
+            $lockInfo->depth = $row['depth'];
+            $lockInfo->uri   = $row['uri'];
+            $lockList[] = $lockInfo;
+
+        }
+
+        return $lockList;
+
+    }
+
+    /**
+     * Locks a uri 
+     * 
+     * @param string $uri 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo 
+     * @return bool 
+     */
+    public function lock($uri,Sabre_DAV_Locks_LockInfo $lockInfo) {
+
+        // We're making the lock timeout 30 minutes
+        $lockInfo->timeout = 30*60;
+        $lockInfo->created = time();
+        $lockInfo->uri = $uri;
+
+        $locks = $this->getLocks($uri);
+        $exists = false;
+        foreach($locks as $k=>$lock) {
+            if ($lock->token == $lockInfo->token) $exists = true;
+        }
+        
+        if ($exists) {
+            $stmt = $this->pdo->prepare('UPDATE locks SET owner = ?, timeout = ?, scope = ?, depth = ?, uri = ?, created = ? WHERE token = ?');
+            $stmt->execute(array($lockInfo->owner,$lockInfo->timeout,$lockInfo->scope,$lockInfo->depth,$uri,$lockInfo->created,$lockInfo->token));
+        } else {
+            $stmt = $this->pdo->prepare('INSERT INTO locks (owner,timeout,scope,depth,uri,created,token) VALUES (?,?,?,?,?,?,?)');
+            $stmt->execute(array($lockInfo->owner,$lockInfo->timeout,$lockInfo->scope,$lockInfo->depth,$uri,$lockInfo->created,$lockInfo->token));
+        }
+
+        return true;
+
+    }
+
+
+
+    /**
+     * Removes a lock from a uri 
+     * 
+     * @param string $uri 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo 
+     * @return bool 
+     */
+    public function unlock($uri,Sabre_DAV_Locks_LockInfo $lockInfo) {
+
+        $stmt = $this->pdo->prepare('DELETE FROM locks WHERE uri = ? AND token = ?');
+        $stmt->execute(array($uri,$lockInfo->token));
+
+        return $stmt->rowCount()===1;
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Locks/Backend/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/DAV/Locks/LockInfo.php

@@ -0,0 +1,81 @@
+<?php
+
+/**
+ * LockInfo class
+ *
+ * An object of the LockInfo class holds all the information relevant to a
+ * single lock.
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Locks_LockInfo {
+
+    /**
+     * A shared lock
+     */
+    const SHARED = 1;
+
+    /**
+     * An exclusive lock
+     */
+    const EXCLUSIVE = 2;
+
+    /**
+     * A never expiring timeout
+     */
+    const TIMEOUT_INFINITE = -1;
+
+    /**
+     * The owner of the lock 
+     * 
+     * @var string 
+     */
+    public $owner;
+
+    /**
+     * The locktoken 
+     * 
+     * @var string 
+     */
+    public $token;
+
+    /**
+     * How long till the lock is expiring 
+     * 
+     * @var int 
+     */
+    public $timeout;
+
+    /**
+     * UNIX Timestamp of when this lock was created 
+     * 
+     * @var int 
+     */
+    public $created;
+
+    /**
+     * Exclusive or shared lock 
+     * 
+     * @var int 
+     */
+    public $scope = self::EXCLUSIVE;
+
+    /**
+     * Depth of lock, can be 0 or Sabre_DAV_Server::DEPTH_INFINITY
+     */
+    public $depth = 0;
+
+    /**
+     * The uri this lock locks
+     *
+     * TODO: This value is not always set 
+     * @var mixed
+     */
+    public $uri;
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Locks/Plugin.php

@@ -0,0 +1,653 @@
+<?php
+
+/**
+ * Locking plugin
+ *
+ * This plugin provides locking support to a WebDAV server.
+ * The easiest way to get started, is by hooking it up as such:
+ *
+ * $lockBackend = new Sabre_DAV_Locks_Backend_FS('./my_lock_directory');
+ * $lockPlugin = new Sabre_DAV_Locks_Plugin($lockBackend);
+ * $server->addPlugin($lockPlugin);
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Locks_Plugin extends Sabre_DAV_ServerPlugin {
+
+    /**
+     * locksBackend 
+     * 
+     * @var Sabre_DAV_Locks_Backend_Abstract 
+     */
+    private $locksBackend;
+
+    /**
+     * server
+     * 
+     * @var Sabre_DAV_Server 
+     */
+    private $server;
+
+    /**
+     * __construct 
+     * 
+     * @param Sabre_DAV_Locks_Backend_Abstract $locksBackend 
+     * @return void
+     */
+    public function __construct(Sabre_DAV_Locks_Backend_Abstract $locksBackend = null) {
+
+        $this->locksBackend = $locksBackend;        
+
+    }
+
+    /**
+     * Initializes the plugin
+     *
+     * This method is automatically called by the Server class after addPlugin.
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @return void
+     */
+    public function initialize(Sabre_DAV_Server $server) {
+
+        $this->server = $server;
+        $server->subscribeEvent('unknownMethod',array($this,'unknownMethod'));
+        $server->subscribeEvent('beforeMethod',array($this,'beforeMethod'),50);
+        $server->subscribeEvent('afterGetProperties',array($this,'afterGetProperties'));
+
+    }
+
+    /**
+     * This method is called by the Server if the user used an HTTP method 
+     * the server didn't recognize.
+     *
+     * This plugin intercepts the LOCK and UNLOCK methods.
+     * 
+     * @param string $method 
+     * @return bool 
+     */
+    public function unknownMethod($method, $uri) {
+
+        switch($method) { 
+
+            case 'LOCK'   : $this->httpLock($uri); return false; 
+            case 'UNLOCK' : $this->httpUnlock($uri); return false; 
+
+        }
+
+    }
+
+    /**
+     * This method is called after most properties have been found
+     * it allows us to add in any Lock-related properties
+     * 
+     * @param string $path 
+     * @param array $properties 
+     * @return bool 
+     */
+    public function afterGetProperties($path,&$newProperties) {
+
+        foreach($newProperties[404] as $propName=>$discard) {
+
+            $node = null;
+
+            switch($propName) {
+
+                case '{DAV:}supportedlock' :
+                    $val = false;
+                    if ($this->locksBackend) $val = true;
+                    else {
+                        if (!$node) $node = $this->server->tree->getNodeForPath($path);
+                        if ($node instanceof Sabre_DAV_ILockable) $val = true;
+                    }
+                    $newProperties[200][$propName] = new Sabre_DAV_Property_SupportedLock($val);
+                    unset($newProperties[404][$propName]);
+                    break;
+
+                case '{DAV:}lockdiscovery' :
+                    $newProperties[200][$propName] = new Sabre_DAV_Property_LockDiscovery($this->getLocks($path));
+                    unset($newProperties[404][$propName]);
+                    break;
+
+            }
+
+
+        }
+        return true;
+
+    }
+
+
+    /**
+     * This method is called before the logic for any HTTP method is
+     * handled.
+     *
+     * This plugin uses that feature to intercept access to locked resources.
+     * 
+     * @param string $method
+     * @param string $uri
+     * @return bool 
+     */
+    public function beforeMethod($method, $uri) {
+
+        switch($method) {
+
+            case 'DELETE' :
+            case 'MKCOL' :
+            case 'PROPPATCH' :
+            case 'PUT' :
+                $lastLock = null;
+                if (!$this->validateLock($uri,$lastLock))
+                    throw new Sabre_DAV_Exception_Locked($lastLock);
+                break;
+            case 'MOVE' :
+                $lastLock = null;
+                if (!$this->validateLock(array(
+                      $uri,
+                      $this->server->calculateUri($this->server->httpRequest->getHeader('Destination')),
+                    ),$lastLock))
+                        throw new Sabre_DAV_Exception_Locked($lastLock);
+                break;
+            case 'COPY' :
+                $lastLock = null;
+                if (!$this->validateLock(
+                      $this->server->calculateUri($this->server->httpRequest->getHeader('Destination')),
+                      $lastLock))
+                        throw new Sabre_DAV_Exception_Locked($lastLock);
+                break;
+        }
+
+        return true;
+
+    }
+
+
+    /**
+     * Use this method to tell the server this plugin defines additional
+     * HTTP methods.
+     *
+     * This method is passed a uri. It should only return HTTP methods that are 
+     * available for the specified uri.
+     *
+     * @param string $uri
+     * @return array 
+     */
+    public function getHTTPMethods($uri) {
+
+        if ($this->locksBackend ||
+            $this->server->tree->getNodeForPath($uri) instanceof Sabre_DAV_ILocks) {
+            return array('LOCK','UNLOCK');
+        }
+        return array();
+
+    }
+
+    /**
+     * Returns a list of features for the HTTP OPTIONS Dav: header.
+     *
+     * In this case this is only the number 2. The 2 in the Dav: header
+     * indicates the server supports locks.
+     * 
+     * @return array 
+     */
+    public function getFeatures() {
+
+        return array(2);
+
+    }
+
+    /**
+     * Returns all lock information on a particular uri 
+     * 
+     * This function should return an array with Sabre_DAV_Locks_LockInfo objects. If there are no locks on a file, return an empty array.
+     *
+     * Additionally there is also the possibility of locks on parent nodes, so we'll need to traverse every part of the tree 
+     *
+     * @param string $uri 
+     * @return array 
+     */
+    public function getLocks($uri) {
+
+        $lockList = array();
+        $currentPath = '';
+        foreach(explode('/',$uri) as $uriPart) {
+
+            $uriLocks = array();
+            if ($currentPath) $currentPath.='/'; 
+            $currentPath.=$uriPart;
+
+            try {
+
+                $node = $this->server->tree->getNodeForPath($currentPath);
+                if ($node instanceof Sabre_DAV_ILockable) $uriLocks = $node->getLocks();
+
+            } catch (Sabre_DAV_Exception_FileNotFound $e){
+                // In case the node didn't exist, this could be a lock-null request
+            }
+
+            foreach($uriLocks as $uriLock) {
+
+                // Unless we're on the leaf of the uri-tree we should ingore locks with depth 0
+                if($uri==$currentPath || $uriLock->depth!=0) {
+                    $uriLock->uri = $currentPath;
+                    $lockList[] = $uriLock;
+                }
+
+            }
+
+        }
+        if ($this->locksBackend) $lockList = array_merge($lockList,$this->locksBackend->getLocks($uri));
+        return $lockList;
+
+    }
+
+    /**
+     * Locks an uri
+     *
+     * The WebDAV lock request can be operated to either create a new lock on a file, or to refresh an existing lock
+     * If a new lock is created, a full XML body should be supplied, containing information about the lock such as the type 
+     * of lock (shared or exclusive) and the owner of the lock
+     *
+     * If a lock is to be refreshed, no body should be supplied and there should be a valid If header containing the lock
+     *
+     * Additionally, a lock can be requested for a non-existant file. In these case we're obligated to create an empty file as per RFC4918:S7.3
+     * 
+     * @param string $uri
+     * @return void
+     */
+    protected function httpLock($uri) {
+
+        $lastLock = null;
+        if (!$this->validateLock($uri,$lastLock)) {
+
+            // If the existing lock was an exclusive lock, we need to fail
+            if (!$lastLock || $lastLock->scope == Sabre_DAV_Locks_LockInfo::EXCLUSIVE) {
+                //var_dump($lastLock);
+                throw new Sabre_DAV_Exception_ConflictingLock($lastLock);
+            }
+
+        }
+
+        if ($body = $this->server->httpRequest->getBody(true)) {
+            // This is a new lock request
+            $lockInfo = $this->parseLockRequest($body);
+            $lockInfo->depth = $this->server->getHTTPDepth(); 
+            $lockInfo->uri = $uri;
+            if($lastLock && $lockInfo->scope != Sabre_DAV_Locks_LockInfo::SHARED) throw new Sabre_DAV_Exception_ConflictingLock($lastLock);
+
+        } elseif ($lastLock) {
+
+            // This must have been a lock refresh
+            $lockInfo = $lastLock;
+
+            // The resource could have been locked through another uri. 
+            if ($uri!=$lockInfo->uri) $uri = $lockInfo->uri;
+
+        } else {
+            
+            // There was neither a lock refresh nor a new lock request
+            throw new Sabre_DAV_Exception_BadRequest('An xml body is required for lock requests');
+
+        }
+
+        if ($timeout = $this->getTimeoutHeader()) $lockInfo->timeout = $timeout;
+
+        $newFile = false;
+
+        // If we got this far.. we should go check if this node actually exists. If this is not the case, we need to create it first
+        try {
+            $node = $this->server->tree->getNodeForPath($uri);
+            
+            // We need to call the beforeWriteContent event for RFC3744
+            $this->server->broadcastEvent('beforeWriteContent',array($uri));
+
+        } catch (Sabre_DAV_Exception_FileNotFound $e) {
+            
+            // It didn't, lets create it
+            $this->server->createFile($uri,fopen('php://memory','r')); 
+            $newFile = true; 
+
+        }
+
+        $this->lockNode($uri,$lockInfo);
+
+        $this->server->httpResponse->setHeader('Content-Type','application/xml; charset=utf-8');
+        $this->server->httpResponse->setHeader('Lock-Token','<opaquelocktoken:' . $lockInfo->token . '>');
+        $this->server->httpResponse->sendStatus($newFile?201:200);
+        $this->server->httpResponse->sendBody($this->generateLockResponse($lockInfo));
+
+    }
+
+    /**
+     * Unlocks a uri
+     *
+     * This WebDAV method allows you to remove a lock from a node. The client should provide a valid locktoken through the Lock-token http header
+     * The server should return 204 (No content) on success
+     *
+     * @param string $uri
+     * @return void
+     */
+    protected function httpUnlock($uri) {
+
+        $lockToken = $this->server->httpRequest->getHeader('Lock-Token');
+
+        // If the locktoken header is not supplied, we need to throw a bad request exception
+        if (!$lockToken) throw new Sabre_DAV_Exception_BadRequest('No lock token was supplied');
+
+        $locks = $this->getLocks($uri);
+
+        // We're grabbing the node information, just to rely on the fact it will throw a 404 when the node doesn't exist 
+        //$this->server->tree->getNodeForPath($uri);
+
+        foreach($locks as $lock) {
+
+            if ('<opaquelocktoken:' . $lock->token . '>' == $lockToken) {
+
+                $this->unlockNode($uri,$lock);
+                $this->server->httpResponse->setHeader('Content-Length','0');
+                $this->server->httpResponse->sendStatus(204);
+                return;
+
+            }
+
+        }
+
+        // If we got here, it means the locktoken was invalid
+        throw new Sabre_DAV_Exception_LockTokenMatchesRequestUri();
+
+    }
+
+    /**
+     * Locks a uri
+     *
+     * All the locking information is supplied in the lockInfo object. The object has a suggested timeout, but this can be safely ignored
+     * It is important that if the existing timeout is ignored, the property is overwritten, as this needs to be sent back to the client
+     * 
+     * @param string $uri 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo 
+     * @return void
+     */
+    public function lockNode($uri,Sabre_DAV_Locks_LockInfo $lockInfo) {
+
+        if (!$this->server->broadcastEvent('beforeLock',array($uri,$lockInfo))) return;
+
+        try {
+            $node = $this->server->tree->getNodeForPath($uri);
+            if ($node instanceof Sabre_DAV_ILockable) return $node->lock($lockInfo);
+        } catch (Sabre_DAV_Exception_FileNotFound $e) {
+            // In case the node didn't exist, this could be a lock-null request
+        }
+        if ($this->locksBackend) return $this->locksBackend->lock($uri,$lockInfo);
+        throw new Sabre_DAV_Exception_MethodNotAllowed('Locking support is not enabled for this resource. No Locking backend was found so if you didn\'t expect this error, please check your configuration.');
+
+    }
+
+    /**
+     * Unlocks a uri
+     *
+     * This method removes a lock from a uri. It is assumed all the supplied information is correct and verified
+     * 
+     * @param string $uri 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo 
+     * @return void
+     */
+    public function unlockNode($uri,Sabre_DAV_Locks_LockInfo $lockInfo) {
+
+        if (!$this->server->broadcastEvent('beforeUnlock',array($uri,$lockInfo))) return;
+        try {
+            $node = $this->server->tree->getNodeForPath($uri);
+            if ($node instanceof Sabre_DAV_ILockable) return $node->unlock($lockInfo);
+        } catch (Sabre_DAV_Exception_FileNotFound $e) {
+            // In case the node didn't exist, this could be a lock-null request
+        }
+
+        if ($this->locksBackend) return $this->locksBackend->unlock($uri,$lockInfo);
+
+    }
+
+
+    /**
+     * Returns the contents of the HTTP Timeout header. 
+     * 
+     * The method formats the header into an integer.
+     *
+     * @return int
+     */
+    public function getTimeoutHeader() {
+
+        $header = $this->server->httpRequest->getHeader('Timeout');
+        
+        if ($header) {
+
+            if (stripos($header,'second-')===0) $header = (int)(substr($header,7));
+            else if (strtolower($header)=='infinite') $header=Sabre_DAV_Locks_LockInfo::TIMEOUT_INFINITE;
+            else throw new Sabre_DAV_Exception_BadRequest('Invalid HTTP timeout header');
+
+        } else {
+
+            $header = 0;
+
+        }
+
+        return $header;
+
+    }
+
+    /**
+     * Generates the response for successfull LOCK requests 
+     * 
+     * @param Sabre_DAV_Locks_LockInfo $lockInfo 
+     * @return string 
+     */
+    protected function generateLockResponse(Sabre_DAV_Locks_LockInfo $lockInfo) {
+
+        $dom = new DOMDocument('1.0','utf-8');
+        $dom->formatOutput = true;
+        
+        $prop = $dom->createElementNS('DAV:','d:prop');
+        $dom->appendChild($prop);
+
+        $lockDiscovery = $dom->createElementNS('DAV:','d:lockdiscovery');
+        $prop->appendChild($lockDiscovery);
+
+        $lockObj = new Sabre_DAV_Property_LockDiscovery(array($lockInfo),true);
+        $lockObj->serialize($this->server,$lockDiscovery);
+
+        return $dom->saveXML();
+
+    }
+    
+    /**
+     * validateLock should be called when a write operation is about to happen
+     * It will check if the requested url is locked, and see if the correct lock tokens are passed 
+     *
+     * @param mixed $urls List of relevant urls. Can be an array, a string or nothing at all for the current request uri
+     * @param mixed $lastLock This variable will be populated with the last checked lock object (Sabre_DAV_Locks_LockInfo)
+     * @return bool
+     */
+    protected function validateLock($urls = null,&$lastLock = null) {
+
+        if (is_null($urls)) {
+            $urls = array($this->server->getRequestUri());
+        } elseif (is_string($urls)) {
+            $urls = array($urls);
+        } elseif (!is_array($urls)) {
+            throw new Sabre_DAV_Exception('The urls parameter should either be null, a string or an array');
+        }
+
+        $conditions = $this->getIfConditions();
+
+        // We're going to loop through the urls and make sure all lock conditions are satisfied
+        foreach($urls as $url) {
+
+            $locks = $this->getLocks($url);
+
+            // If there were no conditions, but there were locks, we fail 
+            if (!$conditions && $locks) {
+                reset($locks);
+                $lastLock = current($locks);
+                return false;
+            }
+          
+            // If there were no locks or conditions, we go to the next url
+            if (!$locks && !$conditions) continue;
+
+            foreach($conditions as $condition) {
+
+                $conditionUri = $condition['uri']?$this->server->calculateUri($condition['uri']):'';
+
+                // If the condition has a url, and it isn't part of the affected url at all, check the next condition
+                if ($conditionUri && strpos($url,$conditionUri)!==0) continue;
+
+                // The tokens array contians arrays with 2 elements. 0=true/false for normal/not condition, 1=locktoken
+                // At least 1 condition has to be satisfied
+                foreach($condition['tokens'] as $conditionToken) {
+
+                    $etagValid = true;
+                    $lockValid  = true;
+
+                    // key 2 can contain an etag
+                    if ($conditionToken[2]) {
+
+                        $uri = $conditionUri?$conditionUri:$this->server->getRequestUri(); 
+                        $node = $this->server->tree->getNodeForPath($uri);
+                        $etagValid = $node->getETag()==$conditionToken[2];
+
+                    }
+
+                    // key 1 can contain a lock token
+                    if ($conditionToken[1]) {
+
+                        $lockValid = false;
+                        // Match all the locks
+                        foreach($locks as $lockIndex=>$lock) {
+
+                            $lockToken = 'opaquelocktoken:' . $lock->token;
+
+                            // Checking NOT
+                            if (!$conditionToken[0] && $lockToken != $conditionToken[1]) {
+
+                                // Condition valid, onto the next
+                                $lockValid = true;
+                                break;
+                            }
+                            if ($conditionToken[0] && $lockToken == $conditionToken[1]) {
+
+                                $lastLock = $lock;
+                                // Condition valid and lock matched
+                                unset($locks[$lockIndex]);
+                                $lockValid = true;
+                                break;
+
+                            }
+
+                        }
+
+                    }
+
+                    // If, after checking both etags and locks they are stil valid,
+                    // we can continue with the next condition.
+                    if ($etagValid && $lockValid) continue 2;
+               }
+               // No conditions matched, so we fail
+               throw new Sabre_DAV_Exception_PreconditionFailed('The tokens provided in the if header did not match','If');
+            }
+
+            // Conditions were met, we'll also need to check if all the locks are gone
+            if (count($locks)) {
+
+                reset($locks);
+
+                // There's still locks, we fail
+                $lastLock = current($locks);
+                return false;
+
+            }
+
+
+        }
+
+        // We got here, this means every condition was satisfied
+        return true;
+
+    }
+
+    /**
+     * This method is created to extract information from the WebDAV HTTP 'If:' header
+     *
+     * The If header can be quite complex, and has a bunch of features. We're using a regex to extract all relevant information
+     * The function will return an array, containg structs with the following keys
+     *
+     *   * uri   - the uri the condition applies to. This can be an empty string for 'every relevant url'
+     *   * tokens - The lock token. another 2 dimensional array containg 2 elements (0 = true/false.. If this is a negative condition its set to false, 1 = the actual token)
+     *   * etag - an etag, if supplied
+     * 
+     * @return void
+     */
+    public function getIfConditions() {
+
+        $header = $this->server->httpRequest->getHeader('If'); 
+        if (!$header) return array();
+
+        $matches = array();
+
+        $regex = '/(?:\<(?P<uri>.*?)\>\s)?\((?P<not>Not\s)?(?:\<(?P<token>[^\>]*)\>)?(?:\s?)(?:\[(?P<etag>[^\]]*)\])?\)/im'; 
+        preg_match_all($regex,$header,$matches,PREG_SET_ORDER);
+
+        $conditions = array();
+
+        foreach($matches as $match) {
+
+            $condition = array(
+                'uri'   => $match['uri'],
+                'tokens' => array(
+                    array($match['not']?0:1,$match['token'],isset($match['etag'])?$match['etag']:'')
+                ),    
+            );
+
+            if (!$condition['uri'] && count($conditions)) $conditions[count($conditions)-1]['tokens'][] = array(
+                $match['not']?0:1,
+                $match['token'],
+                isset($match['etag'])?$match['etag']:''
+            );
+            else {
+                $conditions[] = $condition;
+            }
+
+        }
+
+        return $conditions;
+
+    }
+
+    /**
+     * Parses a webdav lock xml body, and returns a new Sabre_DAV_Locks_LockInfo object 
+     * 
+     * @param string $body 
+     * @return Sabre_DAV_Locks_LockInfo
+     */
+    protected function parseLockRequest($body) {
+
+        $xml = simplexml_load_string($body,null,LIBXML_NOWARNING);
+        $xml->registerXPathNamespace('d','DAV:');
+        $lockInfo = new Sabre_DAV_Locks_LockInfo();
+     
+        $lockInfo->owner = (string)$xml->owner;
+
+        $lockToken = '44445502';
+        $id = md5(microtime() . 'somethingrandom');
+        $lockToken.='-' . substr($id,0,4) . '-' . substr($id,4,4) . '-' . substr($id,8,4) . '-' . substr($id,12,12);
+
+        $lockInfo->token = $lockToken;
+        $lockInfo->scope = count($xml->xpath('d:lockscope/d:exclusive'))>0?Sabre_DAV_Locks_LockInfo::EXCLUSIVE:Sabre_DAV_Locks_LockInfo::SHARED;
+
+        return $lockInfo;
+
+    }
+
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Locks/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/DAV/Mount/Plugin.php

@@ -0,0 +1,79 @@
+<?php
+
+/**
+ * This plugin provides support for RFC4709: Mounting WebDAV servers
+ *
+ * Simply append ?mount to any collection to generate the davmount response.
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ */
+class Sabre_DAV_Mount_Plugin extends Sabre_DAV_ServerPlugin {
+
+    /**
+     * Reference to Server class 
+     * 
+     * @var Sabre_DAV_Server 
+     */
+    private $server;
+
+    /**
+     * Initializes the plugin and registers event handles 
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @return void
+     */
+    public function initialize(Sabre_DAV_Server $server) {
+
+        $this->server = $server;
+        $this->server->subscribeEvent('beforeMethod',array($this,'beforeMethod'), 90);
+
+    }
+
+    /**
+     * 'beforeMethod' event handles. This event handles intercepts GET requests ending
+     * with ?mount
+     * 
+     * @param string $method 
+     * @return void
+     */
+    public function beforeMethod($method, $uri) {
+
+        if ($method!='GET') return;
+        if ($this->server->httpRequest->getQueryString()!='mount') return;
+
+        $currentUri = $this->server->httpRequest->getAbsoluteUri();
+
+        // Stripping off everything after the ?
+        list($currentUri) = explode('?',$currentUri);
+
+        $this->davMount($currentUri);
+
+        // Returning false to break the event chain
+        return false;
+
+    }
+
+    /**
+     * Generates the davmount response 
+     * 
+     * @param string $uri absolute uri 
+     * @return void
+     */
+    public function davMount($uri) {
+       
+        $this->server->httpResponse->sendStatus(200);
+        $this->server->httpResponse->setHeader('Content-Type','application/davmount+xml');
+        ob_start();
+        echo '<?xml version="1.0"?>', "\n";
+        echo "<dm:mount xmlns:dm=\"http://purl.org/NET/webdav/mount\">\n";
+        echo "  <dm:url>", htmlspecialchars($uri, ENT_NOQUOTES, 'UTF-8'), "</dm:url>\n";
+        echo "</dm:mount>";
+        $this->server->httpResponse->sendBody(ob_get_clean());
+
+    }
+
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Mount/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/DAV/Node.php

@@ -0,0 +1,55 @@
+<?php
+
+/**
+ * Node class
+ *
+ * This is a helper class, that should aid in getting nodes setup. 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_Node implements Sabre_DAV_INode {
+
+    /**
+     * Returns the last modification time 
+     *
+     * In this case, it will simply return the current time
+     *
+     * @return int 
+     */
+    public function getLastModified() {
+
+        return time();
+
+    }
+
+    /**
+     * Deleted the current node
+     *
+     * @throws Sabre_DAV_Exception_Forbidden
+     * @return void 
+     */
+    public function delete() {
+
+        throw new Sabre_DAV_Exception_Forbidden('Permission denied to delete node');
+
+    }
+
+    /**
+     * Renames the node
+     * 
+     * @throws Sabre_DAV_Exception_Forbidden
+     * @param string $name The new name
+     * @return void
+     */
+    public function setName($name) {
+
+        throw new Sabre_DAV_Exception_Forbidden('Permission denied to rename file');
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/ObjectTree.php

@@ -0,0 +1,149 @@
+<?php
+
+/**
+ * ObjectTree class
+ *
+ * This implementation of the Tree class makes use of the INode, IFile and ICollection API's 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_ObjectTree extends Sabre_DAV_Tree {
+
+    /**
+     * The root node 
+     * 
+     * @var Sabre_DAV_ICollection
+     */
+    protected $rootNode;
+
+    /**
+     * This is the node cache. Accessed nodes are stored here 
+     * 
+     * @var array 
+     */
+    protected $cache = array();
+
+    /**
+     * Creates the object
+     *
+     * This method expects the rootObject to be passed as a parameter
+     * 
+     * @param Sabre_DAV_ICollection $rootNode 
+     * @return void
+     */
+    public function __construct(Sabre_DAV_ICollection $rootNode) {
+
+        $this->rootNode = $rootNode;
+
+    }
+
+    /**
+     * Returns the INode object for the requested path  
+     * 
+     * @param string $path 
+     * @return Sabre_DAV_INode 
+     */
+    public function getNodeForPath($path) {
+
+        $path = trim($path,'/');
+        if (isset($this->cache[$path])) return $this->cache[$path];
+
+        //if (!$path || $path=='.') return $this->rootNode;
+        $currentNode = $this->rootNode;
+        $i=0;
+        // We're splitting up the path variable into folder/subfolder components and traverse to the correct node.. 
+        foreach(explode('/',$path) as $pathPart) {
+
+            // If this part of the path is just a dot, it actually means we can skip it
+            if ($pathPart=='.' || $pathPart=='') continue;
+
+            if (!($currentNode instanceof Sabre_DAV_ICollection))
+                throw new Sabre_DAV_Exception_FileNotFound('Could not find node at path: ' . $path);
+
+            $currentNode = $currentNode->getChild($pathPart); 
+
+        }
+
+        $this->cache[$path] = $currentNode;
+        return $currentNode;
+
+    }
+
+    /**
+     * This function allows you to check if a node exists.
+     *
+     * @param string $path 
+     * @return bool 
+     */
+    public function nodeExists($path) {
+
+        try {
+
+            list($parent, $base) = Sabre_DAV_URLUtil::splitPath($path);
+            $parentNode = $this->getNodeForPath($parent);
+            return $parentNode->childExists($base);
+
+        } catch (Sabre_DAV_Exception_FileNotFound $e) {
+
+            return false;
+
+        }
+
+    }
+
+    /**
+     * Returns a list of childnodes for a given path. 
+     * 
+     * @param string $path 
+     * @return array 
+     */
+    public function getChildren($path) {
+
+        $node = $this->getNodeForPath($path);
+        $children = $node->getChildren();
+        foreach($children as $child) {
+
+            $this->cache[trim($path,'/') . '/' . $child->getName()] = $child;
+
+        }
+        return $children;
+
+    }
+
+    /**
+     * This method is called with every tree update
+     *
+     * Examples of tree updates are:
+     *   * node deletions
+     *   * node creations
+     *   * copy
+     *   * move
+     *   * renaming nodes 
+     * 
+     * If Tree classes implement a form of caching, this will allow
+     * them to make sure caches will be expired.
+     * 
+     * If a path is passed, it is assumed that the entire subtree is dirty
+     *
+     * @param string $path 
+     * @return void
+     */
+    public function markDirty($path) {
+
+        // We don't care enough about sub-paths
+        // flushing the entire cache
+        $path = trim($path,'/');
+        foreach($this->cache as $nodePath=>$node) {
+            if ($nodePath == $path || strpos($nodePath,$path.'/')===0)
+                unset($this->cache[$nodePath]);
+            
+        }
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Property.php

@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * Abstract property class
+ *
+ * Extend this class to create custom complex properties
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/)
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_Property {
+
+    abstract function serialize(Sabre_DAV_Server $server, DOMElement $prop); 
+
+    static function unserialize(DOMElement $prop) {
+
+        return null;
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Property/GetLastModified.php

@@ -0,0 +1,75 @@
+<?php
+
+/**
+ * This property represents the {DAV:}getlastmodified property.
+ * 
+ * Although this is normally a simple property, windows requires us to add
+ * some new attributes.
+ *
+ * This class uses unix timestamps internally, and converts them to RFC 1123 times for 
+ * serialization
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Property_GetLastModified extends Sabre_DAV_Property {
+
+    /**
+     * time 
+     * 
+     * @var int 
+     */
+    public $time;
+
+    /**
+     * __construct 
+     * 
+     * @param int|DateTime $time 
+     * @return void
+     */
+    public function __construct($time) {
+
+        if ($time instanceof DateTime) {
+            $this->time = $time;
+        } elseif (is_int($time) || ctype_digit($time)) {
+            $this->time = new DateTime('@' . $time);
+        } else {
+            $this->time = new DateTime($time);
+        }
+
+        // Setting timezone to UTC
+        $this->time->setTimezone(new DateTimeZone('UTC'));
+
+    }
+
+    /**
+     * serialize 
+     * 
+     * @param DOMElement $prop 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server, DOMElement $prop) {
+
+        $doc = $prop->ownerDocument;
+        $prop->setAttribute('xmlns:b','urn:uuid:c2f41010-65b3-11d1-a29f-00aa00c14882/');
+        $prop->setAttribute('b:dt','dateTime.rfc1123');
+        $prop->nodeValue = $this->time->format(DateTime::RFC1123);
+
+    }
+
+    /**
+     * getTime 
+     * 
+     * @return DateTime 
+     */
+    public function getTime() {
+
+        return $this->time;
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Property/Href.php

@@ -0,0 +1,91 @@
+<?php
+
+/**
+ * Href property
+ *
+ * The href property represpents a url within a {DAV:}href element.
+ * This is used by many WebDAV extensions, but not really within the WebDAV core spec
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Property_Href extends Sabre_DAV_Property implements Sabre_DAV_Property_IHref {
+
+    /**
+     * href 
+     * 
+     * @var string 
+     */
+    private $href;
+
+    /**
+     * Automatically prefix the url with the server base directory 
+     * 
+     * @var bool 
+     */
+    private $autoPrefix = true;
+
+    /**
+     * __construct 
+     * 
+     * @param string $href 
+     * @return void
+     */
+    public function __construct($href, $autoPrefix = true) {
+
+        $this->href = $href;
+        $this->autoPrefix = $autoPrefix;
+
+    }
+
+    /**
+     * Returns the uri 
+     * 
+     * @return string 
+     */
+    public function getHref() {
+
+        return $this->href;
+
+    }
+
+    /**
+     * Serializes this property.
+     *
+     * It will additionally prepend the href property with the server's base uri.
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @param DOMElement $dom 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $dom) {
+
+        $prefix = $server->xmlNamespaces['DAV:'];
+
+        $elem = $dom->ownerDocument->createElement($prefix . ':href');
+        $elem->nodeValue = ($this->autoPrefix?$server->getBaseUri():'') . $this->href;
+        $dom->appendChild($elem);
+
+    }
+
+    /**
+     * Unserializes this property from a DOM Element 
+     *
+     * This method returns an instance of this class.
+     * It will only decode {DAV:}href values. For non-compatible elements null will be returned.
+     *
+     * @param DOMElement $dom 
+     * @return Sabre_DAV_Property_Href 
+     */
+    static function unserialize(DOMElement $dom) {
+
+        if (Sabre_DAV_XMLUtil::toClarkNotation($dom->firstChild)==='{DAV:}href') {
+            return new self($dom->firstChild->textContent,false);
+        }
+
+    } 
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Property/IHref.php

@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * IHref interface
+ *
+ * Any property implementing this interface can expose a related url.
+ * This is used by certain subsystems to aquire more information about for example
+ * the owner of a file
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+interface Sabre_DAV_Property_IHref {
+
+    /**
+     * getHref 
+     * 
+     * @return string 
+     */
+    function getHref();
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Property/LockDiscovery.php

@@ -0,0 +1,85 @@
+<?php
+
+/**
+ * Represents {DAV:}lockdiscovery property
+ *
+ * This property contains all the open locks on a given resource
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Property_LockDiscovery extends Sabre_DAV_Property {
+
+    /**
+     * locks 
+     * 
+     * @var array 
+     */
+    public $locks;
+ 
+    /**
+     * Should we show the locktoken as well? 
+     * 
+     * @var bool 
+     */
+    public $revealLockToken;
+
+    /**
+     * __construct 
+     * 
+     * @param array $locks 
+     * @param bool $revealLockToken 
+     * @return void
+     */
+    public function __construct($locks,$revealLockToken = false) {
+
+        $this->locks = $locks;
+        $this->revealLockToken = $revealLockToken;
+
+    }
+
+    /**
+     * serialize 
+     * 
+     * @param DOMElement $prop 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $prop) {
+
+        $doc = $prop->ownerDocument;
+
+        foreach($this->locks as $lock) {
+
+            $activeLock = $doc->createElementNS('DAV:','d:activelock');
+            $prop->appendChild($activeLock);
+
+            $lockScope = $doc->createElementNS('DAV:','d:lockscope');
+            $activeLock->appendChild($lockScope);
+
+            $lockScope->appendChild($doc->createElementNS('DAV:','d:' . ($lock->scope==Sabre_DAV_Locks_LockInfo::EXCLUSIVE?'exclusive':'shared')));
+
+            $lockType = $doc->createElementNS('DAV:','d:locktype');
+            $activeLock->appendChild($lockType);
+
+            $lockType->appendChild($doc->createElementNS('DAV:','d:write'));
+
+            $activeLock->appendChild($doc->createElementNS('DAV:','d:depth',($lock->depth == Sabre_DAV_Server::DEPTH_INFINITY?'infinity':$lock->depth)));
+            $activeLock->appendChild($doc->createElementNS('DAV:','d:timeout','Second-' . $lock->timeout));
+
+            if ($this->revealLockToken) {
+                $lockToken = $doc->createElementNS('DAV:','d:locktoken');
+                $activeLock->appendChild($lockToken);
+                $lockToken->appendChild($doc->createElementNS('DAV:','d:href','opaquelocktoken:' . $lock->token));
+            }
+           
+            $activeLock->appendChild($doc->createElementNS('DAV:','d:owner',$lock->owner));
+
+        }
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Property/Principal.php

@@ -0,0 +1,126 @@
+<?php
+
+/**
+ * Principal property
+ *
+ * The principal property represents a principal from RFC3744 (ACL).
+ * The property can be used to specify a principal or pseudo principals. 
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Property_Principal extends Sabre_DAV_Property implements Sabre_DAV_Property_IHref {
+
+    /**
+     * To specify a not-logged-in user, use the UNAUTHENTICTED principal
+     */
+    const UNAUTHENTICATED = 1;
+
+    /**
+     * To specify any principal that is logged in, use AUTHENTICATED
+     */
+    const AUTHENTICATED = 2;
+
+    /**
+     * Specific princpals can be specified with the HREF
+     */
+    const HREF = 3;
+
+    /**
+     * Principal-type
+     *
+     * Must be one of the UNAUTHENTICATED, AUTHENTICATED or HREF constants.
+     * 
+     * @var int 
+     */
+    private $type;
+
+    /**
+     * Url to principal
+     *
+     * This value is only used for the HREF principal type.
+     * 
+     * @var string 
+     */
+    private $href;
+
+    /**
+     * Creates the property.
+     *
+     * The 'type' argument must be one of the type constants defined in this class.
+     *
+     * 'href' is only required for the HREF type.
+     * 
+     * @param int $type 
+     * @param string $href 
+     * @return void
+     */
+    public function __construct($type, $href = null) {
+
+        $this->type = $type;
+
+        if ($type===self::HREF && is_null($href)) {
+            throw new Sabre_DAV_Exception('The href argument must be specified for the HREF principal type.');
+        }
+        $this->href = $href;
+
+    }
+
+    /**
+     * Returns the principal type 
+     * 
+     * @return int 
+     */
+    public function getType() {
+
+        return $this->type;
+
+    }
+
+    /**
+     * Returns the principal uri. 
+     * 
+     * @return string
+     */
+    public function getHref() {
+
+        return $this->href;
+
+    }
+
+    /**
+     * Serializes the property into a DOMElement. 
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @param DOMElement $node 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server, DOMElement $node) {
+
+        $prefix = $server->xmlNamespaces['DAV:'];
+        switch($this->type) {
+
+            case self::UNAUTHENTICATED :
+                $node->appendChild(
+                    $node->ownerDocument->createElement($prefix . ':unauthenticated')
+                );
+                break;
+            case self::AUTHENTICATED :
+                $node->appendChild(
+                    $node->ownerDocument->createElement($prefix . ':authenticated')
+                );
+                break;
+            case self::HREF :
+                $href = $node->ownerDocument->createElement($prefix . ':href');
+                $href->nodeValue = $server->getBaseUri() . $this->href;
+                $node->appendChild($href);
+                break;
+
+        }
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Property/ResourceType.php

@@ -0,0 +1,80 @@
+<?php
+
+/**
+ * This class represents the {DAV:}resourcetype property
+ *
+ * Normally for files this is empty, and for collection {DAV:}collection.
+ * However, other specs define different values for this. 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/)
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Property_ResourceType extends Sabre_DAV_Property {
+
+    /**
+     * resourceType 
+     * 
+     * @var string 
+     */
+    public $resourceType = null;
+
+    /**
+     * __construct 
+     * 
+     * @param mixed $resourceType 
+     * @return void
+     */
+    public function __construct($resourceType = null) {
+
+        if ($resourceType === Sabre_DAV_Server::NODE_FILE)
+            $this->resourceType = null;
+        elseif ($resourceType === Sabre_DAV_Server::NODE_DIRECTORY)
+            $this->resourceType = '{DAV:}collection';
+        else 
+            $this->resourceType = $resourceType;
+
+    }
+
+    /**
+     * serialize 
+     * 
+     * @param DOMElement $prop 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $prop) {
+
+        $propName = null;
+        $rt = $this->resourceType;
+        if (!is_array($rt)) $rt = array($rt);
+        
+        foreach($rt as $resourceType) {
+            if (preg_match('/^{([^}]*)}(.*)$/',$resourceType,$propName)) { 
+       
+                if (isset($server->xmlNamespaces[$propName[1]])) {
+                    $prop->appendChild($prop->ownerDocument->createElement($server->xmlNamespaces[$propName[1]] . ':' . $propName[2]));
+                } else {
+                    $prop->appendChild($prop->ownerDocument->createElementNS($propName[1],'custom:' . $propName[2]));
+                }
+            
+            }
+        }
+
+    }
+
+    /**
+     * Returns the value in clark-notation
+     *
+     * For example '{DAV:}collection'
+     * 
+     * @return string 
+     */
+    public function getValue() {
+
+        return $this->resourceType;
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Property/Response.php

@@ -0,0 +1,156 @@
+<?php
+
+/**
+ * Response property 
+ * 
+ * This class represents the {DAV:}response XML element.
+ * This is used by the Server class to encode individual items within a multistatus 
+ * response.
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Property_Response extends Sabre_DAV_Property implements Sabre_DAV_Property_IHref {
+
+    /**
+     * Url for the response 
+     * 
+     * @var string 
+     */
+    private $href;
+
+    /**
+     * Propertylist, ordered by HTTP status code 
+     * 
+     * @var array 
+     */
+    private $responseProperties;
+
+    /**
+     * The responseProperties argument is a list of properties
+     * within an array with keys representing HTTP status codes
+     * 
+     * @param string $href 
+     * @param array $responseProperties 
+     * @return void
+     */
+    public function __construct($href,array $responseProperties) {
+
+        $this->href = $href;
+        $this->responseProperties = $responseProperties; 
+
+    }
+
+    /**
+     * Returns the url 
+     * 
+     * @return string 
+     */
+    public function getHref() {
+
+        return $this->href;
+
+    }
+
+    /**
+     * Returns the property list 
+     * 
+     * @return array 
+     */
+    public function getResponseProperties() {
+
+        return $this->responseProperties;
+
+    }
+
+    /**
+     * serialize 
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @param DOMElement $dom 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $dom) {
+
+        $document = $dom->ownerDocument;
+        $properties = $this->responseProperties;
+        
+        $xresponse = $document->createElement('d:response');
+        $dom->appendChild($xresponse); 
+
+        $uri = Sabre_DAV_URLUtil::encodePath($this->href);
+
+        // Adding the baseurl to the beginning of the url
+        $uri = $server->getBaseUri() . $uri;
+
+        $xresponse->appendChild($document->createElement('d:href',$uri));
+       
+        // The properties variable is an array containing properties, grouped by
+        // HTTP status
+        foreach($properties as $httpStatus=>$propertyGroup) {
+
+            // The 'href' is also in this array, and it's special cased.
+            // We will ignore it
+            if ($httpStatus=='href') continue;
+
+            // If there are no properties in this group, we can also just carry on
+            if (!count($propertyGroup)) continue;
+
+            $xpropstat = $document->createElement('d:propstat');
+            $xresponse->appendChild($xpropstat);
+
+            $xprop = $document->createElement('d:prop');
+            $xpropstat->appendChild($xprop);
+
+            $nsList = $server->xmlNamespaces;
+
+            foreach($propertyGroup as $propertyName=>$propertyValue) {
+
+                $propName = null;
+                preg_match('/^{([^}]*)}(.*)$/',$propertyName,$propName);
+            
+                // special case for empty namespaces
+                if ($propName[1]=='') {
+
+                    $currentProperty = $document->createElement($propName[2]);
+                    $xprop->appendChild($currentProperty);
+                    $currentProperty->setAttribute('xmlns','');
+
+                } else {
+
+                    if (!isset($nsList[$propName[1]])) {
+                        $nsList[$propName[1]] = 'x' . count($nsList);
+                    }
+
+                    // If the namespace was defined in the top-level xml namespaces, it means 
+                    // there was already a namespace declaration, and we don't have to worry about it.
+                    if (isset($server->xmlNamespaces[$propName[1]])) {
+                        $currentProperty = $document->createElement($nsList[$propName[1]] . ':' . $propName[2]);
+                    } else {
+                        $currentProperty = $document->createElementNS($propName[1],$nsList[$propName[1]].':' . $propName[2]);
+                    }
+                    $xprop->appendChild($currentProperty);
+
+                }
+
+                if (is_scalar($propertyValue)) {
+                    $text = $document->createTextNode($propertyValue);
+                    $currentProperty->appendChild($text);
+                } elseif ($propertyValue instanceof Sabre_DAV_Property) {
+                    $propertyValue->serialize($server,$currentProperty);
+                } elseif (!is_null($propertyValue)) {
+                    throw new Sabre_DAV_Exception('Unknown property value type: ' . gettype($propertyValue) . ' for property: ' . $propertyName);
+                }
+
+            }
+
+            $xpropstat->appendChild($document->createElement('d:status',$server->httpResponse->getStatusMessage($httpStatus)));
+
+        }
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Property/SupportedLock.php

@@ -0,0 +1,76 @@
+<?php
+
+/**
+ * This class represents the {DAV:}supportedlock property
+ *
+ * This property contains information about what kind of locks
+ * this server supports.
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/)
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Property_SupportedLock extends Sabre_DAV_Property {
+
+    /**
+     * supportsLocks 
+     * 
+     * @var mixed
+     */
+    public $supportsLocks = false;
+
+    /**
+     * __construct 
+     * 
+     * @param mixed $supportsLocks 
+     * @return void
+     */
+    public function __construct($supportsLocks) {
+
+        $this->supportsLocks = $supportsLocks;
+
+    }
+
+    /**
+     * serialize 
+     * 
+     * @param DOMElement $prop 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $prop) {
+
+        $doc = $prop->ownerDocument;
+
+        if (!$this->supportsLocks) return null;
+
+        $lockEntry1 = $doc->createElementNS('DAV:','d:lockentry');
+        $lockEntry2 = $doc->createElementNS('DAV:','d:lockentry');
+
+        $prop->appendChild($lockEntry1);
+        $prop->appendChild($lockEntry2);
+
+        $lockScope1 = $doc->createElementNS('DAV:','d:lockscope');
+        $lockScope2 = $doc->createElementNS('DAV:','d:lockscope');
+        $lockType1 = $doc->createElementNS('DAV:','d:locktype');
+        $lockType2 = $doc->createElementNS('DAV:','d:locktype');
+
+        $lockEntry1->appendChild($lockScope1);
+        $lockEntry1->appendChild($lockType1);
+        $lockEntry2->appendChild($lockScope2);
+        $lockEntry2->appendChild($lockType2);
+
+        $lockScope1->appendChild($doc->createElementNS('DAV:','d:exclusive'));
+        $lockScope2->appendChild($doc->createElementNS('DAV:','d:shared'));
+
+        $lockType1->appendChild($doc->createElementNS('DAV:','d:write'));
+        $lockType2->appendChild($doc->createElementNS('DAV:','d:write'));
+
+        //$frag->appendXML('<d:lockentry><d:lockscope><d:exclusive /></d:lockscope><d:locktype><d:write /></d:locktype></d:lockentry>');
+        //$frag->appendXML('<d:lockentry><d:lockscope><d:shared /></d:lockscope><d:locktype><d:write /></d:locktype></d:lockentry>');
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Property/SupportedReportSet.php

@@ -0,0 +1,110 @@
+<?php
+
+/**
+ * supported-report-set property.
+ *
+ * This property is defined in RFC3253, but since it's
+ * so common in other webdav-related specs, it is part of the core server.
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Property_SupportedReportSet extends Sabre_DAV_Property {
+
+    /**
+     * List of reports 
+     * 
+     * @var array
+     */
+    protected $reports = array();
+
+    /**
+     * Creates the property
+     *
+     * Any reports passed in the constructor
+     * should be valid report-types in clark-notation.
+     *
+     * Either a string or an array of strings must be passed.
+     * 
+     * @param mixed $reports 
+     * @return void
+     */
+    public function __construct($report = null) {
+
+        if (!is_null($report)) 
+            $this->addReport($reports);
+
+    }
+
+    /**
+     * Adds a report to this property
+     *
+     * The report must be a string in clark-notation.
+     * Multiple reports can be specified as an array.
+     * 
+     * @param mixed $report 
+     * @return void
+     */
+    public function addReport($report) {
+
+        if (!is_array($report)) $report = array($report);
+
+        foreach($report as $r) {
+
+            if (!preg_match('/^{([^}]*)}(.*)$/',$r)) 
+                throw new Sabre_DAV_Exception('Reportname must be in clark-notation');
+
+            $this->reports[] = $r;
+
+        }
+
+    }
+
+    /**
+     * Returns the list of supported reports
+     * 
+     * @return array 
+     */
+    public function getValue() {
+
+        return $this->reports;
+
+    }
+
+    /**
+     * Serializes the node 
+     *
+     * @param Sabre_DAV_Server $server
+     * @param DOMElement $prop 
+     * @return void
+     */
+    public function serialize(Sabre_DAV_Server $server,DOMElement $prop) {
+
+        foreach($this->reports as $reportName) {
+     
+            $supportedReport = $prop->ownerDocument->createElement('d:supported-report');
+            $prop->appendChild($supportedReport);
+
+            $report = $prop->ownerDocument->createElement('d:report');
+            $supportedReport->appendChild($report);
+
+            preg_match('/^{([^}]*)}(.*)$/',$reportName,$matches);
+            
+            list(, $namespace, $element) = $matches;
+       
+            $prefix = isset($server->xmlNamespaces[$namespace])?$server->xmlNamespaces[$namespace]:null;
+
+            if ($prefix) {
+                $report->appendChild($prop->ownerDocument->createElement($prefix . ':' . $element));
+            } else {
+                $report->appendChild($prop->ownerDocument->createElementNS($namespace, 'x:' . $element));
+            }
+
+        }
+
+    }
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Property/index.html

@@ -0,0 +1,10 @@
+<html>
+<head><title>IP.Board - Bulletin Board System</title></head>
+<body>
+<h1>403: IP.Board -&gt; Forbidden</h1>
+<hr>
+You have reached this page in error, please use your back button to return to the forum.
+<hr>
+<a href="http://www.invisionpower.com/">IP.Board</a>
+</body>
+</html>

upload/ips_kernel/sabre/Sabre/DAV/ServerPlugin.php

@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * The baseclass for all server plugins.
+ *
+ * Plugins can modify or extend the servers behaviour. 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_ServerPlugin {
+
+    /**
+     * This initializes the plugin.
+     *
+     * This function is called by Sabre_DAV_Server, after
+     * addPlugin is called.
+     *
+     * This method should set up the requires event subscriptions.
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @return void
+     */
+    abstract public function initialize(Sabre_DAV_Server $server);
+    
+    /**
+     * This method should return a list of server-features. 
+     *
+     * This is for example 'versioning' and is added to the DAV: header
+     * in an OPTIONS response.
+     * 
+     * @return array
+     */
+    public function getFeatures() {
+
+        return array();
+
+    }
+
+    /**
+     * Use this method to tell the server this plugin defines additional
+     * HTTP methods.
+     *
+     * This method is passed a uri. It should only return HTTP methods that are 
+     * available for the specified uri.
+     *
+     * @param string $uri
+     * @return array 
+     */
+    public function getHTTPMethods($uri) {
+
+        return array();
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/SimpleDirectory.php

@@ -0,0 +1,106 @@
+<?php
+
+/**
+ * SimpleDirectory
+ *
+ * The SimpleDirectory is used to quickly setup static directory structures.
+ * Just create the object with a proper name, and add children to use it.
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_SimpleDirectory extends Sabre_DAV_Directory {
+
+    /**
+     * List of childnodes 
+     *
+     * @var array
+     */
+    protected $children = array();
+
+    /**
+     * Name of this resource 
+     * 
+     * @var string 
+     */
+    protected $name;
+
+    /**
+     * Creates this node
+     *
+     * The name of the node must be passed, child nodes can also be bassed.
+     * This nodes must be instances of Sabre_DAV_INode
+     * 
+     * @param string $name 
+     * @param array $children 
+     * @return void
+     */
+    public function __construct($name,array $children = array()) {
+
+        $this->name = $name;
+        foreach($children as $child) {
+
+            if (!($child instanceof Sabre_DAV_INode)) throw new Sabre_DAV_Exception('Only instances of Sabre_DAV_INode are allowed to be passed in the children argument');
+            $this->addChild($child);
+
+        }
+
+    }
+
+    /**
+     * Adds a new childnode to this collection 
+     * 
+     * @param Sabre_DAV_INode $child 
+     * @return void
+     */
+    public function addChild(Sabre_DAV_INode $child) {
+
+        $this->children[$child->getName()] = $child;
+
+    }
+
+    /**
+     * Returns the name of the collection 
+     * 
+     * @return string 
+     */
+    public function getName() {
+
+        return $this->name;
+
+    }
+
+    /**
+     * Returns a child object, by its name.
+     *
+     * This method makes use of the getChildren method to grab all the child nodes, and compares the name. 
+     * Generally its wise to override this, as this can usually be optimized
+     * 
+     * @param string $name
+     * @throws Sabre_DAV_Exception_FileNotFound
+     * @return Sabre_DAV_INode 
+     */
+    public function getChild($name) {
+
+        if (isset($this->children[$name])) return $this->children[$name];
+        throw new Sabre_DAV_Exception_FileNotFound('File not found: ' . $name);
+
+    }
+
+    /**
+     * Returns a list of children for this collection 
+     * 
+     * @return array 
+     */
+    public function getChildren() {
+
+        return array_values($this->children);
+
+    }
+
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/TemporaryFileFilterPlugin.php

@@ -0,0 +1,279 @@
+<?php
+
+/**
+ * Temporary File Filter Plugin
+ *
+ * The purpose of this filter is to intercept some of the garbage files
+ * operation systems and applications tend to generate when mounting
+ * a WebDAV share as a disk.
+ *
+ * It will intercept these files and place them in a separate directory.
+ * these files are not deleted automatically, so it is adviceable to
+ * delete these after they are not accessed for 24 hours.
+ *
+ * Currently it supports:
+ *   * OS/X style resource forks and .DS_Store
+ *   * desktop.ini and Thumbs.db (windows)
+ *   * .*.swp (vim temporary files)
+ *   * .dat.* (smultron temporary files)
+ *
+ * Additional patterns can be added, by adding on to the
+ * temporaryFilePatterns property.
+ *
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_TemporaryFileFilterPlugin extends Sabre_DAV_ServerPlugin {
+
+    /**
+     * This is the list of patterns we intercept.
+     * If new patterns are added, they must be valid patterns for preg_match.
+     * 
+     * @var array
+     */
+    public $temporaryFilePatterns = array(
+        '/^\._(.*)$/',     // OS/X resource forks
+        '/^.DS_Store$/',   // OS/X custom folder settings
+        '/^desktop.ini$/', // Windows custom folder settings
+        '/^Thumbs.db$/',   // Windows thumbnail cache
+        '/^.(.*).swp$/',   // ViM temporary files
+        '/^\.dat(.*)$/',   // Smultron seems to create these
+        '/^~lock.(.*)#$/', // Windows 7 lockfiles
+    );
+    
+    /**
+     * This is the directory where this plugin
+     * will store it's files.
+     * 
+     * @var string 
+     */
+    private $dataDir;
+
+    /**
+     * A reference to the main Server class
+     * 
+     * @var Sabre_DAV_Server 
+     */
+    private $server;
+
+    /**
+     * Creates the plugin.
+     *
+     * Make sure you specify a directory for your files. If you don't, we
+     * will use PHP's directory for session-storage instead, and you might
+     * not want that.
+     * 
+     * @param string $dataDir 
+     * @return void
+     */
+    public function __construct($dataDir = null) {
+
+        if (!$dataDir) $dataDir = ini_get('session.save_path').'/sabredav/';
+        if (!is_dir($dataDir)) mkdir($dataDir);
+        $this->dataDir = $dataDir;
+
+    } 
+
+    /**
+     * Initialize the plugin
+     *
+     * This is called automatically be the Server class after this plugin is
+     * added with Sabre_DAV_Server::addPlugin()
+     * 
+     * @param Sabre_DAV_Server $server 
+     * @return void
+     */
+    public function initialize(Sabre_DAV_Server $server) {
+
+        $this->server = $server;
+        $server->subscribeEvent('beforeMethod',array($this,'beforeMethod'));
+        $server->subscribeEvent('beforeCreateFile',array($this,'beforeCreateFile'));
+
+    }
+
+    /**
+     * This method is called before any HTTP method handler
+     *
+     * This method intercepts any GET, DELETE, PUT and PROPFIND calls to 
+     * filenames that are known to match the 'temporary file' regex.
+     * 
+     * @param string $method 
+     * @return bool 
+     */
+    public function beforeMethod($method, $uri) {
+
+        if (!$tempLocation = $this->isTempFile($uri))
+            return true;
+
+        switch($method) {
+            case 'GET' :
+                return $this->httpGet($tempLocation);
+            case 'PUT' :
+                return $this->httpPut($tempLocation);
+            case 'PROPFIND' :
+                return $this->httpPropfind($tempLocation, $uri);
+            case 'DELETE' :
+                return $this->httpDelete($tempLocation);
+         }
+         return true;
+
+    }
+
+    /**
+     * This method is invoked if some subsystem creates a new file.
+     *
+     * This is used to deal with HTTP LOCK requests which create a new 
+     * file.
+     * 
+     * @param string $uri 
+     * @param resource $data 
+     * @return bool 
+     */
+    public function beforeCreateFile($uri,$data) {
+
+        if ($tempPath = $this->isTempFile($uri)) {
+            
+            $hR = $this->server->httpResponse;
+            $hR->setHeader('X-Sabre-Temp','true');
+            file_put_contents($tempPath,$data);
+            return false;
+        }
+        return true; 
+
+    }
+
+    /**
+     * This method will check if the url matches the temporary file pattern
+     * if it does, it will return an path based on $this->dataDir for the 
+     * temporary file storage.
+     * 
+     * @param string $path 
+     * @return boolean|string 
+     */
+    protected function isTempFile($path) {
+
+        // We're only interested in the basename.
+        list(, $tempPath) = Sabre_DAV_URLUtil::splitPath($path);
+
+        foreach($this->temporaryFilePatterns as $tempFile) {
+
+            if (preg_match($tempFile,$tempPath)) {
+                return $this->dataDir . '/sabredav_' . md5($path) . '.tempfile';
+            }
+
+        }
+
+        return false;
+
+    }
+
+
+    /**
+     * This method handles the GET method for temporary files.
+     * If the file doesn't exist, it will return false which will kick in
+     * the regular system for the GET method.
+     * 
+     * @param string $tempLocation 
+     * @return bool 
+     */
+    public function httpGet($tempLocation) {
+
+        if (!file_exists($tempLocation)) return true;
+
+        $hR = $this->server->httpResponse;
+        $hR->setHeader('Content-Type','application/octet-stream');
+        $hR->setHeader('Content-Length',filesize($tempLocation));
+        $hR->setHeader('X-Sabre-Temp','true');
+        $hR->sendStatus(200);
+        $hR->sendBody(fopen($tempLocation,'r'));
+        return false;
+
+    }
+
+    /**
+     * This method handles the PUT method.
+     * 
+     * @param string $tempLocation 
+     * @return bool 
+     */
+    public function httpPut($tempLocation) {
+
+        $hR = $this->server->httpResponse;
+        $hR->setHeader('X-Sabre-Temp','true');
+
+        $newFile = !file_exists($tempLocation);
+       
+        if (!$newFile && ($this->server->httpRequest->getHeader('If-None-Match'))) {
+             throw new Sabre_DAV_Exception_PreconditionFailed('The resource already exists, and an If-None-Match header was supplied');
+        }
+
+        file_put_contents($tempLocation,$this->server->httpRequest->getBody());
+        $hR->sendStatus($newFile?201:200);
+        return false;
+
+    }
+
+    /**
+     * This method handles the DELETE method.
+     *
+     * If the file didn't exist, it will return false, which will make the 
+     * standard HTTP DELETE handler kick in.
+     * 
+     * @param string $tempLocation 
+     * @return bool 
+     */
+    public function httpDelete($tempLocation) {
+
+        if (!file_exists($tempLocation)) return true;
+
+        unlink($tempLocation);
+        $hR = $this->server->httpResponse;
+        $hR->setHeader('X-Sabre-Temp','true');
+        $hR->sendStatus(204);
+        return false;
+
+    }
+
+    /**
+     * This method handles the PROPFIND method. 
+     *
+     * It's a very lazy method, it won't bother checking the request body
+     * for which properties were requested, and just sends back a default
+     * set of properties.
+     *
+     * @param string $tempLocation 
+     * @return void
+     */
+    public function httpPropfind($tempLocation, $uri) {
+
+        if (!file_exists($tempLocation)) return true;
+       
+        $hR = $this->server->httpResponse;
+        $hR->setHeader('X-Sabre-Temp','true');
+        $hR->sendStatus(207);
+        $hR->setHeader('Content-Type','application/xml; charset=utf-8');
+
+        $requestedProps = $this->server->parsePropFindRequest($this->server->httpRequest->getBody(true)); 
+
+        $properties = array(
+            'href' => $uri,
+            200 => array(
+                '{DAV:}getlastmodified' => new Sabre_DAV_Property_GetLastModified(filemtime($tempLocation)),
+                '{DAV:}getcontentlength' => filesize($tempLocation),
+                '{DAV:}resourcetype' => new Sabre_DAV_Property_ResourceType(null),
+                '{'.Sabre_DAV_Server::NS_SABREDAV.'}tempFile' => true, 
+
+            ),
+         );
+
+        $data = $this->server->generateMultiStatus(array($properties));
+        $hR->sendBody($data);
+        return false;
+
+    }
+
+
+}

upload/ips_kernel/sabre/Sabre/DAV/Tree.php

@@ -0,0 +1,192 @@
+<?php
+
+/**
+ * Abstract tree object 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+abstract class Sabre_DAV_Tree {
+    
+    /**
+     * This function must return an INode object for a path
+     * If a Path doesn't exist, thrown an Exception_FileNotFound
+     * 
+     * @param string $path 
+     * @throws Exception_FileNotFound
+     * @return Sabre_DAV_INode 
+     */
+    abstract function getNodeForPath($path);
+
+    /**
+     * This function allows you to check if a node exists.
+     *
+     * Implementors of this class should override this method to make 
+     * it cheaper.
+     * 
+     * @param string $path 
+     * @return bool 
+     */
+    public function nodeExists($path) {
+
+        try {
+
+            $this->getNodeForPath($path);
+            return true;
+
+        } catch (Sabre_DAV_Exception_FileNotFound $e) {
+
+            return false;
+
+        }
+
+    }
+
+    /**
+     * Copies a file from path to another
+     *
+     * @param string $sourcePath The source location
+     * @param string $destinationPath The full destination path
+     * @return void 
+     */
+    public function copy($sourcePath, $destinationPath) {
+
+        $sourceNode = $this->getNodeForPath($sourcePath);
+       
+        // grab the dirname and basename components
+        list($destinationDir, $destinationName) = Sabre_DAV_URLUtil::splitPath($destinationPath);
+
+        $destinationParent = $this->getNodeForPath($destinationDir);
+        $this->copyNode($sourceNode,$destinationParent,$destinationName);
+
+        $this->markDirty($destinationDir);
+
+    }
+
+    /**
+     * Moves a file from one location to another 
+     * 
+     * @param string $sourcePath The path to the file which should be moved 
+     * @param string $destinationPath The full destination path, so not just the destination parent node
+     * @return int
+     */
+    public function move($sourcePath, $destinationPath) {
+
+        list($sourceDir, $sourceName) = Sabre_DAV_URLUtil::splitPath($sourcePath);
+        list($destinationDir, $destinationName) = Sabre_DAV_URLUtil::splitPath($destinationPath);
+
+        if ($sourceDir===$destinationDir) {
+            $renameable = $this->getNodeForPath($sourcePath);
+            $renameable->setName($destinationName);
+        } else {
+            $this->copy($sourcePath,$destinationPath);
+            $this->getNodeForPath($sourcePath)->delete();
+        }
+        $this->markDirty($sourceDir);
+        $this->markDirty($destinationDir);
+
+    }
+
+    /**
+     * Deletes a node from the tree 
+     * 
+     * @param string $path 
+     * @return void
+     */
+    public function delete($path) {
+
+        $node = $this->getNodeForPath($path);
+        $node->delete();
+        
+        list($parent) = Sabre_DAV_URLUtil::splitPath($path);
+        $this->markDirty($parent);
+
+    }
+
+    /**
+     * Returns a list of childnodes for a given path. 
+     * 
+     * @param string $path 
+     * @return array 
+     */
+    public function getChildren($path) {
+
+        $node = $this->getNodeForPath($path);
+        return $node->getChildren();
+
+    }
+
+    /**
+     * This method is called with every tree update
+     *
+     * Examples of tree updates are:
+     *   * node deletions
+     *   * node creations
+     *   * copy
+     *   * move
+     *   * renaming nodes 
+     * 
+     * If Tree classes implement a form of caching, this will allow
+     * them to make sure caches will be expired.
+     * 
+     * If a path is passed, it is assumed that the entire subtree is dirty
+     *
+     * @param string $path 
+     * @return void
+     */
+    public function markDirty($path) {
+
+
+    }
+
+    /**
+     * copyNode 
+     * 
+     * @param Sabre_DAV_INode $source 
+     * @param Sabre_DAV_ICollection $destination 
+     * @return void
+     */
+    protected function copyNode(Sabre_DAV_INode $source,Sabre_DAV_ICollection $destinationParent,$destinationName = null) {
+
+        if (!$destinationName) $destinationName = $source->getName();
+
+        if ($source instanceof Sabre_DAV_IFile) {
+
+            $data = $source->get();
+
+            // If the body was a string, we need to convert it to a stream
+            if (is_string($data)) {
+                $stream = fopen('php://temp','r+');
+                fwrite($stream,$data);
+                rewind($stream);
+                $data = $stream;
+            } 
+            $destinationParent->createFile($destinationName,$data);
+            $destination = $destinationParent->getChild($destinationName);
+
+        } elseif ($source instanceof Sabre_DAV_ICollection) {
+
+            $destinationParent->createDirectory($destinationName);
+            
+            $destination = $destinationParent->getChild($destinationName);
+            foreach($source->getChildren() as $child) {
+
+                $this->copyNode($child,$destination);
+
+            }
+
+        }
+        if ($source instanceof Sabre_DAV_IProperties && $destination instanceof Sabre_DAV_IProperties) {
+
+            $props = $source->getProperties(array());
+            $destination->updateProperties($props);
+
+        }
+
+    }
+
+}
+

upload/ips_kernel/sabre/Sabre/DAV/Tree/Filesystem.php

@@ -0,0 +1,124 @@
+<?php
+
+/**
+ * Sabre_DAV_Tree_Filesystem 
+ * 
+ * @package Sabre
+ * @subpackage DAV
+ * @copyright Copyright (C) 2007-2010 Rooftop Solutions. All rights reserved.
+ * @author Evert Pot (http://www.rooftopsolutions.nl/) 
+ * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
+ */
+class Sabre_DAV_Tree_Filesystem extends Sabre_DAV_Tree {
+
+    /**
+     * Base url on the filesystem.
+     *
+     * @var string 
+     */
+    protected $basePath;
+
+    /**
+     * Creates this tree
+     *
+     * Supply the path you'd like to share.
+     * 
+     * @param string $basePath 
+     * @return void
+     */
+    public function __construct($basePath) {
+
+        $this->basePath = $basePath;
+
+    }
+
+    /**
+     * Returns a new node for the given path 
+     * 
+     * @param string $path 
+     * @return void
+     */
+    public function getNodeForPath($path) {
+
+        $realPath = $this->getRealPath($path);
+        if (!file_exists($realPath)) throw new Sabre_DAV_Exception_FileNotFound('File at location ' . $realPath . ' not found');
+        if (is_dir($realPath)) { 
+            return new Sabre_DAV_FS_Directory($path);
+        } else {
+            return new Sabre_DAV_FS_File($path);
+        }
+
+    }
+
+    /**
+     * Returns the real filesystem path for a webdav url. 
+     * 
+     * @param string $publicPath 
+     * @return string 
+     */
+    protected function getRealPath($publicPath) {
+
+        return rtrim($this->basePath,'/') . '/' . trim($publicPath,'/');
+
+    }
+
+    /**
+     * Copies a file or directory.
+     *
+     * This method must work recursively and delete the destination
+     * if it exists
+     * 
+     * @param string $source 
+     * @param string $destination 
+     * @return void
+     */
+    public function copy($source,$destination) {
+
+        $source = $this->getRealPath($source);
+        $destination = $this->getRealPath($destination);
+        $this->realCopy($source,$destination); 
+
+    }
+
+    /**
+     * Used by self::copy 
+     * 
+     * @param string $source 
+     * @param string $destination 
+     * @return void
+     */
+    protected function realCopy($source,$destination) {
+
+        if (is_file($source)) {
+            copy($source,$destination);
+        } else {
+            mkdir($destination);
+            foreach(scandir($source) as $subnode) {
+
+                if ($subnode=='.' || $subnode=='..') continue;
+                $this->realCopy($source.'/'.$subnode,$destination.'/'.$subnode);
+
+            }
+        }
+
+    }
+
+    /**
+     * Moves a file or directory recursively.
+     *
+     * If the destination exists, delete it first.
+     * 
+     * @param string $source 
+     * @param string $destination 
+     * @return void
+     */
+    public function move($source,$destination) {
+
+        $source = $this->getRealPath($source);
+        $destination = $this->getRealPath($destination);
+        rename($source,$destination);
+
+    }
+
+}
+