Initial commit of the Faster IT roundcube_calendar plugin distribution

This includes:
 * Kolab plugins 3.2.9 (calendar and libcalendaring)
 * CalDAV driver 3.2.8
 * .htaccess files for at least some security
 * SabreDAV updated to 1.8.12 (Jan 2015 release)
 * Support for CURLOPT_SSL_* settings to allow self-signed certificates
 * Small fixes & improved documentation

7 files changed, 1345 insertions, 0 deletions

diff --git a/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/AbstractBackend.php b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/AbstractBackend.php
new file mode 100644
index 0000000..c89d37c
--- /dev/null
+++ b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/AbstractBackend.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace OldSabre\DAV\Locks\Backend;
+
+use OldSabre\DAV\Locks;
+
+/**
+ * This is an Abstract clas for lock backends.
+ *
+ * Currently this backend has no function, but it exists for consistency, and
+ * to ensure that if default code is required in the backend, there will be a
+ * non-bc-breaking way to do so.
+ *
+ * @copyright Copyright (C) 2007-2015 fruux GmbH (https://fruux.com/).
+ * @author Evert Pot (http://evertpot.com/)
+ * @license http://sabre.io/license/ Modified BSD License
+ */
+abstract class AbstractBackend implements BackendInterface {
+
+}
+
diff --git a/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/BackendInterface.php b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/BackendInterface.php
new file mode 100644
index 0000000..1a768b0
--- /dev/null
+++ b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/BackendInterface.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace OldSabre\DAV\Locks\Backend;
+
+use OldSabre\DAV\Locks;
+
+/**
+ * If you are defining your own Locks backend, you must implement this
+ * interface.
+ *
+ * @copyright Copyright (C) 2007-2015 fruux GmbH (https://fruux.com/).
+ * @author Evert Pot (http://evertpot.com/)
+ * @license http://sabre.io/license/ Modified BSD License
+ */
+interface BackendInterface {
+
+    /**
+     * Returns a list of OldSabre\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.
+     *
+     * If returnChildLocks is set to true, this method should also look for
+     * any locks in the subtree of the uri for locks.
+     *
+     * @param string $uri
+     * @param bool $returnChildLocks
+     * @return array
+     */
+    public function getLocks($uri, $returnChildLocks);
+
+    /**
+     * Locks a uri
+     *
+     * @param string $uri
+     * @param Locks\LockInfo $lockInfo
+     * @return bool
+     */
+    public function lock($uri,Locks\LockInfo $lockInfo);
+
+    /**
+     * Removes a lock from a uri
+     *
+     * @param string $uri
+     * @param Locks\LockInfo $lockInfo
+     * @return bool
+     */
+    public function unlock($uri,Locks\LockInfo $lockInfo);
+
+}
+
diff --git a/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/FS.php b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/FS.php
new file mode 100644
index 0000000..3a61f40
--- /dev/null
+++ b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/FS.php
@@ -0,0 +1,193 @@
+<?php
+
+namespace OldSabre\DAV\Locks\Backend;
+
+use OldSabre\DAV\Locks\LockInfo;
+
+/**
+ * This Lock Backend stores all its data in the filesystem in separate file per
+ * node.
+ *
+ * This Lock Manager is now deprecated. It has a bug that allows parent
+ * collections to be deletes when children deeper in the tree are locked.
+ *
+ * This also means that using this backend means you will not pass the Neon
+ * Litmus test.
+ *
+ * You are recommended to use either the PDO or the File backend instead.
+ *
+ * @deprecated
+ * @copyright Copyright (C) 2007-2015 fruux GmbH (https://fruux.com/).
+ * @author Evert Pot (http://evertpot.com/)
+ * @license http://sabre.io/license/ Modified BSD License
+ */
+class FS extends AbstractBackend {
+
+    /**
+     * 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 OldSabre\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.
+     *
+     * If returnChildLocks is set to true, this method should also look for
+     * any locks in the subtree of the uri for locks.
+     *
+     * @param string $uri
+     * @param bool $returnChildLocks
+     * @return array
+     */
+    public function getLocks($uri, $returnChildLocks) {
+
+        $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 ignore 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 LockInfo $lockInfo
+     * @return bool
+     */
+    public function lock($uri, LockInfo $lockInfo) {
+
+        // We're making the lock timeout 30 minutes
+        $lockInfo->timeout = 1800;
+        $lockInfo->created = time();
+
+        $locks = $this->getLocks($uri,false);
+        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 LockInfo $lockInfo
+     * @return bool
+     */
+    public function unlock($uri, LockInfo $lockInfo) {
+
+        $locks = $this->getLocks($uri,false);
+        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);
+
+    }
+
+}
+
diff --git a/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/File.php b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/File.php
new file mode 100644
index 0000000..b4eb58b
--- /dev/null
+++ b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/File.php
@@ -0,0 +1,183 @@
+<?php
+
+namespace OldSabre\DAV\Locks\Backend;
+
+use OldSabre\DAV\Locks\LockInfo;
+
+/**
+ * The Lock manager allows you to handle all file-locks centrally.
+ *
+ * This Lock Manager stores all its data in a single file.
+ *
+ * Note that this is not nearly as robust as a database, you are encouraged
+ * to use the PDO backend instead.
+ *
+ * @copyright Copyright (C) 2007-2015 fruux GmbH (https://fruux.com/).
+ * @author Evert Pot (http://evertpot.com/)
+ * @license http://sabre.io/license/ Modified BSD License
+ */
+class File extends AbstractBackend {
+
+    /**
+     * The storage file
+     *
+     * @var string
+     */
+    private $locksFile;
+
+    /**
+     * Constructor
+     *
+     * @param string $locksFile path to file
+     */
+    public function __construct($locksFile) {
+
+        $this->locksFile = $locksFile;
+
+    }
+
+    /**
+     * Returns a list of OldSabre\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.
+     *
+     * If returnChildLocks is set to true, this method should also look for
+     * any locks in the subtree of the uri for locks.
+     *
+     * @param string $uri
+     * @param bool $returnChildLocks
+     * @return array
+     */
+    public function getLocks($uri, $returnChildLocks) {
+
+        $newLocks = array();
+
+        $locks = $this->getData();
+
+        foreach($locks as $lock) {
+
+            if ($lock->uri === $uri ||
+                //deep locks on parents
+                ($lock->depth!=0 && strpos($uri, $lock->uri . '/')===0) ||
+
+                // locks on children
+                ($returnChildLocks && (strpos($lock->uri, $uri . '/')===0)) ) {
+
+                $newLocks[] = $lock;
+
+            }
+
+        }
+
+        // Checking if we can remove any of these locks
+        foreach($newLocks as $k=>$lock) {
+            if (time() > $lock->timeout + $lock->created) unset($newLocks[$k]);
+        }
+        return $newLocks;
+
+    }
+
+    /**
+     * Locks a uri
+     *
+     * @param string $uri
+     * @param LockInfo $lockInfo
+     * @return bool
+     */
+    public function lock($uri, LockInfo $lockInfo) {
+
+        // We're making the lock timeout 30 minutes
+        $lockInfo->timeout = 1800;
+        $lockInfo->created = time();
+        $lockInfo->uri = $uri;
+
+        $locks = $this->getData();
+
+        foreach($locks as $k=>$lock) {
+            if (
+                ($lock->token == $lockInfo->token) ||
+                (time() > $lock->timeout + $lock->created)
+            ) {
+                unset($locks[$k]);
+            }
+        }
+        $locks[] = $lockInfo;
+        $this->putData($locks);
+        return true;
+
+    }
+
+    /**
+     * Removes a lock from a uri
+     *
+     * @param string $uri
+     * @param LockInfo $lockInfo
+     * @return bool
+     */
+    public function unlock($uri, LockInfo $lockInfo) {
+
+        $locks = $this->getData();
+        foreach($locks as $k=>$lock) {
+
+            if ($lock->token == $lockInfo->token) {
+
+                unset($locks[$k]);
+                $this->putData($locks);
+                return true;
+
+            }
+        }
+        return false;
+
+    }
+
+    /**
+     * Loads the lockdata from the filesystem.
+     *
+     * @return array
+     */
+    protected function getData() {
+
+        if (!file_exists($this->locksFile)) return array();
+
+        // opening up the file, and creating a shared lock
+        $handle = fopen($this->locksFile,'r');
+        flock($handle,LOCK_SH);
+
+        // Reading data until the eof
+        $data = stream_get_contents($handle);
+
+        // 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;
+
+    }
+
+    /**
+     * Saves the lockdata
+     *
+     * @param array $newData
+     * @return void
+     */
+    protected function putData(array $newData) {
+
+        // opening up the file, and creating an exclusive lock
+        $handle = fopen($this->locksFile,'a+');
+        flock($handle,LOCK_EX);
+
+        // We can only truncate and rewind once the lock is acquired.
+        ftruncate($handle,0);
+        rewind($handle);
+
+        fwrite($handle,serialize($newData));
+        fclose($handle);
+
+    }
+
+}
+
diff --git a/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/PDO.php b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/PDO.php
new file mode 100644
index 0000000..520a84b
--- /dev/null
+++ b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Backend/PDO.php
@@ -0,0 +1,167 @@
+<?php
+
+namespace OldSabre\DAV\Locks\Backend;
+
+use OldSabre\DAV\Locks\LockInfo;
+
+/**
+ * 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.
+ *
+ * @copyright Copyright (C) 2007-2015 fruux GmbH (https://fruux.com/).
+ * @author Evert Pot (http://evertpot.com/)
+ * @license http://sabre.io/license/ Modified BSD License
+ */
+class PDO extends AbstractBackend {
+
+    /**
+     * The PDO connection object
+     *
+     * @var pdo
+     */
+    private $pdo;
+
+    /**
+     * The PDO tablename this backend uses.
+     *
+     * @var string
+     */
+    protected $tableName;
+
+    /**
+     * Constructor
+     *
+     * @param PDO $pdo
+     * @param string $tableName
+     */
+    public function __construct(\PDO $pdo, $tableName = 'locks') {
+
+        $this->pdo = $pdo;
+        $this->tableName = $tableName;
+
+    }
+
+    /**
+     * Returns a list of OldSabre\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.
+     *
+     * If returnChildLocks is set to true, this method should also look for
+     * any locks in the subtree of the uri for locks.
+     *
+     * @param string $uri
+     * @param bool $returnChildLocks
+     * @return array
+     */
+    public function getLocks($uri, $returnChildLocks) {
+
+        // NOTE: the following 10 lines or so could be easily replaced by
+        // pure sql. MySQL's non-standard string concatenation prevents us
+        // from doing this though.
+        $query = 'SELECT owner, token, timeout, created, scope, depth, uri FROM '.$this->tableName.' 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;
+
+        }
+
+        if ($returnChildLocks) {
+
+            $query.=' OR (uri LIKE ?)';
+            $params[] = $uri . '/%';
+
+        }
+        $query.=')';
+
+        $stmt = $this->pdo->prepare($query);
+        $stmt->execute($params);
+        $result = $stmt->fetchAll();
+
+        $lockList = array();
+        foreach($result as $row) {
+
+            $lockInfo = new 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 LockInfo $lockInfo
+     * @return bool
+     */
+    public function lock($uri, LockInfo $lockInfo) {
+
+        // We're making the lock timeout 30 minutes
+        $lockInfo->timeout = 30*60;
+        $lockInfo->created = time();
+        $lockInfo->uri = $uri;
+
+        $locks = $this->getLocks($uri,false);
+        $exists = false;
+        foreach($locks as $lock) {
+            if ($lock->token == $lockInfo->token) $exists = true;
+        }
+
+        if ($exists) {
+            $stmt = $this->pdo->prepare('UPDATE '.$this->tableName.' 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 '.$this->tableName.' (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 LockInfo $lockInfo
+     * @return bool
+     */
+    public function unlock($uri, LockInfo $lockInfo) {
+
+        $stmt = $this->pdo->prepare('DELETE FROM '.$this->tableName.' WHERE uri = ? AND token = ?');
+        $stmt->execute(array($uri,$lockInfo->token));
+
+        return $stmt->rowCount()===1;
+
+    }
+
+}
+
diff --git a/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/LockInfo.php b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/LockInfo.php
new file mode 100644
index 0000000..77bba97
--- /dev/null
+++ b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/LockInfo.php
@@ -0,0 +1,81 @@
+<?php
+
+namespace OldSabre\DAV\Locks;
+
+/**
+ * LockInfo class
+ *
+ * An object of the LockInfo class holds all the information relevant to a
+ * single lock.
+ *
+ * @copyright Copyright (C) 2007-2015 fruux GmbH (https://fruux.com/).
+ * @author Evert Pot (http://evertpot.com/)
+ * @license http://sabre.io/license/ Modified BSD License
+ */
+class 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 OldSabre\DAV\Server::DEPTH_INFINITY
+     */
+    public $depth = 0;
+
+    /**
+     * The uri this lock locks
+     *
+     * TODO: This value is not always set
+     * @var mixed
+     */
+    public $uri;
+
+}
+
diff --git a/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Plugin.php b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Plugin.php
new file mode 100644
index 0000000..df78b92
--- /dev/null
+++ b/calendar/lib/SabreDAV/lib/OldSabre/DAV/Locks/Plugin.php
@@ -0,0 +1,649 @@
+<?php
+
+namespace OldSabre\DAV\Locks;
+
+use OldSabre\DAV;
+
+/**
+ * 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 OldSabre\DAV\Locks\Backend\File('./mylockdb');
+ * $lockPlugin = new OldSabre\DAV\Locks\Plugin($lockBackend);
+ * $server->addPlugin($lockPlugin);
+ *
+ * @copyright Copyright (C) 2007-2015 fruux GmbH (https://fruux.com/).
+ * @author Evert Pot (http://evertpot.com/)
+ * @license http://sabre.io/license/ Modified BSD License
+ */
+class Plugin extends DAV\ServerPlugin {
+
+    /**
+     * locksBackend
+     *
+     * @var Backend\Backend\Interface
+     */
+    protected $locksBackend;
+
+    /**
+     * server
+     *
+     * @var OldSabre\DAV\Server
+     */
+    protected $server;
+
+    /**
+     * __construct
+     *
+     * @param Backend\BackendInterface $locksBackend
+     */
+    public function __construct(Backend\BackendInterface $locksBackend = null) {
+
+        $this->locksBackend = $locksBackend;
+
+    }
+
+    /**
+     * Initializes the plugin
+     *
+     * This method is automatically called by the Server class after addPlugin.
+     *
+     * @param DAV\Server $server
+     * @return void
+     */
+    public function initialize(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'));
+
+    }
+
+    /**
+     * Returns a plugin name.
+     *
+     * Using this name other plugins will be able to access other plugins
+     * using OldSabre\DAV\Server::getPlugin
+     *
+     * @return string
+     */
+    public function getPluginName() {
+
+        return 'locks';
+
+    }
+
+    /**
+     * 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
+     * @param string $uri
+     * @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 $newProperties
+     * @return bool
+     */
+    public function afterGetProperties($path, &$newProperties) {
+
+        foreach($newProperties[404] as $propName=>$discard) {
+
+            switch($propName) {
+
+                case '{DAV:}supportedlock' :
+                    $val = false;
+                    if ($this->locksBackend) $val = true;
+                    $newProperties[200][$propName] = new DAV\Property\SupportedLock($val);
+                    unset($newProperties[404][$propName]);
+                    break;
+
+                case '{DAV:}lockdiscovery' :
+                    $newProperties[200][$propName] = new 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' :
+                $lastLock = null;
+                if (!$this->validateLock($uri,$lastLock, true))
+                    throw new DAV\Exception\Locked($lastLock);
+                break;
+            case 'MKCOL' :
+            case 'PROPPATCH' :
+            case 'PUT' :
+            case 'PATCH' :
+                $lastLock = null;
+                if (!$this->validateLock($uri,$lastLock))
+                    throw new DAV\Exception\Locked($lastLock);
+                break;
+            case 'MOVE' :
+                $lastLock = null;
+                if (!$this->validateLock(array(
+                      $uri,
+                      $this->server->calculateUri($this->server->httpRequest->getHeader('Destination')),
+                    ),$lastLock, true))
+                        throw new DAV\Exception\Locked($lastLock);
+                break;
+            case 'COPY' :
+                $lastLock = null;
+                if (!$this->validateLock(
+                      $this->server->calculateUri($this->server->httpRequest->getHeader('Destination')),
+                      $lastLock, true))
+                        throw new 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)
+            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 OldSabre\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
+     * If the $returnChildLocks argument is set to true, we'll also traverse all the children of the object
+     * for any possible locks and return those as well.
+     *
+     * @param string $uri
+     * @param bool $returnChildLocks
+     * @return array
+     */
+    public function getLocks($uri, $returnChildLocks = false) {
+
+        $lockList = array();
+
+        if ($this->locksBackend)
+            $lockList = array_merge($lockList,$this->locksBackend->getLocks($uri, $returnChildLocks));
+
+        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-existent 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 == LockInfo::EXCLUSIVE) {
+                //var_dump($lastLock);
+                throw new 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 != LockInfo::SHARED) throw new 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 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 {
+            $this->server->tree->getNodeForPath($uri);
+
+            // We need to call the beforeWriteContent event for RFC3744
+            // Edit: looks like this is not used, and causing problems now.
+            //
+            // See Issue 222
+            // $this->server->broadcastEvent('beforeWriteContent',array($uri));
+
+        } catch (DAV\Exception\NotFound $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 DAV\Exception\BadRequest('No lock token was supplied');
+
+        $locks = $this->getLocks($uri);
+
+        // Windows sometimes forgets to include < and > in the Lock-Token
+        // header
+        if ($lockToken[0]!=='<') $lockToken = '<' . $lockToken . '>';
+
+        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 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 LockInfo $lockInfo
+     * @return bool
+     */
+    public function lockNode($uri,LockInfo $lockInfo) {
+
+        if (!$this->server->broadcastEvent('beforeLock',array($uri,$lockInfo))) return;
+
+        if ($this->locksBackend) return $this->locksBackend->lock($uri,$lockInfo);
+        throw new 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 LockInfo $lockInfo
+     * @return bool
+     */
+    public function unlockNode($uri, LockInfo $lockInfo) {
+
+        if (!$this->server->broadcastEvent('beforeUnlock',array($uri,$lockInfo))) return;
+        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 = LockInfo::TIMEOUT_INFINITE;
+            else throw new DAV\Exception\BadRequest('Invalid HTTP timeout header');
+
+        } else {
+
+            $header = 0;
+
+        }
+
+        return $header;
+
+    }
+
+    /**
+     * Generates the response for successful LOCK requests
+     *
+     * @param LockInfo $lockInfo
+     * @return string
+     */
+    protected function generateLockResponse(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 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 (OldSabre\DAV\Locks\LockInfo)
+     * @param bool $checkChildLocks If set to true, this function will also look for any locks set on child resources of the supplied urls. This is needed for for example deletion of entire trees.
+     * @return bool
+     */
+    protected function validateLock($urls = null,&$lastLock = null, $checkChildLocks = false) {
+
+        if (is_null($urls)) {
+            $urls = array($this->server->getRequestUri());
+        } elseif (is_string($urls)) {
+            $urls = array($urls);
+        } elseif (!is_array($urls)) {
+            throw new 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, $checkChildLocks);
+
+            // 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) {
+
+                if (!$condition['uri']) {
+                    $conditionUri = $this->server->getRequestUri();
+                } else {
+                    $conditionUri = $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 instanceof DAV\IFile && $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 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, containing structs with the following keys
+     *
+     *   * uri   - the uri the condition applies to. If this is returned as an
+     *     empty string, this implies it's referring to the request url.
+     *   * tokens - The lock token. another 2 dimensional array containing 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 array
+     */
+    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 OldSabre\DAV\Locks\LockInfo object
+     *
+     * @param string $body
+     * @return DAV\Locks\LockInfo
+     */
+    protected function parseLockRequest($body) {
+
+        // Fixes an XXE vulnerability on PHP versions older than 5.3.23 or
+        // 5.4.13.
+        $previous = libxml_disable_entity_loader(true);
+
+
+        $xml = simplexml_load_string(
+            DAV\XMLUtil::convertDAVNamespace($body),
+            null,
+            LIBXML_NOWARNING);
+        libxml_disable_entity_loader($previous);
+
+        $xml->registerXPathNamespace('d','urn:DAV');
+        $lockInfo = new LockInfo();
+
+        $children = $xml->children("urn:DAV");
+        $lockInfo->owner = (string)$children->owner;
+
+        $lockInfo->token = DAV\UUIDUtil::getUUID();
+        $lockInfo->scope = count($xml->xpath('d:lockscope/d:exclusive'))>0 ? LockInfo::EXCLUSIVE : LockInfo::SHARED;
+
+        return $lockInfo;
+
+    }
+
+
+}