public/gallery3-contrib
Archived
1
0
Fork 0
Code Releases Activity

Merge remote branch 'upstream/master'

Browse Source
This commit is contained in:
Romain LE DISEZ 2010-12-18 14:40:07 +01:00
commit b65fe2f488
122 changed files with 13316 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
3.0/modules/albumtree/helpers/albumtree_block.php
View File

@ -26,9 +26,10 @@ class albumtree_block_Core {
$block = new Block();
switch ($block_id) {
case "albumtree":
$style = module::get_var("albumtree", "style", "select");
$block->css_id = "g-albumtree";
$block->title = t("Album Tree");
$block->content = new View("albumtree_block.html");
$block->content = new View("albumtree_block_{$style}.html");
$block->content->root = item::root();
break;
}

33
3.0/modules/albumtree/helpers/albumtree_installer.php Normal file
View File

@ -0,0 +1,33 @@
<?php defined("SYSPATH") or die("No direct script access.");
/**
* Gallery - a web based photo album viewer and editor
* Copyright (C) 2000-2010 Bharat Mediratta
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
class albumtree_installer {
static function install() {
module::set_var("albumtree", "style", "select");
module::set_version("albumtree", 2);
}
static function upgrade($version) {
$db = Database::instance();
if ($version == 1) {
module::set_var("albumtree", "style", "select");
module::set_version("albumtree", $version = 2);
}
}
}

2
3.0/modules/albumtree/module.info
View File

@ -1,3 +1,3 @@
name = "Album Tree"
description = "Provides a block in the sidebar with quick links to all other albums."
version = 1
version = 2

38
3.0/modules/albumtree/views/albumtree_block_list.html.php Normal file
View File

@ -0,0 +1,38 @@
<?php defined("SYSPATH") or die("No direct script access.") ?>
<style type="text/css">
ul.treealbumnav {
height: 225px;
width: 190px;
overflow: auto;
border: 1px solid #666;
padding: 2px;
}
</style>
<ul class="treealbumnav">
<? // We'll keep track of the list of items that we want to display in a stack ?>
<? $stack = array(array(0, $root)) ?>
<? // While there are still items to show, pick the next one and show it ?>
<? while ($stack): ?>
<? list($level, $album) = array_pop($stack) ?>
<li>
<a href="/index.php/items/<?= $album->id ?>"><?= str_repeat("&nbsp;&nbsp;", $level) ?><?= $album->title ?>
</li>
<? // Then take all of that album's children and put them next on the stack. ?>
<? $tmp = array(); ?>
<? foreach ($album->viewable()->children(null, null, array(array("type", "=", "album"))) as $child): ?>
<? $tmp[] = array($level + 1, $child) ?>
<? endforeach ?>
<? // Since we'll pull them off the stack in the opposite order that we put them on, ?>
<? // and the order that we put them on is the order in which we want to display them, ?>
<? // We need to reverse the order of the children on the stack ?>
<? if ($tmp): ?>
<? $stack = array_merge($stack, array_reverse($tmp)) ?>
<? endif ?>
<? endwhile ?>
</ul>
</div>

2
3.0/modules/albumtree/views/albumtree_block.html.php → 3.0/modules/albumtree/views/albumtree_block_select.html.php
View File

@ -10,7 +10,7 @@
<? // Then take all of that album's children and put them next on the stack. ?>
<? $tmp = array(); ?>
<? foreach ($album->children(null, null, array(array("type", "=", "album"))) as $child): ?>
<? foreach ($album->viewable()->children(null, null, array(array("type", "=", "album"))) as $child): ?>
<? $tmp[] = array($level + 1, $child) ?>
<? endforeach ?>

2
3.0/modules/aws_s3/helpers/aws_s3.php
View File

@ -53,7 +53,7 @@ class aws_s3_Core {
"&Signature=" . urlencode(self::getHash("GET\n\n\n" . (time() + module::get_var("aws_s3", "sig_exp")) . "\n/" . $host . "/" . $resource));
self::get_s3();
S3::getAuthenticatedURL("danneh-org", $resource, module::get_var("aws_s3", "sig_exp"));
S3::getAuthenticatedURL(module::get_var("aws_s3", "bucket_name"), $resource, module::get_var("aws_s3", "sig_exp"));
}
else
$url .= "?m=" . ($updated ? $updated : time());

12
3.0/modules/ldap/config/identity.php
View File

@ -34,13 +34,13 @@ $config["ldap"] = array(
"driver" => "ldap",
"allow_updates" => false,
"params" => array(
"groups" => array("eng", "google", "guest"),
"groups" => array("engineering", "everybody", "guest"),
"everybody_group" => "guest",
"registered_users_group" => "google",
"admins" => array("mediratta", "martinm"),
"url" => "ldaps://ldap.corp.google.com/",
"group_domain" => "ou=Posix,ou=Groups,dc=google,dc=com",
"user_domain" => "ou=People,dc=google,dc=com",
"registered_users_group" => "everybody",
"admins" => array("alice", "bob"),
"url" => "ldaps://ldap.mycompany.com/",
"group_domain" => "ou=Posix,ou=Groups,dc=ymcompany,dc=com",
"user_domain" => "ou=People,dc=MyCompany,dc=com",
"bind_rdn" => null,
"bind_password" => null,
)

4
3.0/modules/ldap/libraries/drivers/IdentityProvider/Ldap.php
View File

@ -212,14 +212,14 @@ class IdentityProvider_Ldap_Driver implements IdentityProvider_Driver {
/**
* @see IdentityProvider_Driver::add_user_to_group.
*/
static function add_user_to_group($user, $group) {
public function add_user_to_group($user, $group) {
throw new Exception("@todo INVALID OPERATION");
}
/**
* @see IdentityProvider_Driver::remove_user_to_group.
*/
static function remove_user_from_group($user, $group) {
public function remove_user_from_group($user, $group) {
throw new Exception("@todo INVALID OPERATION");
}
} // End Identity Gallery Driver

22
3.0/modules/unrest/helpers/unrest.php Normal file
View File

@ -0,0 +1,22 @@
<?php defined("SYSPATH") or die("No direct script access.");
/**
* Gallery - a web based photo album viewer and editor
* Copyright (C) 2000-2010 Bharat Mediratta
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
class unrest_Core {
}

8
3.0/modules/unrest/helpers/unrest_event.php Normal file
View File

@ -0,0 +1,8 @@
<?php defined("SYSPATH") or die("No direct script access.");
class unrest_event_Core {
}
?>

308
3.0/modules/unrest/helpers/unrest_rest.php Normal file
View File

@ -0,0 +1,308 @@
<?php defined("SYSPATH") or die("No direct script access.");
class unrest_rest_Core {
private static function resolveLimitOption($string)
{
$items = split(',', $string);
if (count($items) == 1) { return $string; }
return $items;
}
private static function getFreetextLimiters($request, $limit = array())
{
$likeMapping = array(
'name' => 'name',
'description' => 'description'
);
foreach ($likeMapping as $key => $col)
{
if (isset($request->params->$key)) { $limit[$col] = array('op' => 'LIKE', 'value' => '%' . $request->params->$key . '%'); }
}
return $limit;
}
private static function getBasicLimiters($request, $limit = array())
{
$directMapping = array(
'type' => 'type',
'id' => 'items.id',
'parent' => 'parent_id',
'mime' => 'mime_type');
foreach ($directMapping as $key => $col)
{
if (isset($request->params->$key)) { $limit[$col] = array('op' => '=', 'value' => unrest_rest::resolveLimitOption($request->params->$key)); }
}
return $limit;
}
private static function albumsICanAccess()
{
$db = db::build();
$gids = identity::group_ids_for_active_user();
$q = $db->select('id')->from('items');
foreach ($gids as $gid) { $q->or_where('view_' . $gid, '=', 1); }
$q->where('type', '=', 'album');
$permitted = array();
foreach($q->execute() as $row) { $permitted[] = $row->id; }
return $permitted;
}
static function queryLimitByPermission(&$query, $permitted)
{
$query->and_open()->and_open()->where('type', '=', 'album')->and_where('items.id', 'IN', $permitted)->close();
$query->or_open()->where('type', '!=', 'album')->and_where('parent_id', 'IN', $permitted)->close()->close();
}
static function baseItemQuery($db)
{
$fields = array(
'items.id', 'title', 'album_cover_item_id', 'description', 'height', 'width', 'left_ptr', 'right_ptr',
'level', 'mime_type', 'name', 'owner_id', 'parent_id', 'relative_path_cache', 'relative_url_cache',
'resize_dirty', 'slug', 'sort_column', 'sort_order', 'thumb_dirty','thumb_height', 'view_1', 'type',
'resize_height', 'resize_width', 'thumb_height', 'thumb_width', 'slug', 'name', 'relative_path_cache'
);
$permfields = array('view_', 'view_full_', 'edit_', 'add_');
foreach (identity::group_ids_for_active_user() as $album)
{
foreach ($permfields as $field)
{
$fields[] = $field . $album;
}
}
return($db->select($fields)->from('items')->join('access_caches', 'access_caches.item_id', 'items.id'));
/*
return($db->select(array(
'id', 'title', 'album_cover_item_id', 'description', 'height', 'width', 'left_ptr', 'right_ptr',
'level', 'mime_type', 'name', 'owner_id', 'parent_id', 'relative_path_cache', 'relative_url_cache',
'resize_dirty', 'slug', 'sort_column', 'sort_order', 'thumb_dirty','thumb_height', 'view_1', 'type',
'resize_height', 'resize_width', 'thumb_height', 'thumb_width', 'slug', 'name', 'relative_path_cache'
))->from('items'));
*/
}
static function queryLimitByLimiter(&$query, $limit)
{
foreach ($limit as $key => $block)
{
if (gettype($block['value']) == 'array') { $query->and_where($key, 'IN', $block['value']); }
else { $query->and_where($key, $block['op'], $block['value']); }
}
}
static function getDisplayOptions($request)
{
if (isset($request->params->display)) {
return(split(',', $request->params->display));
} else {
return(array('uiimage','uitext','ownership','members'));
};
}
static function queryOrder(&$query, $request)
{
if (isset($request->params->order)) {
$order = $request->params->order;
$direction = 'asc';
if (isset($request->params->direction))
{
if ($request->params->direction == 'desc') { $direction = 'desc'; }
}
switch ($order)
{
case 'tree':
$query->order_by(array('level' => 'ASC', 'left_ptr' => 'ASC'));
break;
case 'created':
$query->order_by(array('created' => $direction));
break;
case 'updated':
$query->order_by(array('updated' => $direction));
break;
case 'views':
$query->order_by(array('view_count' => $direction));
break;
case 'type':
$query->order_by(array('type' => $direction));
break;
}
}
}
static function addChildren($request, $db, $filler, $permitted, $display, &$return, $rest_base)
{
$children = $db->select('parent_id', 'id')->from('items')->where('parent_id', 'IN', $filler['children_of']);
if (isset($request->params->childtypes))
{
$types = split(',', $request->params->childtypes);
$children->where('type', 'IN', $types);
}
/* We shouldn't have any albums we don't have access to by default in this query, but just in case.. */
unrest_rest::queryLimitByPermission(&$children, $permitted);
$childBlock = array();
foreach($children->execute() as $item)
{
$childBlock[$item->parent_id][] = intval($item->id);
}
foreach ($return as &$data)
{
if (array_key_exists($data['entity']['id'], $childBlock))
{
if (in_array('terse', $display)) {
$data['members'] = $childBlock[ $data['id'] ];
}
else {
$members = array();
foreach ($childBlock[ $data['entity']['id'] ] as $child) {
$members[] = unrest_rest::makeRestURL('item', $child, $rest_base);
}
$data['members'] = $members;
}
}
else
{
$data['members'] = array();
}
}
}
private static function makeRestURL($resource, $identifier, $base)
{
return $base . '/' . $resource . '/' . $identifier;
}
public static function size_url($size, $relative_path_cache, $type, $file_base) {
$base = $file_base . 'var/' . $size . '/' . $relative_path_cache;
if ($type == 'photo') {
return $base;
} else if ($type == 'album') {
return $base . "/.album.jpg";
} else if ($type == 'movie') {
// Replace the extension with jpg
return preg_replace("/...$/", "jpg", $base);
}
}
static function get($request) {
$db = db::build();
$start = microtime(true);
$rest_base = url::abs_site("rest");
$file_base = url::abs_file(''); #'var/' . $size . '/'
/* Build basic limiters */
$limit = unrest_rest::getBasicLimiters($request);
$limit = unrest_rest::getFreetextLimiters($request,$limit);
/* Build numeric limiters */
/* ...at some point. */
/* Figure out an array of albums we got permissions to access */
$permitted = unrest_rest::albumsICanAccess();
$display = unrest_rest::getDisplayOptions($request);
$items = unrest_rest::baseItemQuery($db);
/*
Introduce some WHERE statements that'll make sure that we don't get to see stuff we
shouldn't be seeing.
*/
unrest_rest::queryLimitByPermission(&$items, $permitted);
unrest_rest::queryLimitByLimiter(&$items, $limit);
unrest_rest::queryOrder(&$items, $request);
$return = array();
$filler = array();
$relationshipCandidates = array();
foreach($items->execute() as $item)
{
$data = array(
'id' => intval($item->id),
'parent' => intval($item->parent_id),
'owner_id' => intval($item->{'owner_id'}),
'public' => ($item->view_1)?true:false,
'type' => $item->type // Grmbl
);
if (in_array('uitext', $display)) {
$ui = array(
'title' => $item->title,
'description' => $item->description,
'name' => $item->name,
'slug' => $item->slug
);
$data = array_merge($data, $ui);
}
if (in_array('uiimage', $display)) {
$ui = array(
'height' => $item->height,
'width' => $item->width,
'resize_height' => $item->resize_height,
'resize_width' => $item->resize_width,
'thumb_height' => $item->resize_height,
'thumb_width' => $item->resize_width
);
$ui['thumb_url_public'] = unrest_rest::size_url('thumbs', $item->relative_path_cache, $item->type, $file_base);
$public = $item->view_1?true:false;
$fullPublic = $item->view_full_1?true:false;
if ($item->type != 'album')
{
$ui['file_url'] = unrest_rest::makeRestURL('data', $item->id . '?size=full', $rest_base);
$ui['thumb_url'] = unrest_rest::makeRestURL('data', $item->id . '?size=thumb', $rest_base);
$ui['resize_url'] = unrest_rest::makeRestURL('data', $item->id . '?size=resize', $rest_base);
if ($public) {
$ui['resize_url_public'] = unrest_rest::size_url('resizes', $item->relative_path_cache, $item->type, $file_base);
if ($fullPublic) {
$ui['file_url_public'] = unrest_rest::size_url('albums', $item->relative_path_cache, $item->type, $file_base);
}
}
}
$data = array_merge($data, $ui);
}
if (in_array('members', $display)) {
$filler['children_of'][] = $item->id;
}
$return[] = array(
'url' => unrest_rest::makeRestURL('item', $item->id, $rest_base ),
'entity' => $data
);
}
/* Do we need to fetch children? */
if (array_key_exists('children_of', $filler))
{
unrest_rest::addChildren($request, $db, $filler, $permitted, $display, &$return, $rest_base);
}
$end = microtime(true);
error_log("Inner " . ($end - $start) . " seconds taken");
return $return;
}
}
?>

3
3.0/modules/unrest/module.info Normal file
View File

@ -0,0 +1,3 @@
name = "Un-Rest API module"
description = "Shorter invocations for the Rest API"
version = 1

63
3.0/modules/webdav/controllers/webdav.php Normal file
View File

@ -0,0 +1,63 @@
<?php defined("SYSPATH") or die("No direct script access.");
/**
* Gallery - a web based photo album viewer and editor
* Copyright (C) 2000-2010 Bharat Mediratta
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
require_once(MODPATH . "webdav/vendor/Sabre/autoload.php");
class WebDAV_Controller extends Controller {
public function gallery() {
$root = new Gallery3_DAV_Album("");
$tree = new Gallery3_DAV_Tree($root);
// Skip the lock plugin for now, we don't want Finder to get write support for the time being.
// $lock_backend = new Sabre_DAV_Locks_Backend_FS(TMPPATH . "sabredav");
// $lock = new Sabre_DAV_Locks_Plugin($lock_backend);
$filter = new Sabre_DAV_TemporaryFileFilterPlugin(TMPPATH . "sabredav");
$server = new Sabre_DAV_Server($tree);
$server->setBaseUri(url::site("webdav/gallery"));
// $server->addPlugin($lock);
$server->addPlugin($filter);
if ($this->_authenticate()) {
$server->exec();
}
}
private function _authenticate() {
$auth = new Sabre_HTTP_BasicAuth();
$auth->setRealm(item::root()->title);
$authResult = $auth->getUserPass();
list($username, $password) = $authResult;
if (!$username || !$password) {
$auth->requireLogin();
return false;
}
$user = identity::lookup_user_by_name($username);
if (empty($user) || !identity::is_correct_password($user, $password)) {
$auth->requireLogin();
return false;
}
identity::set_active_user($user);
return true;
}
}

128
3.0/modules/webdav/libraries/Gallery3_DAV_Album.php Normal file
View File

@ -0,0 +1,128 @@
<?php defined("SYSPATH") or die("No direct script access.");
/**
* Gallery - a web based photo album viewer and editor
* Copyright (C) 2000-2010 Bharat Mediratta
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
class Gallery3_DAV_Album extends Sabre_DAV_Directory {
private $item;
private $stat;
private $path;
function __construct($path) {
$this->cache = Gallery3_DAV_Cache::instance();
$this->path = $path;
$this->item = $this->cache->to_item($path);
}
function getName() {
return $this->item->name;
}
function getChildren() {
$return = array();
foreach ($this->item->viewable()->children() as $child) {
$return[] = $this->getChild($child->name);
}
return $return;
}
function getChild($name) {
$rp = "{$this->path}/$name";
$child = $this->cache->to_item($rp);
if (!access::can("view", $child)) {
throw new Sabre_DAV_Exception_FileNotFound("Access denied");
}
if ($child->is_album()) {
return new Gallery3_DAV_Album($rp);
} else {
return new Gallery3_DAV_File($rp);
}
}
public function createFile($name, $data=null) {
try {
access::required("view", $this->item);
access::required("add", $this->item);
} catch (Kohana_404_Exception $e) {
throw new Sabre_DAV_Exception_Forbidden("Access denied");
}
if (substr($name, 0, 1) == ".") {
return true;
};
try {
$tempfile = tempnam(TMPPATH, "dav");
$target = fopen($tempfile, "wb");
stream_copy_to_stream($data, $target);
fclose($target);
$item = ORM::factory("item");
$item->name = $name;
$item->title = item::convert_filename_to_title($item->name);
$item->description = "";
$item->parent_id = $this->item->id;
$item->set_data_file($tempfile);
$item->type = "photo";
$item->save();
} catch (Exception $e) {
unlink($tempfile);
throw $e;
}
}
public function createDirectory($name) {
try {
access::required("view", $this->item);
access::required("add", $this->item);
} catch (Kohana_404_Exception $e) {
throw new Sabre_DAV_Exception_Forbidden("Access denied");
}
$album = ORM::factory("item");
$album->type = "album";
$album->parent_id = $this->item->id;
$album->name = $name;
$album->title = $name;
$album->description = "";
$album->save();
// Refresh MPTT pointers
$this->item->reload();
}
function getLastModified() {
return $this->item->updated;
}
function setName($name) {
if (!access::can("edit", $this->item)) {
throw new Sabre_DAV_Exception_Forbidden("Access denied");
};
$this->item->name = $name;
$this->item->save();
}
public function delete() {
if (!access::can("edit", $this->item)) {
throw new Sabre_DAV_Exception_Forbidden("Access denied");
};
$this->item->delete();
}
}

66
3.0/modules/webdav/libraries/Gallery3_DAV_Cache.php Normal file
View File

@ -0,0 +1,66 @@
<?php defined("SYSPATH") or die("No direct script access.");
/**
* Gallery - a web based photo album viewer and editor
* Copyright (C) 2000-2010 Bharat Mediratta
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
class Gallery3_DAV_Cache {
private static $cache;
private static $instance;
private function __construct() {
self::$cache = array();
}
public static function instance() {
if (!isset(self::$instance)) {
self::$instance = new Gallery3_DAV_Cache();
}
return self::$instance;
}
private function encode_path($path) {
$path = trim($path, "/");
$encoded_array = array();
foreach (explode("/", $path) as $part) {
$encoded_array[] = rawurlencode($part);
}
return join("/", $encoded_array);
}
public function to_album($path) {
$path = substr($path, 0, strrpos($path, "/"));
return $this->to_item($path);
}
public function to_item($path) {
$path = trim($path, "/");
$path = $this->encode_path($path);
if (!isset(self::$cache[$path])) {
self::$cache[$path] = ORM::factory("item")
->viewable()
->where("relative_path_cache", "=", $path)
->find();
}
return self::$cache[$path];
}
public function __clone() {
}
}

78
3.0/modules/webdav/libraries/Gallery3_DAV_File.php Normal file
View File

@ -0,0 +1,78 @@
<?php defined("SYSPATH") or die("No direct script access.");
/**
* Gallery - a web based photo album viewer and editor
* Copyright (C) 2000-2010 Bharat Mediratta
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
class Gallery3_DAV_File extends Sabre_DAV_File {
private $item;
private $stat;
private $path;
function __construct($path) {
$this->cache = Gallery3_DAV_Cache::instance();
$this->item = $this->cache->to_item($path);
if (access::can("view_full", $this->item)) {
$this->stat = stat($this->item->file_path());
$this->path = $this->item->file_path();
} else {
$this->stat = stat($this->item->resize_path());
$this->path = $this->item->resize_path();
}
}
public function delete() {
if (!access::can("edit", $this->item)) {
throw new Sabre_DAV_Exception_Forbidden("Access denied");
};
$this->item->delete();
}
function setName($name) {
if (!access::can("edit", $this->item)) {
throw new Sabre_DAV_Exception_Forbidden("Access denied");
};
$this->item->name = $name;
$this->item->save();
}
public function getLastModified() {
return $this->item->updated;
}
function get() {
if (!access::can("view", $this->item)) {
throw new Sabre_DAV_Exception_Forbidden("Access denied");
};
return fopen($this->path, "r");
}
function getSize() {
return $this->stat[7];
}
function getName() {
return $this->item->name;
}
function getETag() {
if (!access::can("view", $this->item)) {
throw new Sabre_DAV_Exception_Forbidden("Access denied");
};
return "'" . md5($this->item->file_path()) . "'";
}
}

60
3.0/modules/webdav/libraries/Gallery3_DAV_Tree.php Normal file
View File

@ -0,0 +1,60 @@
<?php defined("SYSPATH") or die("No direct script access.");
/**
* Gallery - a web based photo album viewer and editor
* Copyright (C) 2000-2010 Bharat Mediratta
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
class Gallery3_DAV_Tree extends Sabre_DAV_Tree {
protected $root_node;
public function __construct(Sabre_DAV_ICollection $root_node) {
$this->cache = Gallery3_DAV_Cache::instance();
$this->root_node = $root_node;
}
public function move($source, $target) {
$source_item = $this->cache->to_item($source);
$target_item = $this->cache->to_album($target);
try {
access::required("view", $source_item);
access::required("edit", $source_item);
access::required("view", $target_item);
access::required("edit", $target_item);
} catch (Kohana_404_Exception $e) {
throw new Sabre_DAV_Exception_Forbidden("Access denied");
}
$source_item->parent_id = $target_item->id;
$source_item->save();
return true;
}
public function getNodeForPath($path) {
$path = trim($path,"/");
$item = $this->cache->to_item($path);
if (!$item->loaded()) {
throw new Sabre_DAV_Exception_FileNotFound("Could not find node at path: $path");
}
if ($item->is_album()) {
return new Gallery3_DAV_Album($path);
} else {
return new Gallery3_DAV_File($path);
}
}
}

3
3.0/modules/webdav/module.info Normal file
View File

@ -0,0 +1,3 @@
name = "WebDAV"
description = "WebDAV interface to Gallery3"
version = 1

16
3.0/modules/webdav/vendor/Sabre.autoload.php vendored Executable file
View File

@ -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';

127
3.0/modules/webdav/vendor/Sabre.includes.php generated vendored Executable file
View File

@ -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';
include 'Sabre/HTTP/Response.php';
include 'Sabre/HTTP/Request.php';
include 'Sabre/HTTP/AbstractAuth.php';
include 'Sabre/HTTP/BasicAuth.php';
include 'Sabre/HTTP/DigestAuth.php';
include 'Sabre/HTTP/AWSAuth.php';
/* Version */
include 'Sabre/DAV/Version.php';
include 'Sabre/HTTP/Version.php';
/* Exceptions */
include 'Sabre/DAV/Exception.php';
include 'Sabre/DAV/Exception/BadRequest.php';
include 'Sabre/DAV/Exception/Conflict.php';
include 'Sabre/DAV/Exception/FileNotFound.php';
include 'Sabre/DAV/Exception/InsufficientStorage.php';
include 'Sabre/DAV/Exception/Locked.php';
include 'Sabre/DAV/Exception/LockTokenMatchesRequestUri.php';
include 'Sabre/DAV/Exception/MethodNotAllowed.php';
include 'Sabre/DAV/Exception/NotImplemented.php';
include 'Sabre/DAV/Exception/Forbidden.php';
include 'Sabre/DAV/Exception/PreconditionFailed.php';
include 'Sabre/DAV/Exception/RequestedRangeNotSatisfiable.php';
include 'Sabre/DAV/Exception/UnsupportedMediaType.php';
include 'Sabre/DAV/Exception/NotAuthenticated.php';
include 'Sabre/DAV/Exception/ConflictingLock.php';
include 'Sabre/DAV/Exception/ReportNotImplemented.php';
include 'Sabre/DAV/Exception/InvalidResourceType.php';
/* Properties */
include 'Sabre/DAV/Property.php';
include 'Sabre/DAV/Property/GetLastModified.php';
include 'Sabre/DAV/Property/ResourceType.php';
include 'Sabre/DAV/Property/SupportedLock.php';
include 'Sabre/DAV/Property/LockDiscovery.php';
include 'Sabre/DAV/Property/IHref.php';
include 'Sabre/DAV/Property/Href.php';
include 'Sabre/DAV/Property/SupportedReportSet.php';
include 'Sabre/DAV/Property/Response.php';
include 'Sabre/DAV/Property/Principal.php';
/* Node interfaces */
include 'Sabre/DAV/INode.php';
include 'Sabre/DAV/IFile.php';
include 'Sabre/DAV/ICollection.php';
include 'Sabre/DAV/IProperties.php';
include 'Sabre/DAV/ILockable.php';
include 'Sabre/DAV/IQuota.php';
include 'Sabre/DAV/IExtendedCollection.php';
/* Node abstract implementations */
include 'Sabre/DAV/Node.php';
include 'Sabre/DAV/File.php';
include 'Sabre/DAV/Directory.php';
/* Utilities */
include 'Sabre/DAV/SimpleDirectory.php';
include 'Sabre/DAV/XMLUtil.php';
include 'Sabre/DAV/URLUtil.php';
/* Filesystem implementation */
include 'Sabre/DAV/FS/Node.php';
include 'Sabre/DAV/FS/File.php';
include 'Sabre/DAV/FS/Directory.php';
/* Advanced filesystem implementation */
include 'Sabre/DAV/FSExt/Node.php';
include 'Sabre/DAV/FSExt/File.php';
include 'Sabre/DAV/FSExt/Directory.php';
/* Trees */
include 'Sabre/DAV/Tree.php';
include 'Sabre/DAV/ObjectTree.php';
include 'Sabre/DAV/Tree/Filesystem.php';
/* Server */
include 'Sabre/DAV/Server.php';
include 'Sabre/DAV/ServerPlugin.php';
/* Browser */
include 'Sabre/DAV/Browser/Plugin.php';
include 'Sabre/DAV/Browser/MapGetToPropFind.php';
include 'Sabre/DAV/Browser/GuessContentType.php';
/* Locks */
include 'Sabre/DAV/Locks/LockInfo.php';
include 'Sabre/DAV/Locks/Plugin.php';
include 'Sabre/DAV/Locks/Backend/Abstract.php';
include 'Sabre/DAV/Locks/Backend/FS.php';
include 'Sabre/DAV/Locks/Backend/PDO.php';
/* Temporary File Filter plugin */
include 'Sabre/DAV/TemporaryFileFilterPlugin.php';
/* Authentication plugin */
include 'Sabre/DAV/Auth/Plugin.php';
include 'Sabre/DAV/Auth/Backend/Abstract.php';
include 'Sabre/DAV/Auth/Backend/AbstractDigest.php';
include 'Sabre/DAV/Auth/Backend/File.php';
include 'Sabre/DAV/Auth/Backend/PDO.php';
include 'Sabre/DAV/Auth/Principal.php';
include 'Sabre/DAV/Auth/PrincipalCollection.php';
/* DavMount plugin */
include 'Sabre/DAV/Mount/Plugin.php';

151
3.0/modules/webdav/vendor/Sabre/CalDAV/Backend/Abstract.php vendored Executable file
View File

@ -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);
}

356
3.0/modules/webdav/vendor/Sabre/CalDAV/Backend/PDO.php vendored Executable file
View File

@ -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));
}
}

254
3.0/modules/webdav/vendor/Sabre/CalDAV/Calendar.php vendored Executable file
View File

@ -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;
}
}

176
3.0/modules/webdav/vendor/Sabre/CalDAV/CalendarObject.php vendored Executable file
View File

@ -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']);
}
}

74
3.0/modules/webdav/vendor/Sabre/CalDAV/CalendarRootNode.php vendored Executable file
View File

@ -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;
}
}

18
3.0/modules/webdav/vendor/Sabre/CalDAV/Exception/InvalidICalendarObject.php vendored Executable file
View File

@ -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 {
}

154
3.0/modules/webdav/vendor/Sabre/CalDAV/ICalendarUtil.php vendored Executable file
View File

@ -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;
}
}

707
3.0/modules/webdav/vendor/Sabre/CalDAV/Plugin.php vendored Executable file
View File

@ -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);
}
}
}

85
3.0/modules/webdav/vendor/Sabre/CalDAV/Property/SupportedCalendarComponentSet.php vendored Executable file
View File

@ -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);
}
}

38
3.0/modules/webdav/vendor/Sabre/CalDAV/Property/SupportedCalendarData.php vendored Executable file
View File

@ -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);
}
}

34
3.0/modules/webdav/vendor/Sabre/CalDAV/Property/SupportedCollationSet.php vendored Executable file
View File

@ -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')
);
}
}

50
3.0/modules/webdav/vendor/Sabre/CalDAV/Server.php vendored Executable file
View File

@ -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);
}
}

193
3.0/modules/webdav/vendor/Sabre/CalDAV/UserCalendars.php vendored Executable file
View File

@ -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);
}
}

24
3.0/modules/webdav/vendor/Sabre/CalDAV/Version.php vendored Executable file
View File

@ -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';
}

208
3.0/modules/webdav/vendor/Sabre/CalDAV/XMLUtil.php vendored Executable file
View File

@ -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;
}
}

49
3.0/modules/webdav/vendor/Sabre/DAV/Auth/Backend/Abstract.php vendored Executable file
View File

@ -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();
}
}

85
3.0/modules/webdav/vendor/Sabre/DAV/Auth/Backend/AbstractBasic.php vendored Executable file
View File

@ -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;
}
}

105
3.0/modules/webdav/vendor/Sabre/DAV/Auth/Backend/AbstractDigest.php vendored Executable file
View File

@ -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;
}
}

77
3.0/modules/webdav/vendor/Sabre/DAV/Auth/Backend/Apache.php vendored Executable file
View File

@ -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());
}
}

102
3.0/modules/webdav/vendor/Sabre/DAV/Auth/Backend/File.php vendored Executable file
View File

@ -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;
}
}

79
3.0/modules/webdav/vendor/Sabre/DAV/Auth/Backend/PDO.php vendored Executable file
View File

@ -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;
}
}

434
3.0/modules/webdav/vendor/Sabre/DAV/Auth/Plugin.php vendored Executable file
View File

@ -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)));
}
}

147
3.0/modules/webdav/vendor/Sabre/DAV/Auth/Principal.php vendored Executable file
View File

@ -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;
/**
* 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;
}
}

74
3.0/modules/webdav/vendor/Sabre/DAV/Auth/PrincipalCollection.php vendored Executable file
View File

@ -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;
}
}

97
3.0/modules/webdav/vendor/Sabre/DAV/Browser/GuessContentType.php vendored Executable file
View File

@ -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];
}
}

54
3.0/modules/webdav/vendor/Sabre/DAV/Browser/MapGetToPropFind.php vendored Executable file
View File

@ -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;
}
}

248
3.0/modules/webdav/vendor/Sabre/DAV/Browser/Plugin.php vendored Executable file
View File

@ -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;
}
}

90
3.0/modules/webdav/vendor/Sabre/DAV/Directory.php vendored Executable file
View File

@ -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');
}
}

63
3.0/modules/webdav/vendor/Sabre/DAV/Exception.php vendored Executable file
View File

@ -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();
}
}

28
3.0/modules/webdav/vendor/Sabre/DAV/Exception/BadRequest.php vendored Executable file
View File

@ -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;
}
}

28
3.0/modules/webdav/vendor/Sabre/DAV/Exception/Conflict.php vendored Executable file
View File

@ -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;
}
}

35
3.0/modules/webdav/vendor/Sabre/DAV/Exception/ConflictingLock.php vendored Executable file
View File

@ -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));
}
}
}

28
3.0/modules/webdav/vendor/Sabre/DAV/Exception/FileNotFound.php vendored Executable file
View File

@ -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;
}
}

27
3.0/modules/webdav/vendor/Sabre/DAV/Exception/Forbidden.php vendored Executable file
View File

@ -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;
}
}

27
3.0/modules/webdav/vendor/Sabre/DAV/Exception/InsufficientStorage.php vendored Executable file
View File

@ -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;
}
}

33
3.0/modules/webdav/vendor/Sabre/DAV/Exception/InvalidResourceType.php vendored Executable file
View File

@ -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);
}
}

39
3.0/modules/webdav/vendor/Sabre/DAV/Exception/LockTokenMatchesRequestUri.php vendored Executable file
View File

@ -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);
}
}

67
3.0/modules/webdav/vendor/Sabre/DAV/Exception/Locked.php vendored Executable file
View File

@ -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));
}
}
}

44
3.0/modules/webdav/vendor/Sabre/DAV/Exception/MethodNotAllowed.php vendored Executable file
View File

@ -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)),
);
}
}

28
3.0/modules/webdav/vendor/Sabre/DAV/Exception/NotAuthenticated.php vendored Executable file
View File

@ -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;
}
}

27
3.0/modules/webdav/vendor/Sabre/DAV/Exception/NotImplemented.php vendored Executable file
View File

@ -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;
}
}

69
3.0/modules/webdav/vendor/Sabre/DAV/Exception/PreconditionFailed.php vendored Executable file
View File

@ -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);
}
}
}

30
3.0/modules/webdav/vendor/Sabre/DAV/Exception/ReportNotImplemented.php vendored Executable file
View File

@ -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);
}
}

29
3.0/modules/webdav/vendor/Sabre/DAV/Exception/RequestedRangeNotSatisfiable.php vendored Executable file
View File

@ -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;
}
}

28
3.0/modules/webdav/vendor/Sabre/DAV/Exception/UnsupportedMediaType.php vendored Executable file
View File

@ -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;
}
}

121
3.0/modules/webdav/vendor/Sabre/DAV/FS/Directory.php vendored Executable file
View File

@ -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)
);
}
}

89
3.0/modules/webdav/vendor/Sabre/DAV/FS/File.php vendored Executable file
View File

@ -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;
}
}

81
3.0/modules/webdav/vendor/Sabre/DAV/FS/Node.php vendored Executable file
View File

@ -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);
}
}

135
3.0/modules/webdav/vendor/Sabre/DAV/FSExt/Directory.php vendored Executable file
View File

@ -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)
);
}
}

88
3.0/modules/webdav/vendor/Sabre/DAV/FSExt/File.php vendored Executable file
View File

@ -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);
}
}

276
3.0/modules/webdav/vendor/Sabre/DAV/FSExt/Node.php vendored Executable file
View File

@ -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();
}
}

81
3.0/modules/webdav/vendor/Sabre/DAV/File.php vendored Executable file
View File

@ -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;
}
}

58
3.0/modules/webdav/vendor/Sabre/DAV/ICollection.php vendored Executable file
View File

@ -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);
}

28
3.0/modules/webdav/vendor/Sabre/DAV/IExtendedCollection.php vendored Executable file
View File

@ -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);
}

63
3.0/modules/webdav/vendor/Sabre/DAV/IFile.php vendored Executable file
View File

@ -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();
}

38
3.0/modules/webdav/vendor/Sabre/DAV/ILockable.php vendored Executable file
View File

@ -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);
}

44
3.0/modules/webdav/vendor/Sabre/DAV/INode.php vendored Executable file
View File

@ -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();
}

67
3.0/modules/webdav/vendor/Sabre/DAV/IProperties.php vendored Executable file
View File

@ -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);
}

27
3.0/modules/webdav/vendor/Sabre/DAV/IQuota.php vendored Executable file
View File

@ -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();
}

46
3.0/modules/webdav/vendor/Sabre/DAV/Locks/Backend/Abstract.php vendored Executable file
View File

@ -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);
}

180
3.0/modules/webdav/vendor/Sabre/DAV/Locks/Backend/FS.php vendored Executable file
View File

@ -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);
}
}

141
3.0/modules/webdav/vendor/Sabre/DAV/Locks/Backend/PDO.php vendored Executable file
View File

@ -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;
}
}

81
3.0/modules/webdav/vendor/Sabre/DAV/Locks/LockInfo.php vendored Executable file
View File

@ -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;
}

653
3.0/modules/webdav/vendor/Sabre/DAV/Locks/Plugin.php vendored Executable file
View File

@ -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;
}
}

79
3.0/modules/webdav/vendor/Sabre/DAV/Mount/Plugin.php vendored Executable file
View File

@ -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());
}
}

55
3.0/modules/webdav/vendor/Sabre/DAV/Node.php vendored Executable file
View File

@ -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');
}
}

149
3.0/modules/webdav/vendor/Sabre/DAV/ObjectTree.php vendored Executable file
View File

@ -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]);
}
}
}

25
3.0/modules/webdav/vendor/Sabre/DAV/Property.php vendored Executable file
View File

@ -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;
}
}

75
3.0/modules/webdav/vendor/Sabre/DAV/Property/GetLastModified.php vendored Executable file
View File

@ -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;
}
}

91
3.0/modules/webdav/vendor/Sabre/DAV/Property/Href.php vendored Executable file
View File

@ -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);
}
}
}

25
3.0/modules/webdav/vendor/Sabre/DAV/Property/IHref.php vendored Executable file
View File

@ -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();
}

85
3.0/modules/webdav/vendor/Sabre/DAV/Property/LockDiscovery.php vendored Executable file
View File

@ -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));
}
}
}

126
3.0/modules/webdav/vendor/Sabre/DAV/Property/Principal.php vendored Executable file
View File

@ -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;
}
}
}

80
3.0/modules/webdav/vendor/Sabre/DAV/Property/ResourceType.php vendored Executable file
View File

@ -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;
}
}

156
3.0/modules/webdav/vendor/Sabre/DAV/Property/Response.php vendored Executable file
View File

@ -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)));
}
}
}

76
3.0/modules/webdav/vendor/Sabre/DAV/Property/SupportedLock.php vendored Executable file
View File

@ -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>');
}
}

110
3.0/modules/webdav/vendor/Sabre/DAV/Property/SupportedReportSet.php vendored Executable file
View File

@ -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));
}
}
}
}

1821
3.0/modules/webdav/vendor/Sabre/DAV/Server.php vendored Executable file
View File

File diff suppressed because it is too large Load Diff

60
3.0/modules/webdav/vendor/Sabre/DAV/ServerPlugin.php vendored Executable file
View File

@ -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();
}
}

106
3.0/modules/webdav/vendor/Sabre/DAV/SimpleDirectory.php vendored Executable file
View File

@ -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);
}
}

Some files were not shown because too many files have changed in this diff Show More