Sindbad~EG File Manager

Current Path : /var/www/web3/g2data/cache/repository/released/modules/
Current File : /var/www/web3/g2data/cache/repository/released/modules/webdav-1.0.0.2-16513-base.package
<?php
function unpack_6421a0d81d($outputDir) {
/* Create directory structure. */
@mkdir($outputDir . 'classes');
@mkdir($outputDir . 'classes/GalleryStorage');
@mkdir($outputDir . 'data');
@mkdir($outputDir . 'data/options');
@mkdir($outputDir . 'lib');
@mkdir($outputDir . 'lib/HTTP');
@mkdir($outputDir . 'lib/HTTP/WebDAV');
@mkdir($outputDir . 'lib/HTTP/WebDAV/Tools');
@mkdir($outputDir . 'locale');
@mkdir($outputDir . 'po');
@mkdir($outputDir . 'templates');
@mkdir($outputDir . 'templates/blocks');
/* Recreate individual files. */
expand_6421a0d81d($outputDir, 'Callbacks.inc', 'PD9waHAKLyoKICogR2FsbGVyeSAtIGEgd2ViIGJhc2VkIHBob3RvIGFsYnVtIHZpZXdlciBhbmQgZWRpdG9yCiAqIENvcHlyaWdodCAoQykgMjAwMC0yMDA3IEJoYXJhdCBNZWRpcmF0dGEKICoKICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0CiAqIHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAogKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCiAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEsIFVTQS4KICovCgovKioKICogQHBhY2thZ2UgV2ViRGF2CiAqIEBzdWJwYWNrYWdlIFVzZXJJbnRlcmZhY2UKICogQGF1dGhvciBBbmR5IFN0YXVkYWNoZXIgPGFzdEBnbXguY2g+CiAqIEB2ZXJzaW9uICRSZXZpc2lvbjogMTU3MDQgJAogKi8KY2xhc3MgV2ViRGF2Q2FsbGJhY2tzIHsKCiAgICBmdW5jdGlvbiBjYWxsYmFjaygkcGFyYW1zLCAmJHNtYXJ0eSwgJGNhbGxiYWNrLCAkdXNlcklkPW51bGwpIHsKCWdsb2JhbCAkZ2FsbGVyeTsKCglzd2l0Y2ggKCRjYWxsYmFjaykgewoJY2FzZSAnTG9hZE1vdW50TGluayc6CgkgICAgR2FsbGVyeUNvcmVBcGk6OnJlcXVpcmVPbmNlKCdtb2R1bGVzL3dlYmRhdi9jbGFzc2VzL1dlYkRhdkhlbHBlci5jbGFzcycpOwoKCSAgICAkbGluayA9IFdlYkRhdkhlbHBlcjo6Z2V0TW91bnRMaW5rKCRwYXJhbXNbJ2l0ZW1JZCddKTsKCgkgICAgJGJsb2NrID0mICRzbWFydHktPl90cGxfdmFyc1snYmxvY2snXTsKCSAgICAkYmxvY2tbJ3dlYmRhdiddWydMb2FkTW91bnRMaW5rJ10gPSAkbGluazsKCgkgICAgcmV0dXJuIG51bGw7Cgl9CgoJcmV0dXJuIEdhbGxlcnlDb3JlQXBpOjplcnJvcihFUlJPUl9CQURfUEFSQU1FVEVSKTsKICAgIH0KfQo/Pgo=');
expand_6421a0d81d($outputDir, 'DownloadDavMount.inc', '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');
expand_6421a0d81d($outputDir, 'ItemAddWebDav.inc', '<?php
/*
 * Gallery - a web based photo album viewer and editor
 * Copyright (C) 2000-2007 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.
 */

GalleryCoreApi::requireOnce('modules/webdav/classes/WebDavHelper.class');

/**
 * Add items with WebDAV.  Handle WebDAV PUT requests and describe to users how to add items with
 * WebDAV.
 * @package WebDav
 * @subpackage UserInterface
 * @author Jack Bates <ms419@freezone.co.uk>
 * @version $Revision: 16508 $
 */
class ItemAddWebDav extends ItemAddPlugin {

    /**
     * @see ItemAddPlugin::handleRequest
     */
    function handleRequest($form, &$item) {
	$requestMethod = strtolower(GalleryUtilities::getServerVar('REQUEST_METHOD'));
	if ($requestMethod != 'put') {
	    return array(GalleryCoreApi::error(ERROR_REQUEST_FORGED), null, null);
	}

	$path = GalleryUtilities::getRequestVariables('path');

	/* Check resource is not locked */
	$ret = WebDavHelper::checkLocks($path);
	if ($ret) {
	    return array($ret, null, null);
	}

	/* Prepare data-structure from PUT request */
	list ($ret, $webDavOptions, $stream, $mimeType) = WebDavHelper::putRequestHelper();
	if ($ret) {
	    return array($ret, null, null);
	}

	/* If the mime type is unknown try to get a mime type from the file name */
	list ($ret, $mimeExtensions) = GalleryCoreApi::convertMimeToExtensions($mimeType);
	if ($mimeType == 'application/octet-stream'
		|| $mimeType == 'application/unknown'
		|| empty($mimeExtensions)) {
	    $extension = GalleryUtilities::getFileExtension(basename($path));
	    list ($ret, $mimeType) = GalleryCoreApi::convertExtensionToMime($extension);
	    if ($ret) {
		$mimeType = 'application/unknown';
	    }
	}

	list ($ret, $itemId) = GalleryCoreApi::fetchItemIdByPath($path);
	if ($ret) {
	    if ($ret->getErrorCode() & ERROR_MISSING_OBJECT) {
		/* Item doesn't already exist at this path.  Create it. */
		list ($ret, $error, $status) = $this->_addItem(
		    $item, $webDavOptions, $stream, $mimeType, $path);
		if ($ret) {
		    return array($ret, null, null);
		}

		return array(null, $error, $status);
	    }

	    return array($ret, null, null);
	}

	list ($ret, $error, $status) = $this->_replaceItem(
	    $item, $webDavOptions, $stream, $mimeType, $path, $itemId);
	if ($ret) {
	    return array($ret, null, null);
	}

	return array(null, $error, $status);
    }

    /**
     * Add new item.
     * @param object GalleryItem $parentItem The parent item of the item to be added
     * @param array $webDavOptions WebDAV library options
     * @param resource $stream request body file handle
     * @param string $mimeType request content type
     * @param string $path the path to the destination in the Gallery hierarchy
     * @see ItemAddPlugin::handleRequest for the returned data
     * @access private
     */
    function _addItem($parentItem, $webDavOptions, $stream, $mimeType, $path) {
	global $gallery;
	$platform =& $gallery->getPlatform();

	/* Following pattern from ItemAddWebCam */
	$tmpDir = $gallery->getConfig('data.gallery.tmp');
	$tmpFile = $platform->tempnam($tmpDir, 'webdav');

	$handle = $platform->fopen($tmpFile, 'wb');
	if (!$handle) {
	    return array(GalleryCoreApi::error(ERROR_PLATFORM_FAILURE), null, null);
	}

	while (!$platform->feof($stream)) {
	    $buf = $platform->fread($stream, 4096);
	    if ($platform->fwrite($handle, $buf) != 4096) {
		break;
	    }
	}

	$platform->fclose($handle);

	$originalPath = GalleryUtilities::getRequestVariables('originalPath');
	$title = empty($originalPath) ? basename($path) : basename($originalPath);
	list ($ret, $newItem) = GalleryCoreApi::addItemToAlbum($tmpFile, basename($path),
	    $title, '', '', $mimeType, $parentItem->getId());
	@$platform->unlink($tmpFile);
	if ($ret) {
	    return array($ret, null, null);
	}

	WebDavServer::setResponseStatus('201 Created');
	return array(null, array(), array('addedFiles' => array(array(
	    'fileName' => basename($path), 'id' => $newItem->getId()))));
    }

    /**
     * Replace existing item.
     * @param object GalleryItem $parentItem The parent item of the item to be added
     * @param array $webDavOptions WebDAV library options
     * @param resource $stream request body file handle
     * @param string $mimeType request content type
     * @param string $path the path to the destination in the Gallery hierarchy
     * @param int $itemId The id of the item to be replaced
     * @see ItemAddPlugin::handleRequest for the returned data
     * @access private
     */
    function _replaceItem($parentItem, $webDavOptions, $stream, $mimeType, $path, $itemId) {
	global $gallery;
	$platform =& $gallery->getPlatform();

	/*
	 * The parent is already read-locked by the ItemAddController. Read-lock the whole ancestor
	 * sequence to ensure that filesystem path stays the same.
	 */
	list ($ret, $lockIds[]) = GalleryCoreApi::acquireReadLockParents($parentItem->getId());
	if ($ret) {
	    return array($ret, null, null);
	}

	/* Write lock the item we're replacing */
	list ($ret, $lockIds[]) = GalleryCoreApi::acquireWriteLock($itemId);
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array($ret, null, null);
	}

	list ($ret, $item) = GalleryCoreApi::loadEntitiesById($itemId);
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array($ret, null, null);
	}

	/* Replace the file content */
	list ($ret, $filePath) = $item->fetchPath();
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array($ret, null, null);
	}

	if (($handle = $platform->fopen($filePath, 'wb')) === false) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array(GalleryCoreApi::error(ERROR_PLATFORM_FAILURE), null, null);
	}

	/* Format PUT response */
	$ret = WebDavHelper::putResponseHelper($webDavOptions, $handle);
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array($ret, null, null);
	}

	/* Get a new item by mime type */
	list ($ret, $newItem) = GalleryCoreApi::newItemByMimeType($mimeType);
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array($ret, null, null);
	}
	if (!isset($newItem)) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array(GalleryCoreApi::error(ERROR_MISSING_OBJECT, __FILE__, __LINE__,
		'Failed to get new item by mime type: ' . $mimeType), null, null);
	}

	$ret = $newItem->create($parentItem->getId(), $filePath, $mimeType);
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array($ret, null, null);
	}

	/* Make the new item as close a copy of the original item as possible */
	list ($ret, $newItem) = WebDavHelper::mirrorEntity($item, $newItem);
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array($ret, null, null);
	}

	/* Fall back on an unknown item if the new class doesn't support the file content */
	$ret = $newItem->rescan();
	if ($ret) {
	    if (!($ret->getErrorCode() & ERROR_BAD_DATA_TYPE)) {
		GalleryCoreApi::releaseLocks($lockIds);
		return array($ret, null, null);
	    }

	    $gallery->debug('Error in ItemEditWebDav::handleRequest: ' . $newItem->getClassName()
		. ' doesn\'t support the file content.  Falling back on an unknown item.');

	    list ($ret, $newItem) = GalleryCoreApi::newFactoryInstanceById('GalleryEntity',
		'GalleryUnknownItem');
	    if ($ret) {
		GalleryCoreApi::releaseLocks($lockIds);
		return array($ret, null, null);
	    }
	    if (!isset($newItem)) {
		GalleryCoreApi::releaseLocks($lockIds);
		return array(GalleryCoreApi::error(ERROR_MISSING_OBJECT, __FILE__, __LINE__,
		    'Failed to get GalleryUnknownItem instance'), null, null);
	    }

	    $ret = $newItem->create($parentItem->getId(), $filePath, $mimeType);
	    if ($ret) {
		GalleryCoreApi::releaseLocks($lockIds);
		return array($ret, null, null);
	    }

	    /* Make the new item as close a copy of the original item as possible */
	    list ($ret, $newItem) = WebDavHelper::mirrorEntity($item, $newItem);
	    if ($ret) {
		GalleryCoreApi::releaseLocks($lockIds);
		return array($ret, null, null);
	    }

	    $ret = $newItem->rescan();
	    if ($ret) {
		GalleryCoreApi::releaseLocks($lockIds);
		return array($ret, null, null);
	    }
	}

	/* Follow pattern from ItemAddWebCam */
	$tmpDir = $gallery->getConfig('data.gallery.tmp');
	$tmpFile = $platform->tempnam($tmpDir, 'webdav');

	/* Backup the file content */
	if (!$platform->copy($filePath, $tmpFile)) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array(GalleryCoreApi::error(ERROR_PLATFORM_FAILURE), null, null);
	}

	$ret = $item->delete();
	if ($ret) {
	    @$platform->unlink($tmpFile);
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array($ret, null, null);
	}

	/*
	 * Restore the file content.  If this fails, we rollback the database transaction but the
	 * file content is missing.
	 */
	if (!$platform->copy($tmpFile, $filePath)) {
	    @$platform->unlink($tmpFile);
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array(GalleryCoreApi::error(ERROR_PLATFORM_FAILURE), null, null);
	}
	@$platform->unlink($tmpFile);

	$newItem->setPersistentFlag(STORAGE_FLAG_NEWLY_CREATED);
	$ret = $newItem->save();
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array($ret, null, null);
	}

	$ret = GalleryCoreApi::addExistingItemToAlbum($newItem, $parentItem->getId(), true);
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return array($ret, null, null);
	}

	$ret = GalleryCoreApi::releaseLocks($lockIds);
	if ($ret) {
	    return array($ret, null, null);
	}

	return array(null, array(), array(
	    'addedFiles' => array(array('fileName' => basename($path),
					'id' => $newItem->getId()))));
    }

    /**
     * @see ItemAddPlugin::loadTemplate
     */
    function loadTemplate(&$template, &$form, $item) {
	return array(null, 'modules/webdav/templates/ItemAddWebDav.tpl', null);
    }

    /**
     * @see ItemAddPlugin::getTitle
     */
    function getTitle() {
	list ($ret, $module) = GalleryCoreApi::loadPlugin('module', 'webdav');
	if ($ret) {
	    return array($ret, null);
	}

	return array(null, $module->translate('WebDAV'));
    }
}
?>
');
expand_6421a0d81d($outputDir, 'MANIFEST', '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');
expand_6421a0d81d($outputDir, 'WebDav.inc', '<?php
/*
 * Gallery - a web based photo album viewer and editor
 * Copyright (C) 2000-2007 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.
 */

GalleryCoreApi::requireOnce('modules/core/ItemAdd.inc');
GalleryCoreApi::requireOnce('modules/webdav/classes/WebDavHelper.class');

/**
 * The WebDAV controller handles all WebDAV requests.
 * @package WebDav
 * @subpackage UserInterface
 * @author Jack Bates <ms419@freezone.co.uk>
 * @version $Revision: 15931 $
 */
class WebDavController extends GalleryController {

    /**
     * @see GalleryController::handleRequest
     */
    function handleRequest($form) {
	global $gallery;
	$platform =& $gallery->getPlatform();

	/*
	 * Suppress generating HTML error pages for WebDAV clients.  Exploit the fact that event
	 * listeners aren't currently stored in the database, so this event listener is only
	 * registered for this request.  Since this is the WebDAV controller, we know it is a WebDAV
	 * request.
	 */
	$ret = GalleryCoreApi::registerEventListener('Gallery::Error', new WebDavModule(), true);
	if ($ret) {
	    return array($ret, null);
	}

	/*
	 * Windows Web Folders does not respect HTTP auth requests in PUT responses, so the user
	 * will not be prompted to login.  To work around this, request HTTP auth in all responses
	 * to anonymous Windows Web Folders requests.  Consequently anonymous users can't connect to
	 * WebDAV with Windows Web Folders.
	 */
	$userAgent = GalleryUtilities::getServerVar('HTTP_USER_AGENT');
	if (strpos($userAgent, 'Microsoft Data Access Internet Publishing Provider DAV') !== false
		|| strpos($userAgent, 'Microsoft-WebDAV-MiniRedir') !== false) {
	    list ($ret, $isAnonymous) = GalleryCoreApi::isAnonymousUser();
	    if ($ret) {
		return array($ret, null);
 	    }
	    if ($isAnonymous) {
		return array(GalleryCoreApi::error(ERROR_PERMISSION_DENIED, __FILE__, __LINE__,
			'WebDAV: Anonymous request by MS Windows Webfolders WebDAV client detected.'
			. '  Usability workaround: Require auth on all requests.'), null);
	    }
	}

	/*
	 * GalleryCoreApi::addItemToAlbum normalizes path components but
	 * GalleryCoreApi::fetchItemIdByPath does not.  This is a problem for WebDAV because GET
	 * following a successful PUT at the same URL should succeed.
	 *
	 * An alternative is to consistantly normalize all requests.  While this shouldn't break any
	 * clients, PROPFIND following a successful PUT should strictly include the URL of the PUT.
	 *
	 * Consequently we reject an illegal path component.
	 *
	 * This condition may be relaxed in future if it's a problem.
	 */
	$path = GalleryUtilities::getRequestVariables('path');
	/**
 	 * @todo Refactor towards a cleaner approach, e.g. using a map for public paths.
 	 */
 	GalleryUtilities::putRequestVariable('originalPath', $path);
	$pathComponent = basename($path);

	/* Special case to suppress Mac '._' files.  Ignore request but return success. */
	if (!strncmp($pathComponent, '._', 2)) {
	    WebDavServer::setResponseStatus('200 OK');
	    $handle = WebDavServer::openRequestBody();
	    while (!feof($handle)) {
		fgets($handle);
	    }
	    return array(GalleryCoreApi::error(ERROR_BAD_PATH), null);
	}

 	/* Silently legalize path component */
 	$pathComponents = preg_split('/\//', $path, -1, PREG_SPLIT_NO_EMPTY);
 	foreach ($pathComponents as $key => $pathComponent) {
 	    $pathComponents[$key] = $platform->legalizePathComponent($pathComponent);
 	}
 	$path = implode('/', $pathComponents);
 	GalleryUtilities::putRequestVariable('path', $path);

	$requestMethod = GalleryUtilities::strToLower(
	    GalleryUtilities::getServerVar('REQUEST_METHOD'));
	if ($requestMethod == 'get' || $requestMethod == 'head') {
	    if (empty($path)) {
		list ($ret, $itemId) = GalleryCoreApi::getDefaultAlbumId();
		if ($ret) {
		    return array($ret, null);
		}
	    } else {
		list ($ret, $itemId) = GalleryCoreApi::fetchItemIdByPath($path);
		if ($ret) {
		    return array($ret, null);
		}
	    }

	    list ($ret, $item) = GalleryCoreApi::loadEntitiesById($itemId);
	    if ($ret) {
		return array($ret, null);
	    }

	    /* Until there's a better way to delegate to Show/DownloadItem */
	    GalleryUtilities::putRequestVariable('itemId', $itemId);
	    if (GalleryUtilities::isA($item, 'GalleryAlbumItem')) {
		return array(null, array('delegate' => array('view' => 'core.ShowItem'),
					 'status' => array(),
					 'error' => array()));
	    }

	    return array(null, array('delegate' => array('view' => 'core.DownloadItem'),
				     'status' => array(),
				     'error' => array()));
	} else if ($requestMethod == 'put') {
	    list ($ret, $parentId) = WebDavHelper::getParentItemIdByPath($path);
	    if ($ret) {
		if ($ret->getErrorCode() & ERROR_MISSING_OBJECT) {
		    /*
		     * A PUT that would result in the creation of a resource without an
		     * appropriately scoped parent collection MUST fail with a 409
		     * (Conflict).
		     */
		    WebDavServer::setResponseStatus('409 Conflict');
		}

		return array($ret, null);
	    }

	    /* Until there's a better way to delegate to ItemAdd */
	    GalleryUtilities::putRequestVariable('itemId', $parentId);
	    GalleryUtilities::putRequestVariable('addPlugin', 'ItemAddWebDav');
	    /* Let the ItemAddPlugin handle the replacement for the auth-token check */
	    list ($ret, $data) = ItemAddController::handleRequest($form);
	    if ($ret) {
		return array($ret, null);
	    }

	    /*
	     * Don't send HTTP redirects or HTML status/error back to DAV clients since we
	     * have already set our status code. Fall through to the standard empty return.
	     */
	}

	return array(null, array('delegate' => array('view' => 'webdav.WebDav'),
				 'status' => array(),
				 'error' => array()));
    }

    /**
     * @see GalleryController::omitAuthTokenCheck
     */
    function omitAuthTokenCheck() {
	return true;
    }
}

/**
 * The WebDAV view generates WebDAV responses.
 */
class WebDavView extends GalleryView {

    /**
     * @see GalleryView::isImmediate
     */
    function isImmediate() {
	return true;
    }

    /**
     * @see GalleryView::isControllerLike
     */
    function isControllerLike() {
	/* Although this view is controller-like, we return false since we can't add authTokens */
	return false;
    }

    /**
     * @see GalleryView::renderImmediate
     */
    function renderImmediate($status, $error) {
	$requestMethod = GalleryUtilities::strToLower(
		GalleryUtilities::getServerVar('REQUEST_METHOD'));
	if (!in_array($requestMethod, array('options', 'propfind', 'proppatch', 'mkcol', 'delete',
					    'move', 'lock', 'unlock'))) {

	    /* If we just completed a PUT request and got delegated here, just silently return */
	    if ($requestMethod == 'put') {
		return null;
	    }

	    return GalleryCoreApi::error(ERROR_UNIMPLEMENTED);
	}

	$ret = WebDavHelper::$requestMethod();
	if ($ret) {
	    return $ret;
	}

	return null;
    }
}
?>
');
expand_6421a0d81d($outputDir, 'WebDavMount.inc', 'PD9waHAKLyoKICogR2FsbGVyeSAtIGEgd2ViIGJhc2VkIHBob3RvIGFsYnVtIHZpZXdlciBhbmQgZWRpdG9yCiAqIENvcHlyaWdodCAoQykgMjAwMC0yMDA3IEJoYXJhdCBNZWRpcmF0dGEKICoKICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0CiAqIHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAogKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCiAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEsIFVTQS4KICovCgovKioKICogU2hvdyBXZWJEQVYgbW91bnQgaW5zdHJ1Y3Rpb25zLgogKiBAcGFja2FnZSBXZWJEYXYKICogQHN1YnBhY2thZ2UgVXNlckludGVyZmFjZQogKiBAYXV0aG9yIEFuZHkgU3RhdWRhY2hlciA8YXN0QGdteC5jaD4KICogQHZlcnNpb24gJFJldmlzaW9uOiAxNTcwNCAkCiAqLwpjbGFzcyBXZWJEYXZNb3VudFZpZXcgZXh0ZW5kcyBHYWxsZXJ5VmlldyB7CiAgICAvKioKICAgICAqIEBzZWUgR2FsbGVyeVZpZXc6OmxvYWRUZW1wbGF0ZQogICAgICovCiAgICBmdW5jdGlvbiBsb2FkVGVtcGxhdGUoJiR0ZW1wbGF0ZSwgJiRmb3JtKSB7CgkkdGVtcGxhdGUtPnNldFZhcmlhYmxlKCdXZWJEYXZNb3VudCcsIGFycmF5KCdpc1ZpZXcnID0+IHRydWUpKTsKCXJldHVybiBhcnJheShudWxsLCBhcnJheSgnYm9keScgPT4gJ21vZHVsZXMvd2ViZGF2L3RlbXBsYXRlcy9XZWJEYXZNb3VudC50cGwnKSk7CiAgICB9CgogICAgLyoqCiAgICAgKiBAc2VlIEdhbGxlcnlWaWV3OjpnZXRWaWV3RGVzY3JpcHRpb24KICAgICAqLwogICAgZnVuY3Rpb24gZ2V0Vmlld0Rlc2NyaXB0aW9uKCkgewoJbGlzdCAoJHJldCwgJG1vZHVsZSkgPSBHYWxsZXJ5Q29yZUFwaTo6bG9hZFBsdWdpbignbW9kdWxlJywgJ3dlYmRhdicpOwoJaWYgKCRyZXQpIHsKCSAgICByZXR1cm4gYXJyYXkoJHJldCwgbnVsbCk7Cgl9CgoJcmV0dXJuIGFycmF5KG51bGwsICRtb2R1bGUtPnRyYW5zbGF0ZSgnTW91bnQgd2l0aCBXZWJEQVYnKSk7CiAgICB9Cn0KPz4K');
expand_6421a0d81d($outputDir, 'WebDavSiteAdmin.inc', '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');
expand_6421a0d81d($outputDir, 'WebDavWorks.inc', 'PD9waHAKLyoKICogR2FsbGVyeSAtIGEgd2ViIGJhc2VkIHBob3RvIGFsYnVtIHZpZXdlciBhbmQgZWRpdG9yCiAqIENvcHlyaWdodCAoQykgMjAwMC0yMDA3IEJoYXJhdCBNZWRpcmF0dGEKICoKICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0CiAqIHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAogKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCiAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEsIFVTQS4KICovCgovKioKICogQ2hlY2sgdGhhdCBHYWxsZXJ5IGhhbmRsZXMgV2ViREFWIHJlcXVlc3QgbWV0aG9kcy4KICogQHBhY2thZ2UgV2ViRGF2CiAqIEBzdWJwYWNrYWdlIFVzZXJJbnRlcmZhY2UKICogQGF1dGhvciBKYWNrIEJhdGVzIDxtczQxOUBmcmVlem9uZS5jby51az4KICogQHZlcnNpb24gJFJldmlzaW9uOiAxNTcxNSAkCiAqLwpjbGFzcyBXZWJEYXZXb3Jrc1ZpZXcgZXh0ZW5kcyBHYWxsZXJ5VmlldyB7CgogICAgLyoqCiAgICAgKiBAc2VlIEdhbGxlcnlWaWV3Ojppc0ltbWVkaWF0ZQogICAgICovCiAgICBmdW5jdGlvbiBpc0ltbWVkaWF0ZSgpIHsKCXJldHVybiB0cnVlOwogICAgfQoKICAgIC8qKgogICAgICogQHNlZSBHYWxsZXJ5Vmlldzo6cmVuZGVySW1tZWRpYXRlCiAgICAgKi8KICAgIGZ1bmN0aW9uIHJlbmRlckltbWVkaWF0ZSgkc3RhdHVzLCAkZXJyb3IpIHsKCXByaW50ICdQQVNTX1dFQkRBVic7CiAgICB9Cn0KPz4K');
expand_6421a0d81d($outputDir, 'classes/GNUmakefile', 'aW5jbHVkZSAuLi8uLi8uLi9saWIvdG9vbHMvYmluL0dOVW1ha2VmaWxlLmNsYXNzZXMK');
expand_6421a0d81d($outputDir, 'classes/GalleryStorage/GNUmakefile', 'aW5jbHVkZSAuLi8uLi8uLi8uLi9saWIvdG9vbHMvYmluL0dOVW1ha2VmaWxlLkdhbGxlcnlTdG9yYWdlCg==');
expand_6421a0d81d($outputDir, 'classes/GalleryStorage/schema.tpl', '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');
expand_6421a0d81d($outputDir, 'classes/Maps.inc', 'PD9waHAKLyogVGhpcyBmaWxlIGlzIGF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIGZyb20gTWFwcy54bWwgYnkgbGliL3Rvb2xzL2Jpbi9nZW5lcmF0ZS1tYXBzLnBocCAqLwokbWFwSW5mb1snV2ViRGF2TG9ja01hcCddID0gYXJyYXkoJ2RlcHRoJz0+YXJyYXkoJ3R5cGUnPT5TVE9SQUdFX1RZUEVfU1RSSU5HLCdzaXplJz0+U1RPUkFHRV9TSVpFX01FRElVTSksJ293bmVyJz0+YXJyYXkoJ3R5cGUnPT5TVE9SQUdFX1RZUEVfU1RSSU5HLCdzaXplJz0+U1RPUkFHRV9TSVpFX01FRElVTSksJ2V4cGlyZXMnPT5hcnJheSgndHlwZSc9PlNUT1JBR0VfVFlQRV9JTlRFR0VSLCdzaXplJz0+U1RPUkFHRV9TSVpFX01FRElVTSksJ3Rva2VuJz0+YXJyYXkoJ3R5cGUnPT5TVE9SQUdFX1RZUEVfU1RSSU5HLCdzaXplJz0+U1RPUkFHRV9TSVpFX01FRElVTSksJ3BhdGgnPT5hcnJheSgndHlwZSc9PlNUT1JBR0VfVFlQRV9TVFJJTkcsJ3NpemUnPT5TVE9SQUdFX1NJWkVfTUVESVVNKSwnZ2FsbGVyeUxvY2tJZCc9PmFycmF5KCd0eXBlJz0+U1RPUkFHRV9UWVBFX0lOVEVHRVIsJ3NpemUnPT5TVE9SQUdFX1NJWkVfTUVESVVNKSk7Cj8+Cg==');
expand_6421a0d81d($outputDir, 'classes/Maps.xml', 'PCFET0NUWVBFIG1hcHMgU1lTVEVNICIuLi8uLi8uLi9saWIvdG9vbHMvZHRkL01hcHNEZWZpbml0aW9uMi4wLmR0ZCI+CjxtYXBzPgogIDxtYXA+CiAgICA8bWFwLW5hbWU+V2ViRGF2TG9ja01hcDwvbWFwLW5hbWU+CiAgICA8c2NoZW1hPgogICAgICA8c2NoZW1hLW1ham9yPjA8L3NjaGVtYS1tYWpvcj4KICAgICAgPHNjaGVtYS1taW5vcj4xPC9zY2hlbWEtbWlub3I+CiAgICA8L3NjaGVtYT4KICAgIDxtZW1iZXI+CiAgICAgIDxtZW1iZXItbmFtZT5kZXB0aDwvbWVtYmVyLW5hbWU+CiAgICAgIDxtZW1iZXItdHlwZT5TVFJJTkc8L21lbWJlci10eXBlPgogICAgICA8bWVtYmVyLXNpemU+TUVESVVNPC9tZW1iZXItc2l6ZT4KICAgIDwvbWVtYmVyPgogICAgPG1lbWJlcj4KICAgICAgPG1lbWJlci1uYW1lPm93bmVyPC9tZW1iZXItbmFtZT4KICAgICAgPG1lbWJlci10eXBlPlNUUklORzwvbWVtYmVyLXR5cGU+CiAgICAgIDxtZW1iZXItc2l6ZT5NRURJVU08L21lbWJlci1zaXplPgogICAgPC9tZW1iZXI+CiAgICA8bWVtYmVyPgogICAgICA8bWVtYmVyLW5hbWU+ZXhwaXJlczwvbWVtYmVyLW5hbWU+CiAgICAgIDxtZW1iZXItdHlwZT5JTlRFR0VSPC9tZW1iZXItdHlwZT4KICAgIDwvbWVtYmVyPgogICAgPG1lbWJlcj4KICAgICAgPG1lbWJlci1uYW1lPnRva2VuPC9tZW1iZXItbmFtZT4KICAgICAgPG1lbWJlci10eXBlPlNUUklORzwvbWVtYmVyLXR5cGU+CiAgICAgIDxtZW1iZXItc2l6ZT5NRURJVU08L21lbWJlci1zaXplPgogICAgPC9tZW1iZXI+CiAgICA8bWVtYmVyPgogICAgICA8bWVtYmVyLW5hbWU+cGF0aDwvbWVtYmVyLW5hbWU+CiAgICAgIDxtZW1iZXItdHlwZT5TVFJJTkc8L21lbWJlci10eXBlPgogICAgICA8bWVtYmVyLXNpemU+TUVESVVNPC9tZW1iZXItc2l6ZT4KICAgIDwvbWVtYmVyPgogICAgPG1lbWJlcj4KICAgICAgPG1lbWJlci1uYW1lPmdhbGxlcnlMb2NrSWQ8L21lbWJlci1uYW1lPgogICAgICA8bWVtYmVyLXR5cGU+SU5URUdFUjwvbWVtYmVyLXR5cGU+CiAgICA8L21lbWJlcj4KICA8L21hcD4KPC9tYXBzPgo=');
expand_6421a0d81d($outputDir, 'classes/WebDavHelper.class', '<?php
/*
 * Gallery - a web based photo album viewer and editor
 * Copyright (C) 2000-2007 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.
 */

GalleryCoreApi::requireOnce('modules/webdav/lib/HTTP/WebDAV/Server.php');

/* WebDAV status codes */
define('WEBDAV_STATUS_NO_XML_PARSER', 0x00000002);
define('WEBDAV_STATUS_METHOD_NOT_HANDLED', 0x00000004);
define('WEBDAV_STATUS_HTTPAUTH_MODULE_DISABLED', 0x00000008);
define('WEBDAV_STATUS_REWRITE_MODULE_DISABLED', 0x00000010);
define('WEBDAV_STATUS_CONNECT_RULE_DISABLED', 0x00000020);
define('WEBDAV_STATUS_MISSING_DAV_HEADERS', 0x00000040);
define('WEBDAV_STATUS_ALTERNATIVE_URL_HEADERS', 0x00000080);
define('WEBDAV_STATUS_BAD_REWRITE_PARSER', 0x00000100);
define('WEBDAV_STATUS_OPTIONS_RULE_DISABLED', 0x00000200);
define('WEBDAV_STATUS_HTTPAUTH_AUTH_PLUGINS_DISABLED', 0x00000400);
define('WEBDAV_STATUS_ERROR_UNKNOWN', 0x80000000);

/* Gallery property namespace - RFC2518 18 */
define('WEBDAV_GALLERY_NAMESPACE', 'http://gallery2.org/dav/props/');

/**
 * WebDAV helper class.
 * @package WebDav
 * @subpackage Classes
 * @author Jack Bates <ms419@freezone.co.uk>
 * @version $Revision: 16508 $
 * @static
 */
class WebDavHelper {

    /**
     * Check this module's configuration.
     * @return array object GalleryStatus a status code
     *               int WebDAV status code
     */
    function checkConfiguration() {
	global $gallery;
	$phpVm = $gallery->getPhpVm();
	$urlGenerator =& $gallery->getUrlGenerator();

	$code = 0x00000000;

	list ($ret, $moduleStatus) = GalleryCoreApi::fetchPluginList('module');
	if ($ret) {
	    return array($ret, null);
	}

	/*
	 * URL rewrite module must be enabled.  Check it regardless of missing DAV headers because
	 * it also implies the connect rule is disabled.  Check it before checking for missing DAV
	 * headers causes because it is a missing DAV headers cause.
	 */
	if (empty($moduleStatus['rewrite']['active'])) {
	    $code |= WEBDAV_STATUS_REWRITE_MODULE_DISABLED;
	} else {
	    list ($ret, $rewriteApi) = GalleryCoreApi::newFactoryInstance('RewriteApi');
	    if ($ret) {
		return array($ret, null);
	    }
	    if (!isset($rewriteApi)) {
		return array(GalleryCoreApi::error(ERROR_CONFIGURATION_REQUIRED), null);
	    }

	    list ($ret, $isCompatible) = $rewriteApi->isCompatibleWithApi(array(1, 1));
	    if ($ret) {
		return array($ret, null);
	    }
	    if (!$isCompatible) {
		return array(GalleryCoreApi::error(ERROR_CONFIGURATION_REQUIRED), null);
	    }

	    list ($ret, $activeRules) = $rewriteApi->fetchActiveRulesForModule('webdav');
	    if ($ret) {
		return array($ret, null);
	    }
	}

	/*
	 * Check for missing DAV headers causes first so we can show the error unknown warning if no
	 * causes are found.
	 */
	if (!WebDavHelper::checkDavHeaders($urlGenerator->generateUrl(
		array('controller' => 'webdav.WebDav'),
		array('forceFullUrl' => true,
		      'htmlEntities' => false)))) {

	    /* Already checked one cause: URL rewrite module disabled.  Check other causes. */
	    if (!WebDavHelper::checkDavHeaders($urlGenerator->generateUrl(
		    array('href' => 'modules/webdav/data/options/'),
		    array('forceFullUrl' => true,
			  'htmlEntities' => false)))) {
		$code |= WEBDAV_STATUS_ALTERNATIVE_URL_HEADERS;
	    }

	    if (!empty($moduleStatus['rewrite']['active'])) {
		if ($rewriteApi->getParserType() != 'preGallery') {
		    $code |= WEBDAV_STATUS_BAD_REWRITE_PARSER;
		} else {
		    if (!in_array('options', $activeRules)) {
			$code |= WEBDAV_STATUS_OPTIONS_RULE_DISABLED;
		    }
		}
	    }

	    /* No causes found for missing DAV headers! */
	    if (!$code) {
		$code |= WEBDAV_STATUS_ERROR_UNKNOWN;
	    }

	    $code |= WEBDAV_STATUS_MISSING_DAV_HEADERS;
	}

	/*
	 * Must use short URL because most WebDAV clients don't support query strings.  Check it
	 * after checking for missing DAV headers causes so we can show the error unknown warning if
	 * no causes are found.
	 */
	if (!empty($moduleStatus['rewrite']['active'])) {
	    if (!in_array('connect', $activeRules)) {
		$code |= WEBDAV_STATUS_CONNECT_RULE_DISABLED;
	    }
	}

	/*
	 * HTTP auth module must be enabled to authenticate with WebDAV.  Check it after checking
	 * for missing DAV headers causes so we can show the error unknown warning if no causes are
	 * found.
	 */
	if (empty($moduleStatus['httpauth']['active'])) {
	    $code |= WEBDAV_STATUS_HTTPAUTH_MODULE_DISABLED;
	} else {
	    /* Ensure HTTP auth is enabled */
	    list ($ret, $httpAuthInterface) =
	    	GalleryCoreApi::newFactoryInstance('HttpAuthInterface_1_0');
	    if ($ret) {
		return array($ret, null);
	    }
	    if (isset($httpAuthInterface)) {
		list ($ret, $httpAuthPluginEnabled, $serverAuthPluginEnabled) =
			$httpAuthInterface->getConfiguration();
		if ($ret) {
		    return array($ret, null);
		}
		if (!$httpAuthPluginEnabled && !$serverAuthPluginEnabled) {
		    $code |= WEBDAV_STATUS_HTTPAUTH_AUTH_PLUGINS_DISABLED;
		}
	    }
	}

	/*
	 * Check that Gallery handles WebDAV request methods.  Check it after checking for missing
	 * DAV headers causes so we can show the error unknown warning if no causes are found.
	 */
	foreach (array('PROPFIND', 'PROPPATCH', 'MKCOL', 'DELETE', 'PUT', 'MOVE', 'LOCK', 'UNLOCK')
		as $requestMethod) {
	    if (!WebDavHelper::checkRequestMethod($requestMethod)) {
		if ($gallery->getDebug()) {
		    $gallery->debug('Error in WebDavHelper::checkConfiguration:'
			. ' this server doesn\'t pass ' . $requestMethod . ' requests to Gallery.');
		}
		$code |= WEBDAV_STATUS_METHOD_NOT_HANDLED;
	    }
	}

	/*
	 * The WebDAV library requires a PHP XML parser.  Check it after checking for missing DAV
	 * headers causes so we can show the error unknown warning if no causes are found.
	 */
	if (!$phpVm->extension_loaded('xml')) {
	    $code |= WEBDAV_STATUS_NO_XML_PARSER;
	}

	return array(null, $code);
    }

    /**
     * Check that Gallery handles WebDAV request methods.
     * @param string $requestMethod
     * @return boolean true if Gallery handles the request method
     */
    function checkRequestMethod($requestMethod) {
	global $gallery;
	$urlGenerator =& $gallery->getUrlGenerator();

	list ($status, $headers, $body) = GalleryCoreApi::requestWebPage($urlGenerator->generateUrl(
		array('view' => 'webdav.WebDavWorks'),
		array('forceFullUrl' => true,
		      'htmlEntities' => false)), $requestMethod, array('Content-length' => 0));

	if (!preg_match('/^HTTP\/[0-9]\.[0-9] 200/', $status)) {
	    return false;
	}

	if (trim($body) != 'PASS_WEBDAV') {
	    return false;
	}

	return true;
    }

    /**
     * Check that OPTIONS responses includes the DAV headers.
     * @param string $url
     * @return boolean true if OPTIONS responses include the DAV headers
     */
    function checkDavHeaders($url) {
	list ($status, $headers, $body) = GalleryCoreApi::requestWebPage($url, 'OPTIONS');

	if (!preg_match('/^HTTP\/[0-9]\.[0-9] 200/', $status)) {
	    return false;
	}

	if (empty($headers['Allow']) || $headers['Allow'] != 'OPTIONS,PROPFIND,PROPPATCH,MKCOL,GET'
		. ',HEAD,DELETE,PUT,MOVE,LOCK,UNLOCK') {
	    return false;
	}

	if (empty($headers['DAV']) || $headers['DAV'] != '1,2') {
	    return false;
	}

	if (empty($headers['MS-Author-Via']) || $headers['MS-Author-Via'] != 'DAV') {
	    return false;
	}

	return true;
    }

    /**
     * Returns a browser-specifc mount link for the given item.
     * @param int $itemId
     * @return array('href' => string the davmount URL,
     *               'script' (optional) => string JavaScript to be used as onclick,
     *               'attrs' => array() string additional link tag attributes)
     */
    function getMountLink($itemId) {
	global $gallery;
	$urlGenerator =& $gallery->getUrlGenerator();

	$userAgent = GalleryUtilities::getServerVar('HTTP_USER_AGENT');

	$url = $urlGenerator->generateUrl(array('controller' => 'webdav.WebDav',
						'itemId' => $itemId),
					  array('forceFullUrl' => true,
						'forceSessionId' => false,
						'useAuthToken' => false));
	$link['attrs'] = 'style="behavior: url(#default#anchorClick)" folder="'. $url . '"';

	if (strpos($userAgent, 'MSIE') !== false) {
	    /*
	     * Mount with JavaScript only if using MSIE.  By default, dropdowns link to davmount
	     * resources.
	     */
	    $url = $urlGenerator->generateUrl(array('controller' => 'webdav.WebDav',
						    'itemId' => $itemId),
					      array('forceFullUrl' => true,
						    'htmlEntities' => false,
						    'forceSessionId' => false,
						    'useAuthToken' => false));
	    $link['script'] =
		    "this.style.behavior = 'url(#default#httpFolder)'; this.navigate('$url')";
	}
	if (strpos($userAgent, 'Konqueror') !== false) {
	    /* Konqueror supports webdav:// URLs */
	    $urlParams = array('controller' => 'webdav.WebDav', 'itemId' => $itemId);
	    $urlOptions = array('protocol' => 'webdav', 'forceSessionId' => false,
				'useAuthToken' => false);
	} else {
	    $urlParams = array('view' => 'webdav.DownloadDavMount', 'itemId' => $itemId);
	    $urlOptions = array();
	}

	$link['href'] = $urlGenerator->generateUrl($urlParams, $urlOptions);

	return $link;
    }

    /**
     * Returns the id of item that corresponds to the parent of the given path.
     * The item at the given path doesn't have to exist, but its parent is expected to exist.
     *
     * @param string $path, e.g. /foo/bar
     * @return array object GalleryStatus a status code,
     *               int the id of the parent item
     */
    function getParentItemIdByPath($path) {
	$parentPath = dirname($path);

	/* dirname('foo') is '.' and \ for dirname ('/foo') on Windows */
	if (in_array($parentPath, array('.', '\\'))) {
	    list ($ret, $parentId) =
		    GalleryCoreApi::getPluginParameter('module', 'core', 'id.rootAlbum');
	    if ($ret) {
		return array($ret, null);
	    }
	} else {
	    list ($ret, $parentId) = GalleryCoreApi::fetchItemIdByPath($parentPath);
	    if ($ret) {
		return array($ret, null);
	    }
	}

	return array(null, (int)$parentId);
    }

    /**
     * Take two entities of possibly different classes and make the second entity as close a copy of
     * the first entity as possible.  Copy the id but not the entity type because the entity type
     * must always match the class name.
     * @param object GalleryEntity $sourceEntity entity to copy from
     * @param object GalleryEntity $mirrorEntity entity to copy to
     * @return array object GalleryStatus a status code
     *               object GalleryEntity the mirror entity
     */
    function mirrorEntity($sourceEntity, $mirrorEntity) {
	$className = $mirrorClassName = $mirrorEntity->getClassName();
	list ($ret, $entityInfo) = GalleryCoreApi::describeEntity($className);
	if ($ret) {
	    return array($ret, null);
	}

	list ($ret, $memberAccessInfo) =
	    GalleryCoreApi::getExternalAccessMemberList($className);
	if ($ret) {
	    return array($ret, null);
	}
	/* We need to override id and pathComponent */
	$override = array('id', 'pathComponent');

	/*
	 * Walk down the mirror entity's class hierarchy copying class members from the source
	 * entity if they are defined
	 */
	while (!empty($className)) {
	    foreach ($entityInfo[$className]['members'] as $memberName => $memberInfo) {
		if (isset($sourceEntity->$memberName)
			&& (!empty($memberAccessInfo[$memberName]['write'])
			    || in_array($memberName, $override))) {
		    $mirrorEntity->$memberName = $sourceEntity->$memberName;
		}
	    }

	    $className = $entityInfo[$className]['parent'];
	}

	/*
	 * Reset the entity type to the mirror entity's class name because the entity type must
	 * always match the class name
	 */
	$mirrorEntity->entityType = $mirrorClassName;

	return array(null, $mirrorEntity);
    }

    /**
     * Get singleton WebDAV server library instance.
     *
     * If it didn't need path and baseUrl, we could eliminate and call library methods staticly.
     *
     * @return object WebDavServer instance
     */
    function &getWebDavServer() {
	static $webDavServer;
	if (!isset($webDavServer)) {
	    global $gallery;
	    $urlGenerator =& $gallery->getUrlGenerator();

	    $webDavServer = new WebDavServer();

	    /*
	     * Needed by HTTP_WebDAV_Server::copymove_request_helper and
	     * HTTP_WebDAV_Server::_check_if_header_conditions
	     */
	    $path = GalleryUtilities::getRequestVariables('path');
	    $path = trim($path, '/');

	    $webDavServer->path = $path;
	    $webDavServer->baseUrl = parse_url($urlGenerator->generateUrl(
		array('controller' => 'webdav.WebDav'),
		array('forceFullUrl' => true,
		      'htmlEntities' => false,
		      'forceSessionId' => false,
		      'useAuthToken' => false)));
	}

	return $webDavServer;
    }

    /**
     * Get active WebDAV locks at specified path.
     * @param string $path
     * @param boolean $getDescendentsLocks (optional) also get locks at any descendant path
     * @return array object GalleryStatus a status code
     *               array active WebDAV locks (scope, type, depth, owner, expires, token, path)
     */
    function getLocks($path, $getDescendentsLocks=false) {
	global $gallery;

	/* We haven't done any database calls yet, so GallerySqlFragment isn't defined */
	GalleryCoreApi::requireOnce('modules/core/classes/GalleryStorage.class');

	/* Remove stale locks */
	$ret = GalleryCoreApi::removeMapEntry('WebDavLockMap',
	    array('expires' => new GallerySqlFragment('< ?', time())));
	if ($ret) {
	    return array($ret, null);
	}

	$data = array();
	$query = '
	    SELECT
	      [WebDavLockMap::depth],
	      [WebDavLockMap::owner],
	      [WebDavLockMap::expires],
	      [WebDavLockMap::token],
	      [WebDavLockMap::path]
	    FROM
	      [WebDavLockMap]
	    WHERE';

	/*
	 * Hacks to get ancestors' and descendants' locks will disappear with MPTT -
	 * http://codex.gallery2.org/index.php/Gallery2:Modified_Preorder_Tree_Traversal
	 */
	if ($getDescendentsLocks) {
	    $data[] = "$path%";
	    $query .= '
		  [WebDavLockMap::path] LIKE ?';
	} else {
	    $data[] = $path;
	    $query .= '
		  [WebDavLockMap::path] = ?';
	}

	$pathComponents = explode('/', $path);
	$count = 0;

	/* Get ancestors' locks */
	while (array_pop($pathComponents) !== null) {
	    $data[] = implode('/', $pathComponents);
	    $count++;
	}

	if ($count) {
	    $query .= '
		OR
		  ([WebDavLockMap::path] IN (' . GalleryUtilities::makeMarkers($count)
		  . ') AND [WebDavLockMap::depth] = \'infinity\')';
	}

	list ($ret, $results) = $gallery->search($query, $data);
	if ($ret) {
	    return array($ret, null);
	}

	$locks = array();
	while (($result = $results->nextResult()) !== false) {
	    $locks[] = array('scope' => 'exclusive',
		'type' => 'write',
		'depth' => $result[0],
		'owner' => $result[1],
		'expires' => (int)$result[2],
		'token' => $result[3],
		'path' => $result[4]);
	}

	return array(null, $locks);
    }

    /**
     * Get active locks at specified path or any descendant path.
     * @see WebDavHelper::getLocks
     */
    function getDescendentsLocks($path) {
	return WebDavHelper::getLocks($path, true);
    }

    /**
     * Check if there are no active locks at the specified path, or the request matches the token of
     * the active lock.
     * @param string $path
     * @return boolean no active locks or the request matches the active lock
     */
    function checkLocks($path) {
	$webDavServer =& WebDavHelper::getWebDavServer();

        list ($ret, $locks) = WebDavHelper::getLocks($path);
	if ($ret) {
	    return $ret;
	}

	if (!empty($locks) && !$webDavServer->check_locks_helper($locks, $path)) {
	    WebDavServer::setResponseStatus('423 Locked');
	    return GalleryCoreApi::error(ERROR_LOCK_IN_USE);
	}
    }

    /**
     * OPTIONS handler.
     * @see HTTP_WebDAV_Server::options
     */
    function options() {
	/* TODO: COPY not implemented */
	GalleryUtilities::setResponseHeader(
	    'Allow: OPTIONS,PROPFIND,PROPPATCH,MKCOL,GET,HEAD,DELETE,PUT,MOVE,LOCK,UNLOCK');
	GalleryUtilities::setResponseHeader('DAV: 1,2');
	GalleryUtilities::setResponseHeader('Content-Length: 0');
	GalleryUtilities::setResponseHeader('MS-Author-Via: DAV');
    }

    /**
     * PROPFIND request helper.
     *
     * Wrapper around HTTP_WebDAV_Server::propfind_request_helper which prepares data-structures
     * from PROPFIND requests.
     *
     * @return array object GalleryStatus a status code
     *               array WebDAV library options
     *               int maximum depth of descendant paths
     * @see HTTP_WebDAV_Server::propfind_request_helper
     */
    function propfindRequestHelper() {
	$webDavServer =& WebDavHelper::getWebDavServer();

	if (!$webDavServer->propfind_request_helper($webDavOptions)) {
	    /* WebDAV library found error in the request */
	    return array(GalleryCoreApi::error(ERROR_UNKNOWN), null, null);
	}

	return array(null, $webDavOptions, $webDavOptions['depth']);
    }

    /**
     * PROPFIND response helper.
     *
     * Wrapper around HTTP_WebDAV_Server::propfind_response_helper which formats PROPFIND responses.
     *
     * @param array $webDavOptions WebDAV library options
     * @param array $files files for WebDAV response (path, props)
     * @param array $namespaces namespaces for WebDAV response (URI => prefix)
     * @see HTTP_WebDAV_Server::propfind_response_helper
     */
    function propfindResponseHelper($webDavOptions, $files, $namespaces) {
	$webDavServer =& WebDavHelper::getWebDavServer();
	$webDavOptions['namespaces'] = $namespaces;
	$webDavServer->propfind_response_helper($webDavOptions, $files);
    }

    /**
     * PROPFIND handler.
     * @return object GalleryStatus status code
     */
    function propfind() {
	/* Prepare data-structure from PROPFIND request */
	list ($ret, $webDavOptions, $depth) = WebDavHelper::propfindRequestHelper();
	if ($ret) {
	    return $ret;
	}

	$path = GalleryUtilities::getRequestVariables('path');
	$path = trim($path, '/');

	if (empty($path)) {
	    list ($ret, $itemId) = GalleryCoreApi::getDefaultAlbumId();
	    if ($ret) {
		return $ret;
	    }
	} else {
	    list ($ret, $itemId) = GalleryCoreApi::fetchItemIdByPath($path);
	    if ($ret) {
		return $ret;
	    }
	}

	list ($ret, $item) = GalleryCoreApi::loadEntitiesById($itemId);
	if ($ret) {
	    return $ret;
	}

	$files = array();
	$ret = WebDavHelper::_propfindFiles($item, $path, $depth, $files);
	if ($ret) {
	    return $ret;
	}

	$namespaces = array(WEBDAV_GALLERY_NAMESPACE => 'G');

	/* Format PROPFIND response */
	$ret = WebDavHelper::propfindResponseHelper($webDavOptions, $files, $namespaces);
	if ($ret) {
	    return $ret;
	}
    }

    /**
     * PROPFIND recursive function.
     *
     * Builds file arrays (path, props) from items until depth is exhausted.
     *
     * Could be done iteratively, but waiting for MPTT for the ultimate solution -
     * http://codex.gallery2.org/index.php/Gallery2:Modified_Preorder_Tree_Traversal
     *
     * @param object GalleryItem $item
     * @param string $path
     * @param int $depth maximum depth of descendant paths
     * @param array $files files for WebDAV response (path, props)
     * @return object GalleryStatus a status code
     * @access private
     */
    function _propfindFiles($item, $path, $depth, &$files) {
	/* Verify that the provided object implements the required methods */
	foreach (array('creationTimestamp', 'title', 'modificationTimestamp',
		'pathComponent') as $memberName) {
	    if (!method_exists($item, 'get' . $memberName)) {
		return GalleryCoreApi::error(ERROR_BAD_PARAMETER, __FILE__, __LINE__,
			"Item object does not implement a getter for '$memberName'");
	    }
	}

	$file = array('path' => $path, 'props' => array());

	/* Build standard DAV: properties */
	$file['props'][] = WebDavServer::mkprop('creationdate', $item->getCreationTimestamp());
	$displayName = $item->getTitle();
	if (empty($displayName)) {
	    $displayName = $item->getPathComponent();
	}
	$file['props'][] = WebDavServer::mkprop('displayname', $displayName);
	$file['props'][] =
		WebDavServer::mkprop('getlastmodified', $item->getModificationTimestamp());

	/*
	 * Support exclusive write locks.
	 *
	 * Any DAV compliant resource that supports the LOCK method MUST support the supportedlock
	 * property.
	 */
	$file['props'][] = WebDavServer::mkprop(
	    'supportedlock',
	    array(array('scope' => 'exclusive', 'type' => 'write')));

	/*
	 * WebDavHelper::getLocks is potentially expensive.  Could optimize this if we knew
	 * $webDavOptions['props'] didn't contain 'lockdiscovery' or 'allprop'.
	 */
	list ($ret, $locks) = WebDavHelper::getLocks($path);
	if ($ret) {
	    return $ret;
	}

	$file['props'][] = WebDavServer::mkprop('lockdiscovery', $locks);

	if (GalleryUtilities::isA($item, 'GalleryAlbumItem')) {
	    if (!empty($path)) {
		$file['path'] = "$path/";
	    }

	    $file['props'][] = WebDavServer::mkprop('getcontentlength', 0);
	    $file['props'][] = WebDavServer::mkprop('getcontenttype', 'httpd/unix-directory');
	    $file['props'][] = WebDavServer::mkprop('resourcetype', 'collection');
	} else {
	    $size = 0;
	    if (method_exists($item, 'getSize')) {
		$size = $item->getSize();
	    }
	    $mimeType = 'application/unknown';
	    if (method_exists($item, 'getMimeType')) {
		$mimeType = $item->getMimeType();
	    }
	    $file['props'][] = WebDavServer::mkprop('getcontentlength', $size);
	    $file['props'][] = WebDavServer::mkprop('getcontenttype', $mimeType);
	    $file['props'][] = WebDavServer::mkprop('resourcetype', null);
	}

	/* Build Gallery properties */
	if (method_exists($item, 'getClassName')) {
	    list ($ret, $memberInfo) =
		GalleryCoreApi::getExternalAccessMemberList($item->getClassName());
	    if ($ret) {
		return $ret;
	    }

	    /* Keep track of the properties that we add to prevent repetition */
	    $defaultMembers = array('pathComponent', 'creationTimestamp', 'title',
				    'modificationTimestamp', 'mimeType', 'size');
	    foreach ($memberInfo as $memberName => $accessInfo) {
		$getter = 'get' . $memberName;
		/* Only show properties that are not intended for internal use only */
		if ($accessInfo['read'] && !in_array($memberName, $defaultMembers)
			&& method_exists($item, $getter)) {
		    $value = $item->$getter();
		    /* Ignore array valued properties */
		    if (!is_array($value) && !is_object($value)) {
			$file['props'][] = WebDavServer::mkprop(WEBDAV_GALLERY_NAMESPACE,
								$memberName, $value);
		    }
		}
	    }
	}

	$files[] = $file;

	if ($depth <= 0) {
	    return null;
	}

	list ($ret, $childIds) = GalleryCoreApi::fetchChildItemIds($item);
	if ($ret) {
	    return $ret;
	}

	if (empty($childIds)) {
	    return null;
	}

	list ($ret, $childItems) = GalleryCoreApi::loadEntitiesById($childIds);
	if ($ret) {
	    return $ret;
	}

	foreach ($childItems as $childItem) {
	    /* Could we simply use something like $childItem->fetchLogicalPath? */
	    $childPath = $childItem->getPathComponent();
	    if (!empty($path)) {
		$childPath = "$path/" . $childPath;
	    }

	    $ret = WebDavHelper::_propfindFiles($childItem, $childPath, $depth - 1, $files);
	    if ($ret) {
		return $ret;
	    }
	}

	return null;
    }

    /**
     * PROPPATCH request helper.
     *
     * Wrapper around HTTP_WebDAV_Server::proppatch_request_helper which prepares data-structures
     * from PROPPATCH requests.
     *
     * @return array object GalleryStatus a status code
     *               array WebDAV library options
     *               array properties to set (ns => namespace, name => name, val => value)
     * @see HTTP_WebDAV_Server::proppatch_request_helper
     */
    function proppatchRequestHelper() {
	$webDavServer =& WebDavHelper::getWebDavServer();

	if (!$webDavServer->proppatch_request_helper($webDavOptions)) {
	    /* WebDAV library found error in the request */
	    return array(GalleryCoreApi::error(ERROR_UNKNOWN), null, null);
	}

	return array(null, $webDavOptions, $webDavOptions['props']);
    }

    /**
     * PROPPATCH response helper.
     *
     * Wrapper around HTTP_WebDAV_Server::proppatch_response_helper which formats PROPPATCH
     * responses.
     *
     * @param array $webDavOptions WebDAV library options
     * @param string $path
     * @param array $props properties set (ns => namespace,
     					   name => name,
					   val => value,
					   status => status)
     * @param array $namespace namespaces for WebDAV response (URI => prefix)
     * @see HTTP_WebDAV_Server::proppatch_response_helper
     */
    function proppatchResponseHelper($webDavOptions, $path, $props, $namespaces) {
	$webDavServer =& WebDavHelper::getWebDavServer();
	$webDavOptions['path'] = $path;
	$webDavOptions['props'] = $props;
	$webDavOptions['namespaces'] = $namespaces;
	$webDavServer->proppatch_response_helper($webDavOptions);
    }

    /**
     * PROPPATCH handler.
     * @return object GalleryStatus a status code
     */
    function proppatch() {
	$path = GalleryUtilities::getRequestVariables('path');
	$path = trim($path, '/');

	/* Check resource is not locked */
	$ret = WebDavHelper::checkLocks($path);
	if ($ret) {
	    return $ret;
	}

	if (empty($path)) {
	    list ($ret, $itemId) = GalleryCoreApi::getDefaultAlbumId();
	    if ($ret) {
		return $ret;
	    }
	} else {
	    list ($ret, $itemId) = GalleryCoreApi::fetchItemIdByPath($path);
	    if ($ret) {
		return $ret;
	    }
	}

	list ($ret, $item) = GalleryCoreApi::loadEntitiesById($itemId);
	if ($ret) {
	    return $ret;
	}

	/* Prepare data-structure from PROPPATCH request */
	list ($ret, $webDavOptions, $props) = WebDavHelper::proppatchRequestHelper();
	if ($ret) {
	    return $ret;
	}

	list ($ret, $lockId) = GalleryCoreApi::acquireWriteLock($itemId);
	if ($ret) {
	    return $ret;
	}

	$ret = WebDavHelper::_setItemProps($item, $props);
	if ($ret) {
	    return $ret;
	}

	if ($item->isModified()) {
	    $ret = $item->save();
	    if ($ret) {
		GalleryCoreApi::releaseLocks($lockId);
		return $ret;
	    }
	}

	$ret = GalleryCoreApi::releaseLocks($lockId);
	if ($ret) {
	    return $ret;
	}

	$namespaces = array(WEBDAV_GALLERY_NAMESPACE => 'G');

	/* Format PROPPATCH response */
	$ret = WebDavHelper::proppatchResponseHelper($webDavOptions, $path, $props, $namespaces);
	if ($ret) {
	    return $ret;
	}

	return null;
    }

    /**
     * Set item properties
     * @param object GalleryItem reference $item
     * @param array reference $propos DAV file properties
     * @return object GalleryStatus a status code
     */
    function _setItemProps(&$item, &$props) {
	if (!method_exists($item, 'getClassName')) {
	    return GalleryCoreApi::error(ERROR_BAD_PARAMETER);
	}

	list ($ret, $memberInfo) =
		GalleryCoreApi::getExternalAccessMemberList($item->getClassName());
	if ($ret) {
	    return $ret;
	}

	foreach ($props as $key => $prop) {
	    $name = $prop['name'];
	    if ($prop['ns'] == 'DAV:') {
		if ($prop['name'] == 'displayname') {
		    $name = 'title';
		    /* Want to support any other DAV: properties? */
		} else {
		    $props[$key]['status'] = '403 Forbidden';
		    continue;
		}
	    } else if ($prop['ns'] != WEBDAV_GALLERY_NAMESPACE) {
		$props[$key]['status'] = '403 Forbidden';
		continue;
	    }

	    $setter = 'set' . $name;
	    if (!isset($memberInfo[$name])|| !$memberInfo[$name]['write']
		    || !method_exists($item, $setter)) {
		$props[$key]['status'] = '403 Forbidden';
		continue;
	    }

	    $item->$setter($prop['value']);
	}
	return null;
    }

    /**
     * Validate MKCOL requests.
     *
     * Copied from ItemAddAlbumController::handleRequest for consistancy.  Maybe eventually should
     * go in ItemAddAlbumController::validateRequest or a GalleryCoreApi method.
     *
     * @param int $parentId id of parent album
     * @param string $pathComponent path component of new album
     * @return array object GalleryStatus a status code
     *               array error strings
     * @see ItemAddAlbumController::handleRequest
     */
    function mkcolValidateHelper($parentId, $pathComponent) {
	global $gallery;
	$platform =& $gallery->getPlatform();

	$error = array();

	/* Make sure we have permission do edit this item */
	$ret = GalleryCoreApi::assertHasItemPermission($parentId, 'core.addAlbumItem');
	if ($ret) {
	    return array($ret, null);
	}

	if (empty($pathComponent)) {
	    $error[] = 'form[error][pathComponent][missing]';
	} else if (!$platform->isLegalPathComponent($pathComponent)) {
	    $error[] = 'form[error][pathComponent][invalid]';
	}

	return array(null, $error);
    }

    /**
     * MKCOL helper.
     *
     * Acquire locks, create album and set permissions.
     *
     * Copied from ItemAddAlbumController::handleRequest for consistancy.  Maybe eventually should
     * go in ItemAddAlbumController::requestHelper or a GalleryCoreApi method.
     *
     * @param int $parentId id of parent album
     * @param string $pathComponent path component of new album
     * @param string $title title of new album
     * @param string $summary summary of new album
     * @param string $description description of new album
     * @param array $keywords keywords of new album
     * @return object GalleryStatus a status code
     * @see ItemAddAlbumController::handleRequest
     */
    function mkcolHelper($parentId, $pathComponent, $title, $summary, $description, $keywords) {
	list ($ret, $lockIds[]) = GalleryCoreApi::acquireReadLock($parentId);
	if ($ret) {
	    return $ret;
	}

	list ($ret, $albumItem) = GalleryCoreApi::createAlbum($parentId, $pathComponent,
	    $title, $summary, $description, $keywords);
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return $ret;
	}

	if (!isset($albumItem)) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return GalleryCoreApi::error(ERROR_MISSING_OBJECT);
	}

	$ret = GalleryCoreApi::addUserPermission($albumItem->getId(), $albumItem->getOwnerId(),
	    'core.all', false);
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return $ret;
	}

	$ret = GalleryCoreApi::releaseLocks($lockIds);
	if ($ret) {
	    return $ret;
	}
    }

    /**
     * MKCOL handler.
     * @return object GalleryStatus a status code
     */
    function mkcol() {
	/* Body parsing not yet supported */
	if (GalleryUtilities::getServerVar('CONTENT_LENGTH')) {
	    /*
	     * 415 (Unsupported Media Type) - The server does not support the request type of the
	     * body.
	     */
	    WebDavServer::setResponseStatus('415 Unsupported Media Type');
	    return GalleryCoreApi::error(ERROR_BAD_PARAMETER);
	}

	$path = GalleryUtilities::getRequestVariables('path');
	$path = trim($path, '/');

	list ($ret, $itemId) = GalleryCoreApi::fetchItemIdByPath($path);
	if ($ret && !($ret->getErrorCode() & ERROR_MISSING_OBJECT)) {
	    return $ret;
	}
	if (!$ret) {
	    /*
	     * 405 (Method Not Allowed) - MKCOL can only be executed on a deleted/non-existent
	     * resource.
	     */
	    WebDavServer::setResponseStatus('405 Method Not Allowed');
	    return GalleryCoreApi::error(ERROR_COLLISION);
	}

	$pathComponent = basename($path);

	list ($ret, $parentId) = WebDavHelper::getParentItemIdByPath($path);
	if ($ret) {
	    if ($ret->getErrorCode() & ERROR_MISSING_OBJECT) {
		/*
		 * 409 (Conflict) - A resource cannot be created at the destination until one or
		 * more intermediate collections have been created.
		 */
		WebDavServer::setResponseStatus('409 Conflict');
	    }
	    return $ret;
	}

	list ($ret, $error) = WebDavHelper::mkcolValidateHelper($parentId, $pathComponent);
	if ($ret) {
	    return $ret;
	}

	if (!empty($error)) {
	    foreach ($error as $error) {
		if (!strpos($error, 'permission')) {
		    return GalleryCoreApi::error(ERROR_BAD_PARAMETER);
		}
	    }

	    /* If all errors were permission denied return more specific error */
	    return GalleryCoreApi::error(ERROR_PERMISSION_DENIED);
	}

	$originalPath = GalleryUtilities::getRequestVariables('originalPath');
	$title = empty($originalPath) ? $pathComponent : basename($originalPath);
	$ret = WebDavHelper::mkcolHelper($parentId, $pathComponent, $title, '', '', '');
	if ($ret) {
	    if ($ret->getErrorCode() & ERROR_ILLEGAL_CHILD) {

		/*
		 * 403 (Forbidden) - This indicates at least one of two conditions: 1) the server
		 * does not allow the creation of collections at the given location in its
		 * namespace, or 2) the parent collection of the Request-URI exists but cannot
		 * accept members.
		 */
		WebDavServer::setResponseStatus('403 Forbidden');
	    }

	    return $ret;
	}

	/*
	 * 201 (Created) - The collection or structured resource was created in its entirety.
	 */
	WebDavServer::setResponseStatus('201 Created');
    }

    /**
     * DELETE helper.
     *
     * For an array of item ids, delete the items if not the root album and the user has permission.
     *
     * Copied from ItemDeleteController::handleRequest for consistancy.  Maybe eventually should go
     * in ItemDeleteController::requestHelper or a GalleryCoreApi method.
     *
     * @param array $itemIds ids of items to delete
     * @return array object GalleryStatus a status code
     *               int number of items deleted
     * @see ItemDeleteController::handleRequest
     */
    function deleteHelper($itemIds) {
        if (!is_array($itemIds)) {
	    $itemIds = array($itemIds);
	}

	/* Get the rootId, so we don't try to delete it */
	list ($ret, $rootId) = GalleryCoreApi::getDefaultAlbumId();
	if ($ret) {
	    return array($ret, null);
	}

	$ret = GalleryCoreApi::studyPermissions($itemIds);
	if ($ret) {
	    return array($ret, null);
	}

	foreach ($itemIds as $itemId) {
	    /* Make sure we have permission to delete this item */
	    list ($ret, $permissions) = GalleryCoreApi::getPermissions($itemId);
	    if ($ret) {
		return array($ret, null);
	    }

	    if (!isset($permissions['core.delete'])) {
		return array(GalleryCoreApi::error(ERROR_PERMISSION_DENIED, __FILE__, __LINE__,
		    "Don't have permission to delete this item"), null);
	    }

	    /* Make sure we're not deleting the root album */
	    if ($itemId == $rootId) {
		return array(GalleryCoreApi::error(ERROR_BAD_PARAMETER, __FILE__, __LINE__,
		    "Can't delete the root album"), null);
	    }
	}

	/* If we're still here then all are deletable */
	$count = 0;
	foreach ($itemIds as $itemId) {
	    $ret = GalleryCoreApi::deleteEntityById($itemId);
	    if ($ret) {
		return array($ret, null);
	    }

	    $count++;
	}

	return array(null, $count);
    }

    /**
     * DELETE handler.
     * @return object GalleryStatus a status code
     */
    function delete() {
	/* RFC2518 9.2 last paragraph */
	if (GalleryUtilities::getServerVar('HTTP_DEPTH') != null
		&& GalleryUtilities::getServerVar('HTTP_DEPTH') != 'infinity') {
	    WebDavServer::setResponseStatus('400 Bad Request');
	    return GalleryCoreApi::error(ERROR_BAD_PARAMETER);
	}

	$path = GalleryUtilities::getRequestVariables('path');
	$path = trim($path, '/');

	/* Check resource is not locked */
	$ret = WebDavHelper::checkLocks($path);
	if ($ret) {
	    return $ret;
	}

	if (empty($path)) {
	    list ($ret, $itemId) = GalleryCoreApi::getPluginParameter('module', 'core',
		'id.rootAlbum');
	    if ($ret) {
		return $ret;
	    }
	} else {
	    list ($ret, $itemId) = GalleryCoreApi::fetchItemIdByPath($path);
	    if ($ret) {
		return $ret;
	    }
	}

	list ($ret, $item) = GalleryCoreApi::loadEntitiesById($itemId);
	if ($ret) {
	    return $ret;
	}

	list ($ret, $count) = WebDavHelper::deleteHelper($itemId);
	if ($ret) {
	    return $ret;
	}

	/* What do we do if we weren't successful?  No thumbnail, I guess. */
	list ($ret, $success) = GalleryCoreApi::guaranteeAlbumHasThumbnail($item->getParentId());
	if ($ret) {
	    return $ret;
	}

	WebDavServer::setResponseStatus('204 No Content');
	return null;
    }

    /**
     * PUT request helper.
     *
     * Wrapper around HTTP_WebDAV_Server::put_request_helper which prepares data-structures from PUT
     * requests.
     *
     * @return array object GalleryStatus a status code
     *               array WebDAV library options
     *               resource request body file handle
     *               string request content type
     * @see HTTP_WebDAV_Server::put_request_helper
     */
    function putRequestHelper() {
	$webDavServer =& WebDavHelper::getWebDavServer();

	if (!$webDavServer->put_request_helper($webDavOptions)) {
	    /* WebDAV library found error in the request */
	    return array(GalleryCoreApi::error(ERROR_UNKNOWN), null, null, null);
	}

	return array(null, $webDavOptions,
		     $webDavOptions['stream'],
		     $webDavOptions['content_type']);
    }

    /**
     * PUT response helper.
     *
     * Wrapper around HTTP_WebDAV_Server::put_response_helper which formats PUT responses.
     *
     * @param array $webDavOptions WebDAV library options
     * @param resource $stream destination file handle
     * @see HTTP_WebDAV_Server::put_response_helper
     */
    function putResponseHelper($webDavOptions, $stream) {
	$webDavServer =& WebDavHelper::getWebDavServer();
	$webDavOptions['new'] = false;
	$webDavServer->put_response_helper($webDavOptions, $stream);
    }

    /**
     * COPY / MOVE request helper.
     *
     * Wrapper around HTTP_WebDAV_Server::copymove_request_helper which prepates data-structures
     * from COPY / MOVE requests.
     *
     * @return array object GalleryStatus a status code
     *               array WebDAV library options
     *               int maximum depth of descendant paths
     *               boolean overwrite items at destination path
     *               string destination path
     * @see HTTP_WebDAV_Server::copymove_request_helper
     */
    function copyMoveRequestHelper() {
	global $gallery;
	$platform =& $gallery->getPlatform();
	$webDavServer =& WebDavHelper::getWebDavServer();

	/* Body parsing not yet supported */
	if (GalleryUtilities::getServerVar('CONTENT_LENGTH')) {
	    /*
	     * 415 (Unsupported Media Type) - The server does not support the request type of the
	     * body.
	     */
	    WebDavServer::setResponseStatus('415 Unsupported Media Type');
	    return array(GalleryCoreApi::error(ERROR_BAD_PARAMETER), null, null, null, null);
	}

	if (!$webDavServer->copymove_request_helper($webDavOptions)) {
	    /* WebDAV library found error in the request */
	    return array(GalleryCoreApi::error(ERROR_UNKNOWN), null, null, null, null);
	}

	/* Copying to remote servers not yet supported */
	if (isset($webDavOptions['dest_url'])) {
	    /*
	     * 502 (Bad Gateway) - This may occur when the destination is on another server and the
	     * destination server refuses to accept the resource.
	     */
	    WebDavServer::setResponseStatus('502 Bad Gateway');
	    return array(GalleryCoreApi::error(ERROR_BAD_PARAMETER), null, null, null, null);
	}

	/* Check destination is legal */
	$pathComponent = basename($webDavOptions['dest']);
	if (!$platform->isLegalPathComponent($pathComponent)) {
	    WebDavServer::setResponseStatus('403 Forbidden');
	    return array(GalleryCoreApi::error(ERROR_BAD_PATH), null, null, null, null);
	}

	return array(null, $webDavOptions,
		     $webDavOptions['depth'],
		     $webDavOptions['overwrite'],
		     $webDavOptions['dest']);
    }

    /**
     * Validate MOVE requests.
     *
     * Copied from ItemMoveController::handleRequest for consistancy.  Maybe eventually should go in
     * ItemMoveController::validateRequest or a GalleryCoreApi method.
     *
     * @param array $items items to move
     * @param object GalleryAlbumItem $newParent
     * @return array object GalleryStatus a status code
     *               array error strings
     * @see ItemMoveController::handleRequest
     */
    function moveValidateHelper($items, $newParent) {
        if (!is_array($items)) {
	    $items = array($items);
	}

	$error = array();

	if (empty($newParent)) {
	    $error[] = 'form[error][destination][empty]';
	}

	if (!empty($newParent)) {
	    $newParentId = $newParent->getId();

	    list ($ret, $permissions) = GalleryCoreApi::getPermissions($newParentId);
	    if ($ret) {
		return array($ret, null);
	    }

	    $canAddItem = isset($permissions['core.addDataItem']);
	    $canAddAlbum = isset($permissions['core.addAlbumItem']);
	    if (!$canAddAlbum && !$canAddItem) {
		$error[] = 'form[error][destination][permission]';
	    }

	    if (!GalleryUtilities::isA($newParent, 'GalleryAlbumItem')) {
		/* The view should never let this happen */
		return array(GalleryCoreApi::error(ERROR_BAD_DATA_TYPE), null);
	    }

	    /* Load destination parent ids: We don't want recursive moves */
	    list ($ret, $newParentAncestorIds) = GalleryCoreApi::fetchParentSequence($newParentId);
	    if ($ret) {
		return array($ret, null);
	    }
	    $newParentAncestorIds[] = $newParentId;
	}

	foreach ($items as $item) {
	    $itemId = $item->getId();

	    if (!empty($newParent)) {

		/* Can't move into a tree that is included in the source */
		if (in_array($itemId, $newParentAncestorIds)) {
		    $error[] = 'form[error][source][' . $itemId . '][selfMove]';
		    continue;
		}
	    }

	    list ($ret, $permissions) = GalleryCoreApi::getPermissions($itemId);
	    if ($ret) {
		return array($ret, null);
	    }

	    /* Can we delete this item from here? */
	    if (!isset($permissions['core.delete'])) {
		$error[] = 'form[error][source][' . $itemId . '][permission][delete]';
	    }

	    if (!empty($newParent)) {

		/* Check if the destination allows this source to be added */
		if (GalleryUtilities::isA($item, 'GalleryDataItem')) {
		    if (!$canAddItem) {
			$error[] = 'form[error][source][' . $itemId . '][permission][addDataItem]';
		    }
		} else if (GalleryUtilities::isA($item, 'GalleryAlbumItem')) {
		    if (!$canAddAlbum) {
			$error[] = 'form[error][source][' . $itemId . '][permission][addAlbumItem]';
		    }
		} else {

		    /* The view should never let this happen */
		    return array(GalleryCoreApi::error(ERROR_BAD_DATA_TYPE), null);
		}
	    }
	}

	return array(null, $error);
    }

    /**
     * MOVE handler.
     *
     * Rename an item, change its parent, or both.
     *
     * @return object GalleryStatus a status code
     */
    function move() {
	$path = GalleryUtilities::getRequestVariables('path');
	$path = trim($path, '/');

	/* Check source is not locked */
	$ret = WebDavHelper::checkLocks($path);
	if ($ret) {
	    return $ret;
	}

	/* Validate before deleting a conflicting item */
	list ($ret, $itemId) = GalleryCoreApi::fetchItemIdByPath($path);
	if ($ret) {
	    return $ret;
	}

	list ($ret, $rootId) = GalleryCoreApi::getPluginParameter('module', 'core', 'id.rootAlbum');
	if ($ret) {
	    return $ret;
	}
	if ($itemId == $rootId) {
	    return GalleryCoreApi::error(ERROR_BAD_PARAMETER);
	}

	list ($ret, $item) = GalleryCoreApi::loadEntitiesById($itemId);
	if ($ret) {
	    return $ret;
	}

	/* Prepare data-structure from MOVE request */
	list ($ret, $webDavOptions, $depth, $overwrite, $newPath) =
	    WebDavHelper::copyMoveRequestHelper();
	if ($ret) {
	    return $ret;
	}

	/* Check destination is not locked */
	$ret = WebDavHelper::checkLocks($newPath);
	if ($ret) {
	    return $ret;
	}

	if (GalleryUtilities::isA($item, 'GalleryAlbumItem') && $depth != 'infinity') {
	    /*
	     * The MOVE method on a collection MUST act as if a "Depth: infinity" header was used on
	     * it.  A client MUST NOT submit a Depth header on a MOVE on a collection with any value
	     * but "infinity".
	     */
	    WebDavServer::setResponseStatus('400 Bad Request');
	    return GalleryCoreApi::error(ERROR_BAD_PARAMETER);
	}

	list ($ret, $newParentId) = WebDavHelper::getParentItemIdByPath($newPath);
	if ($ret) {
	    if ($ret->getErrorCode() & ERROR_MISSING_OBJECT) {
		/*
		 * 409 (Conflict) - A resource cannot be created at the destination until
		 * one or more intermediate collections have been created.
		 */
		WebDavServer::setResponseStatus('409 Conflict');
	    }
	    return $ret;
	}

	list ($ret, $newParent) = GalleryCoreApi::loadEntitiesById($newParentId);
	if ($ret) {
	    return $ret;
	}

	$pathComponent = basename($path);
	$newPathComponent = basename($newPath);
	$oldParentId = $item->getParentId();

	if ($oldParentId != $newParentId) {
	    list ($ret, $error) = WebDavHelper::moveValidateHelper($item, $newParent);
	    if ($ret) {
		return $ret;
	    }
	    if (!empty($error)) {
		foreach ($error as $error) {
		    if (!strpos($error, 'permission')) {
			return GalleryCoreApi::error(ERROR_BAD_PARAMETER);
		    }
		}

		/* If all errors were permission denied return more specific error */
		return GalleryCoreApi::error(ERROR_PERMISSION_DENIED);
	    }
	}

	list ($ret, $conflictingItemId) = GalleryCoreApi::fetchItemIdByPath($newPath);
	if ($ret && !($ret->getErrorCode() & ERROR_MISSING_OBJECT)) {
	    return $ret;
	}
	if (!$ret) {
	    if (!$overwrite) {
		/*
		 * 412 (Precondition Failed) - The server was unable to maintain the liveness of the
		 * properties listed in the propertybehavior XML element or the Overwrite header is
		 * "F" and the state of the destination resource is non-null.
		 */
		WebDavServer::setResponseStatus('412 Precondition Failed');
		return GalleryCoreApi::error(ERROR_COLLISION);
	    }

	    list ($ret, $count) = WebDavHelper::deleteHelper($conflictingItemId);
	    if ($ret) {
		return $ret;
	    }
	}

	if ($oldParentId != $newParentId) {
	    /*
	     * Read lock both parent hierarchies
	     * TODO Optimize this
	     */
	    list ($ret, $lockIds[]) = GalleryCoreApi::acquireReadLockParents($newParentId);
	    if ($ret) {
		return $ret;
	    }

	    list ($ret, $lockIds[]) = GalleryCoreApi::acquireReadLockParents($oldParentId);
	    if ($ret) {
		GalleryCoreApi::releaseLocks($lockIds);
		return $ret;
	    }

	    list ($ret, $lockIds[]) =
		GalleryCoreApi::acquireReadLock(array($newParentId, $oldParentId));
	    if ($ret) {
		GalleryCoreApi::releaseLocks($lockIds);
		return $ret;
	    }
	}

	/* Write lock the item we're moving */
	list ($ret, $lockIds[]) = GalleryCoreApi::acquireWriteLock($itemId);
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return $ret;
	}

	/* Refresh the item in case it changed before it was locked */
	list ($ret, $item) = $item->refresh();
	if ($ret) {
	    GalleryCoreApi::releaseLocks($lockIds);
	    return $ret;
	}

	/* Try renaming first - if it fails it's easier to undo */
	if ($newPathComponent != $pathComponent) {
	    $ret = $item->rename($newPathComponent);
	    if ($ret) {
		GalleryCoreApi::releaseLocks($lockIds);
		return $ret;
	    }
	}

	if ($newParentId != $oldParentId) {
	    /* Do the move */
	    $ret = $item->move($newParentId);
	    if ($ret) {
		if ($newPathComponent != $pathComponent) {
		    $item->rename($pathComponent);
		    /* Ignore cascading failures here */
		}

		GalleryCoreApi::releaseLocks($lockIds);
		return $ret;
	    }
	}

	$ret = $item->save();
	if ($ret) {
	    if ($newPathComponent != $pathComponent) {
		$ret = $item->rename($pathComponent);
		/* Ignore cascading failures here */
	    }

	    GalleryCoreApi::releaseLocks($lockIds);
	    return $ret;
	}

	if ($newParentId != $oldParentId) {
	    if (GalleryUtilities::isA($item, 'GalleryDataItem')) {
		/* Update for derivative preferences of new parent */
		$ret = GalleryCoreApi::addExistingItemToAlbum($item, $newParentId);
		if ($ret) {
		    GalleryCoreApi::releaseLocks($lockIds);
		    return $ret;
		}
	    }
	}

	/* Release all locks */
	$ret = GalleryCoreApi::releaseLocks($lockIds);
	if ($ret) {
	    return $ret;
	}

	/* Fix thumbnail integrity */
	if ($newParentId != $oldParentId) {
	    /* What do we do if we weren't successful?  No thumbnail, I guess. */
	    list ($ret, $success) = GalleryCoreApi::guaranteeAlbumHasThumbnail($oldParentId);
	    if ($ret) {
		return $ret;
	    }
	}

	/* If an item was overwritten fix thumbnail integrity */
	if (empty($count)) {
	    /*
	     * 201 (Created) - The source resource was successfully copied.  The copy operation
	     * resulted in the creation of a new resource.
	     */
	    WebDavServer::setResponseStatus('201 Created');
	    return null;
	}

	/* In case we only renamed the item */
	if (empty($newParentId)) {
	    $newParentId = $item->getParentId();
	}

	/* What do we do if we weren't successful?  No thumbnail, I guess. */
	list ($ret, $success) = GalleryCoreApi::guaranteeAlbumHasThumbnail($newParentId);
	if ($ret) {
	    return $ret;
	}

	/*
	 * 204 (No Content) - The source resource was successfully copied to a pre-existing
	 * destination resource.
	 */
	WebDavServer::setResponseStatus('204 No Content');
	return null;
    }

    /**
     * LOCK request helper.
     *
     * Wrapper around HTTP_WebDAV_Server::lock_request_helper which prepares data-structures from
     * LOCK reqeusts.
     *
     * @return array object GalleryStatus a status code
     *               array WebDAV library options
     *               string token of WebDAV lock to refresh or null
     *               string scope of WebDAV lock (exclusive or shared)
     *               string type of WebDAV lock (read or write)
     *               int maximum depth of descendant paths
     *               string owner of WebDAV lock
     *               int timeout of WebDAV lock
     *               string token of WebDAV lock to create
     * @see HTTP_WebDAV_Server::lock_request_helper
     * @todo Simplify function signature
     */
    function lockRequestHelper() {
	$webDavServer =& WebDavHelper::getWebDavServer();

	if (!$webDavServer->lock_request_helper($webDavOptions)) {
	    /* WebDAV library found error in the request */
	    return array(GalleryCoreApi::error(ERROR_UNKNOWN),
			 null, null, null, null, null, null, null, null);
	}

	if (isset($webDavOptions['update'])) {
	    return array(null, $webDavOptions,
	    		 $webDavOptions['update'], null, null, null, null, null, null);
	}

	return array(null, $webDavOptions,
		     null,
		     $webDavOptions['scope'],
		     $webDavOptions['type'],
		     $webDavOptions['depth'],
		     $webDavOptions['owner'],
		     $webDavOptions['timeout'],
		     $webDavOptions['token']);
    }

    /**
     * LOCK response helper.
     *
     * Wrapper around HTTP_WebDAV_Server::lock_response_helper which formates LOCK responses.
     *
     * @param array $webDavOptions WebDAV library options
     * @param array $locks for response (path)
     * @param mixed $status HTTP response status
     * @param string $scope of WebDAV lock (exclusive or shared)
     * @param string $type of WebDAV lock (read or write)
     * @param int $depth maximum depth of descendant paths
     * @param string $owner of WebDAV lock
     * @param int $timeout of WebDAV lock
     * @param int $expires timestamp of WebDAV lock expiration
     * @param string $token of WebDAV lock
     * @see HTTP_WebDAV_Server::lock_response_helper
     * @todo Simplify function signature
     */
    function lockResponseHelper(
	    $webDavOptions, $locks, $status, $scope, $type, $depth, $owner, $expires, $token) {
	$webDavServer =& WebDavHelper::getWebDavServer();
	$webDavOptions['locks'] = $locks;
	$webDavOptions['scope'] = $scope;
	$webDavOptions['type'] = $type;
	$webDavOptions['depth'] = $depth;
	$webDavOptions['owner'] = $owner;
	$webDavOptions['expires'] = $expires;
	$webDavOptions['token'] = $token;
	$webDavServer->lock_response_helper($webDavOptions, $status);
    }

    /**
     * LOCK handler.
     *
     * WebDAV locks persist between requests.
     *
     * @return object GalleryStatus a status code
     * @todo Make corresponding Gallery locks persist between requests
     */
    function lock() {
	global $gallery;

	$path = GalleryUtilities::getRequestVariables('path');
	$path = trim($path, '/');

	/* Check resource is not locked */
	$ret = WebDavHelper::checkLocks($path);
	if ($ret) {
	    return $ret;
	}

	/* Prepare data-structure from LOCK request */
	list ($ret, $webDavOptions, $update, $scope, $type, $depth, $owner, $timeout, $token) =
	    WebDavHelper::lockRequestHelper();
	if ($ret) {
	    return $ret;
	}

	if (empty($path)) {
	    list ($ret, $itemId) = GalleryCoreApi::getDefaultAlbumId();
	    if ($ret) {
		return $ret;
	    }
	} else {
	    list ($ret, $itemId) = GalleryCoreApi::fetchItemIdByPath($path);
	    if ($ret) {
		return $ret;
	    }
	}

	/* Refresh lock */
	if (!empty($update)) {
	    /* Don't join with the Gallery lock table since we might be using flock system */
	    $query = '
		SELECT
		  [WebDavLockMap::depth],
		  [WebDavLockMap::owner],
		  [WebDavLockMap::galleryLockId]
		FROM
		  [WebDavLockMap]
		WHERE
		  [WebDavLockMap::path] = ?
		AND
		  [WebDavLockMap::token] = ?';
	    list ($ret, $results) = $gallery->search($query, array($path, $update));
	    if ($ret) {
		return $ret;
	    }

	    /* Tried to refresh a lock which no longer exists */
	    if (($result = $results->nextResult()) === false) {
		/*
		 * 412 (Precondition Failed) - The included lock token was not enforceable on this
		 * resource or the server could not satisfy the request in the lockinfo XML element.
		 */
		WebDavServer::setResponseStatus('412 Precondition Failed');
		return GalleryCoreApi::error(ERROR_BAD_PARAMETER);
	    }

	    /* Load WebDAV lock information */
	    $scope = 'exclusive';
	    $type = 'write';
	    $depth = $result[0];
	    $owner = $result[1];
	    $lockId = $result[2];

	    /* Check that the Gallery lock didn't disappear before the WebDAV lock */
	    if (GalleryCoreApi::isWriteLocked($itemId)) {
		/* TODO: Need an interface to update g_freshUntil for only $lockId */
	    } else {
		list ($ret, $lockId) = GalleryCoreApi::acquireWriteLock($itemId);
		if ($ret) {
		    return $ret;
		}
	    }
	} else {
	    /* Support only exclusive write locks */
	    if ($scope != 'exclusive' || $type != 'write') {
		/*
		 * 412 (Precondition Failed) - The included lock token was not enforceable on this
		 * resource or the server could not satisfy the request in the lockinfo XML element.
		 */
		WebDavServer::setResponseStatus('412 Precondition Failed');
		return GalleryCoreApi::error(ERROR_BAD_PARAMETER);
	    }

	    if ($depth == 'infinity') {
		list ($ret, $locks) = WebDavHelper::getDescendentsLocks($path);
		if ($ret) {
		    return $ret;
		}

		if (!empty($locks)) {
		    /* Format LOCK response */
		    return WebDavHelper::lockResponseHelper(
			$webDavOptions, $locks, null, null, null, null, null, null, null);
		}
	    }

	    list ($ret, $lockId) = GalleryCoreApi::acquireWriteLock($itemId);
	    if ($ret) {
		return $ret;
	    }
	}

	/* Use Gallery lock freshUntil for WebDAV lock timeout */
	$query = '
	    SELECT
	      [Lock::freshUntil]
	    FROM
	      [Lock]
	    WHERE
	      [Lock::lockId] = ?';
	list ($ret, $results) = $gallery->search($query, array($lockId));
	if ($ret) {
	    return $ret;
	}

	if (($result = $results->nextResult()) !== false) {
	    $expires = $result[0];
	} else {
	    /*
	     * Might be using flock system
	     * TODO: Get expires from flock locks
	    return GalleryCoreApi::error(ERROR_MISSING_VALUE);
	     */
	    $expires = time() + 30;
	}

	/* Refresh lock */
	if (!empty($update)) {
	    $ret = GalleryCoreApi::updateMapEntry('WebDavLockMap',
		array('token' => $update, 'path' => $path),
		array('expires' => $expires, 'galleryLockId' => $lockId));
	    if ($ret) {
		return $ret;
	    }
	} else {
	    $ret = GalleryCoreApi::addMapEntry('WebDavLockMap', array('depth' => $depth,
		'owner' => $owner,
		'expires' => $expires,
		'token' => $token,
		'path' => $path,
		'galleryLockId' => $lockId));
	    if ($ret) {
		return $ret;
	    }
	}

	/* Format LOCK response */
	$ret = WebDavHelper::lockResponseHelper(
	    $webDavOptions, null, true, $scope, $type, $depth, $owner, $expires, $token);
	if ($ret) {
	    return $ret;
	}
    }

    /**
     * UNLOCK request helper.
     *
     * Wrapper around HTTP_WebDAV_Server::unlock_request_helper wich prepares data-structures from
     * UNLOCK requests.
     *
     * @return array object GalleryStatus a status code
     *               array WebDAV library options
     *               string token of WebDAV lock to clear
     * @see HTTP_WebDAV_Server::unlock_request_helper
     */
    function unlockRequestHelper() {
	$webDavServer =& WebDavHelper::getWebDavServer();

	if (!$webDavServer->unlock_request_helper($webDavOptions)) {
	    /* WebDAV library found error in the request */
	    return array(GalleryCoreApi::error(ERROR_UNKNOWN), null, null);
	}

	return array(null, $webDavOptions, $webDavOptions['token']);
    }

    /**
     * UNLOCK handler.
     * @return object GalleryStatus a status code
     */
    function unlock() {
	global $gallery;

	/* Prepare data-structure from UNLOCK request */
	list ($ret, $webDavOptions, $token) = WebDavHelper::unlockRequestHelper();
	if ($ret) {
	    return $ret;
	}

	$path = GalleryUtilities::getRequestVariables('path');
	$path = trim($path, '/');

	$query = '
	    SELECT
	      [WebDavLockMap::galleryLockId]
	    FROM
	      [WebDavLockMap]
	    WHERE
	      [WebDavLockMap::path] = ?
	    AND
	      [WebDavLockMap::token] = ?';
	list ($ret, $results) = $gallery->search($query, array($path, $token));
	if ($ret) {
	    return $ret;
	}

	if (($result = $results->nextResult()) === false) {
	    return GalleryCoreApi::error(ERROR_MISSING_VALUE);
	}
	$lockId = $result[0];

	$ret = GalleryCoreApi::releaseLocks($lockId);
	if ($ret) {
	    return $ret;
	}

	$ret = GalleryCoreApi::removeMapEntry(
	    'WebDavLockMap', array('token' => $token, 'path' => $path));
	if ($ret) {
	    return $ret;
	}

	/*
	 * The 204 (No Content) status code is used instead of 200 (OK) because there is no response
	 * entity body.
	 */
	WebDavServer::setResponseStatus('204 No Content');
	return null;
    }
}

/**
 * Sub-class of HTTP_WebDAV_Server which overrides getHref, openRequestBody, setResponseHeader and
 * setResponseStatus.  getHref uses the URL generator.  openRequestBody uses the platform, for
 * testability.  setResponseHeader and setResponseStatus use GalleryUtilities::setResponseHeader to
 * avoid response headers being replaced elsewhere in Gallery and for testability, since
 * GalleryUtilities::setResponseHeader uses $phpVm->header.
 */
class WebDavServer extends HTTP_WebDAV_Server {

    /**
     * @see HTTP_WebDAV_Server::getHref
     */
    function getHref($path) {
	global $gallery;
	$urlGenerator =& $gallery->getUrlGenerator();

	return $urlGenerator->generateUrl(
	    array('controller' => 'webdav.WebDav', 'path' => $path),
	    array('forceServerRelativeUrl' => true,
		  'forceSessionId' => false,
		  'useAuthToken' => false));
    }

    /**
     * @see HTTP_WebDAV_Server::openRequestBody
     */
    function openRequestBody() {
	global $gallery;
	$platform =& $gallery->getPlatform();

	return $platform->fopen('php://input', 'rb');
    }

    /**
     * @see HTTP_WebDAV_Server::setResponseHeader
     */
    function setResponseHeader($header, $replace=true) {
	GalleryUtilities::setResponseHeader($header, $replace);
    }

    /**
     * @see HTTP_WebDAV_Server::setResponseStatus
     */
    function setResponseStatus($status, $replace=true) {
	GalleryUtilities::setResponseHeader("HTTP/1.0 $status", $replace);
    }
}
?>
');
expand_6421a0d81d($outputDir, 'classes/WebDavRewriteHelper.class', 'PD9waHAKLyoKICogR2FsbGVyeSAtIGEgd2ViIGJhc2VkIHBob3RvIGFsYnVtIHZpZXdlciBhbmQgZWRpdG9yCiAqIENvcHlyaWdodCAoQykgMjAwMC0yMDA3IEJoYXJhdCBNZWRpcmF0dGEKICoKICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0CiAqIHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAogKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCiAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEsIFVTQS4KICovCgovKioKICogQSBXZWJEQVYgaGVscGVyIGNsYXNzIGZvciBnZW5lcmF0aW5nIHNob3J0IFVSTHMgd2l0aG91dCBxdWVyeSBzdHJpbmdzLgogKiBAcGFja2FnZSBXZWJEYXYKICogQHN1YnBhY2thZ2UgQ2xhc3NlcwogKiBAYXV0aG9yIEphY2sgQmF0ZXMgPG1zNDE5QGZyZWV6b25lLmNvLnVrPgogKiBAdmVyc2lvbiAkUmV2aXNpb246IDE1NTEzICQKICogQHN0YXRpYwogKi8KY2xhc3MgV2ViRGF2UmV3cml0ZUhlbHBlciB7CgogICAgLyoqCiAgICAgKiBIYWNrZWQgdmVyc2lvbiBvZiBSZXdyaXRlU2ltcGxlSGVscGVyOjpwYXJzZXJQYXRoIHRvIHN1cHBvcnQgZWl0aGVyICdwYXRoJyBvciAnaXRlbUlkJyBhbmQKICAgICAqIGVtcHR5IHBhdGggb3IgJy8nIGZvciBzaG9ydCBVUkwgdG8gdGhlIHJvb3QgYWxidW0uICBVc2VzIHJhd3VybGVuY29kZSBpbnN0ZWFkIG9mIHVybGVuY29kZSB0bwogICAgICogZW5jb2RlICcgJyBhcyAnJTIwJywgaW5zdGVhZCBvZiAnKycuCiAgICAgKiBAc2VlIFJld3JpdGVTaW1wbGVIZWxwZXI6OnBhcnNlUGF0aAogICAgICovCiAgICBmdW5jdGlvbiBwYXJzZVBhdGgoJiR1cmwsICYkcGFyYW1zLCAmJGVudGl0eSkgewoJZ2xvYmFsICRnYWxsZXJ5OwoKCWlmIChpc3NldCgkcGFyYW1zWydpdGVtSWQnXSkpIHsKCSAgICBpZiAoIWlzc2V0KCRlbnRpdHkpKSB7CgkJJHVybEdlbmVyYXRvciA9JiAkZ2FsbGVyeS0+Z2V0VXJsR2VuZXJhdG9yKCk7CgkJJGVudGl0eSA9ICR1cmxHZW5lcmF0b3ItPmxvYWRFbnRpdHkoJHBhcmFtc1snaXRlbUlkJ10pOwoJICAgIH0KCgkgICAgaWYgKCFHYWxsZXJ5VXRpbGl0aWVzOjppc0EoJGVudGl0eSwgJ0dhbGxlcnlGaWxlU3lzdGVtRW50aXR5JykpIHsKCQlyZXR1cm47CgkgICAgfQoKCSAgICBsaXN0ICgkcmV0LCAkcGFyYW1zWydwYXRoJ10pID0gJGVudGl0eS0+ZmV0Y2hMb2dpY2FsUGF0aCgpOwoJICAgIGlmICgkcmV0KSB7CgkJcmV0dXJuOwoJICAgIH0KCgkgICAgdW5zZXQoJHBhcmFtc1snaXRlbUlkJ10pOwoJfQoKCWlmIChlbXB0eSgkcGFyYW1zWydwYXRoJ10pKSB7CgkgICAgJHBhcmFtc1sncGF0aCddID0gJyc7Cgl9IGVsc2UgewoJICAgICRwYXJhbXNbJ3BhdGgnXSA9IGx0cmltKCRwYXJhbXNbJ3BhdGgnXSwgJy8nKTsKCgkgICAgLyogcmF3dXJsZW5jb2RlIGV4Y2VwdCBmb3IgcGF0aCBzZXBhcmF0b3JzICovCgkgICAgJHBhcmFtc1sncGF0aCddID0gc3RyX3JlcGxhY2UoJyUyRicsICcvJywgcmF3dXJsZW5jb2RlKCRwYXJhbXNbJ3BhdGgnXSkpOwoJfQoKCS8qCgkgKiBXZSBhZGQgaW4gYSBsZWFkaW5nIHNsYXNoIHRvIHRoZSBwYXRoIGJlY2F1c2UgdGhlIHJ1bGUgaXMgZGVzaWduZWQgbm90IHRvIGhhdmUKCSAqIG9uZSwgc28gdGhhdCBpdCBjYW4gdHJpZ2dlciBvbiBnYWxsZXJ5Mi93LyBhbmQgZ2FsbGVyeTIvdyAoV2luZG93cyBYUCB3aWxsCgkgKiBQUk9QRklORCB0aGUgcGF0aCB3aXRob3V0IHRoZSB0cmFpbGluZyBzbGFzaAoJICovCgkkdXJsID0gc3RyX3JlcGxhY2UoJyVwYXRoJScsICcvJyAuICRwYXJhbXNbJ3BhdGgnXSwgJHVybCk7Cgl1bnNldCgkcGFyYW1zWydwYXRoJ10pOwoKCXJldHVybiB0cnVlOwogICAgfQp9Cj8+Cg==');
expand_6421a0d81d($outputDir, 'data/options/.htaccess', 'IyBUaGUgV2ViREFWIHNwZWMsIFJGQzI1MTgsIHByb21pc2VzIHRoZSBEQVYgaGVhZGVyIG9uIGFsbCBPUFRJT05TIHJlc3BvbnNlczoKIwojICAgICBUaGlzIGhlYWRlciBpbmRpY2F0ZXMgdGhhdCB0aGUgcmVzb3VyY2Ugc3VwcG9ydHMgdGhlIERBViBzY2hlbWEgYW5kCiMgICAgIHByb3RvY29sIGFzIHNwZWNpZmllZC4gQWxsIERBViBjb21wbGlhbnQgcmVzb3VyY2VzIE1VU1QgcmV0dXJuIHRoZQojICAgICBEQVYgaGVhZGVyIG9uIGFsbCBPUFRJT05TIHJlc3BvbnNlcy4KIwojIFNvbWUgV2ViREFWIGNsaWVudHMsIGUuZy4gTWFjIE9TIFggV2ViREFWRlMsIGZhaWwgdG8gY29ubmVjdCBpZiB0aGlzIGhlYWRlcgojIGlzIG1pc3NpbmcuICBUaGUgV2ViREFWIG1vZHVsZSB3aWxsIHJldHVybiB0aGUgREFWIGhlYWRlciBvbiBhbGwgcmVzcG9uc2VzLAojIGJ1dCBzb21lIHNlcnZlciBjb25maWd1cmF0aW9ucyBkb24ndCBwYXNzIE9QVElPTlMgcmVxdWVzdHMgdG8gc2NyaXB0cywgZS5nLgojIEFwYWNoZSBkb2Vzbid0IHBhc3MgT1BUSU9OUyByZXF1ZXN0cyB0byBDR0kgc2NyaXB0czoKIyBodHRwOi8vaXNzdWVzLmFwYWNoZS5vcmcvYnVnemlsbGEvc2hvd19idWcuY2dpP2lkPTM3OTgyCiMKIyBDb25zZXF1ZW50bHksIHNvbWUgV2ViREFWIGNsaWVudHMgd2lsbCB3b3JrIHdpdGggbW9kX3BocCwgYnV0IG5vdCBwaHAtY2dpLgojCiMgQWx0ZXJuYXRpdmVseSwgd2UgY2FuIHNldCB0aGUgREFWIGhlYWRlciB1c2luZyBtb2RfcmV3cml0ZSBhbmQgbW9kX2hlYWRlcnMuCiMgVGhlIEhlYWRlciBzdGF0ZW1lbnQgZG9lc24ndCBiZWxvbmcgaW4gZ2FsbGVyeTIvLmh0YWNjZXNzLCBpdCBiZWxvbmdzIGluIHRoZQojIGRpcmVjdG9yeSBvZiB0aGUgaW50ZXJwcmV0ZXIsIGkuZS4gcGhwLWNnaS4KIwojIFRvIGF2b2lkIGVkaXRpbmcgL3Vzci9saWIvY2dpLWJpbi8uaHRhY2Nlc3Mgd2UgY2FuIHVzZSB0aGUgVVJMIHJld3JpdGUgbW9kdWxlCiMgdG8gcmVkaXJlY3QgT1BUSU9OUyByZXF1ZXN0cyB0byB0aGlzIGRpcmVjdG9yeS4KIwojIFJlaW1wbGVtZW50YXRpb24gb2YgV2ViRGF2SGVscGVyOjpvcHRpb25zIHVzaW5nIG1vZF9oZWFkZXJzLgojCiMgVE9ETzogQ09QWSBub3QgaW1wbGVtZW50ZWQuCjxJZk1vZHVsZSBtb2RfaGVhZGVycy5jPgogICAgSGVhZGVyIHNldCBBbGxvdyBPUFRJT05TLFBST1BGSU5ELFBST1BQQVRDSCxNS0NPTCxHRVQsSEVBRCxERUxFVEUsUFVULE1PVkUsTE9DSyxVTkxPQ0sKICAgIEhlYWRlciBzZXQgREFWIDEsMgogICAgSGVhZGVyIHNldCBNUy1BdXRob3ItVmlhIERBVgo8L0lmTW9kdWxlPgo=');
expand_6421a0d81d($outputDir, 'lib/HTTP/WebDAV/Server.php', '<?php
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Hartmut Holzgraefe <hholzgra@php.net>                       |
// |          Christian Stocker <chregu@bitflux.ch>                       |
// +----------------------------------------------------------------------+
//
// $Id: Server.php 15729 2007-01-27 05:53:15Z andy_st $

require_once(dirname(__FILE__) . '/Tools/_parse_propfind.php');
require_once(dirname(__FILE__) . '/Tools/_parse_proppatch.php');
require_once(dirname(__FILE__) . '/Tools/_parse_lockinfo.php');

define('HTTP_WEBDAV_SERVER_DATATYPE_NAMESPACE',
    'urn:uuid:c2f41010-65b3-11d1-a29f-00aa00c14882');

/**
 * Virtual base class for implementing WebDAV servers
 *
 * WebDAV server base class, needs to be extended to do useful work
 *
 * @package HTTP_WebDAV_Server
 * @author Hartmut Holzgraefe <hholzgra@php.net>
 * @version 0.99.1dev
 */
class HTTP_WebDAV_Server
{
    // {{{ Member Variables

    /**
     * URL path for this request
     *
     * @var string
     */
    var $path;

    /**
     * Base URL for this request
     *
     * See PHP parse_url structure
     *
     * @var array
     */
    var $baseUrl;

    /**
     * Realm string to be used in authentification popups
     *
     * @var string
     */
    var $http_auth_realm = 'PHP WebDAV';

    /**
     * String to be used in "X-Dav-Powered-By" header
     *
     * @var string
     */
    var $dav_powered_by = '';

    /**
     * Remember parsed If: (RFC2518 9.4) header conditions
     *
     * @var array
     */
    var $_if_header_uris = array();

    /**
     * HTTP response headers
     *
     * @var array
     */
    var $headers = array();

    /**
     * Encoding of property values passed in
     *
     * @var string
     */
    var $_prop_encoding = 'utf-8';

    // }}}

    // {{{ handleRequest

    /**
     * Handle WebDAV request
     *
     * Dispatch WebDAV request to the apropriate method wrapper
     *
     * @param void
     * @return void
     */
    function handleRequest()
    {
        // identify ourselves
        if (empty($this->dav_powered_by)) {
            $this->dav_powered_by = 'PHP class: ' . get_class($this);
        }
        $this->setResponseHeader('X-Dav-Powered-By: ' . $this->dav_powered_by);

        // set path
        if (empty($this->path)) {
            $this->path = $this->_urldecode($_SERVER['PATH_INFO']);
            $this->path = trim($this->path, '/');
        }

        if (ini_get('magic_quotes_gpc')) {
            $this->path = stripslashes($this->path);
        }

        // set base URL
        if (empty($this->baseUrl)) {
            $this->baseUrl = parse_url(
                "http://$_SERVER[HTTP_HOST]$_SERVER[REQUEST_URI]");
            $this->baseUrl['path'] = substr($this->baseUrl['path'], 0,
                strlen($this->baseUrl['path']) - strlen($_SERVER['PATH_INFO']));
        }

        // check authentication
        if (!$this->check_auth_wrapper()) {

            // RFC2518 says we must use Digest instead of Basic but Microsoft
            // clients do not support Digest and we don't support NTLM or
            // Kerberos so we are stuck with Basic here
            $this->setResponseHeader('WWW-Authenticate: Basic realm="'
                . $this->http_auth_realm . '"');

            // Windows seems to require this being the last header sent
            // (changed according to PECL bug #3138)
            $this->setResponseStatus('401 Authentication Required');
            return;
        }

        // check
        if (!$this->_check_if_header_conditions()) {
            $this->setResponseStatus('412 Precondition Failed');
            return;
        }

        // detect requested method names
        $method = strtolower($_SERVER['REQUEST_METHOD']);
        $wrapper = $method . '_wrapper';

        // emulate HEAD using GET if no HEAD method found
        if ($wrapper == 'head_wrapper' &&
                !method_exists($this, 'head')) {
            $method = 'get';
        }

        if (method_exists($this, $method) &&
                method_exists($this, $wrapper) ||
                $method == 'options') {
            $this->$wrapper();
            return;
        }

        // method not found/implemented
        if ($method == 'lock') {
            $this->setResponseStatus('412 Precondition Failed');
            return;
        }

        // tell client what's allowed
        $this->setResponseStatus('405 Method Not Allowed');
        $this->setResponseHeader('Allow: ' . implode(', ', $this->_allow()));
    }

    // }}}

    // {{{ abstract WebDAV methods

    // {{{ PROPFIND

    /**
     * PROPFIND implementation
     *
     * @abstract
     * @param array &$params
     * @returns int HTTP-Statuscode
     */

    /* abstract
       function propfind()
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // {{{ PROPPATCH

    /**
     * PROPPATCH implementation
     *
     * @abstract
     * @param array &$params
     * @returns int HTTP-Statuscode
     */

    /* abstract
       function proppatch()
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // {{{ MKCOL

    /**
     * MKCOL implementation
     *
     * @abstract
     * @param array &$params
     * @returns int HTTP-Statuscode
     */

    /* abstract
       function mkcol()
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // {{{ GET

    /**
     * GET implementation
     *
     * Overload this method to retrieve resources from your server
     *
     * @abstract
     * @param array &$params array of input and output parameters
     * <br><b>input</b><ul>
     * <li> path -
     * </ul>
     * <br><b>output</b><ul>
     * <li> size -
     * </ul>
     * @returns int HTTP-Statuscode
     */

    /* abstract
       function get()
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // {{{ DELETE

    /**
     * DELETE implementation
     *
     * @abstract
     * @param array &$params
     * @returns int HTTP-Statuscode
     */

    /* abstract
       function delete()
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // {{{ PUT

    /**
     * PUT implementation
     *
     * @abstract
     * @param array &$params
     * @returns int HTTP-Statuscode
     */

    /* abstract
       function put()
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // {{{ COPY

    /**
     * COPY implementation
     *
     * @abstract
     * @param array &$params
     * @returns int HTTP-Statuscode
     */

    /* abstract
       function copy()
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // {{{ MOVE

    /**
     * MOVE implementation
     *
     * @abstract
     * @param array &$params
     * @returns int HTTP-Statuscode
     */

    /* abstract
       function move()
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // {{{ LOCK

    /**
     * LOCK implementation
     *
     * @abstract
     * @param array &$params
     * @returns int HTTP-Statuscode
     */

    /* abstract
       function lock()
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // {{{ UNLOCK

    /**
     * UNLOCK implementation
     *
     * @abstract
     * @param array &$params
     * @returns int HTTP-Statuscode
     */

    /* abstract
       function unlock()
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // }}}

    // {{{ other abstract methods

    // {{{ checkAuth

    /**
     * Check authentication
     *
     * Overload this method to retrieve and confirm authentication information
     *
     * @abstract
     * @param string type Authentication type, e.g. "basic" or "digest"
     * @param string username Transmitted username
     * @param string passwort Transmitted password
     * @returns bool Authentication status
     */

    /* abstract
       function checkAuth($type, $username, $password)
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // {{{ getLocks

    /**
     * Get lock entries for a resource
     *
     * Overload this method to return shared and exclusive locks active for
     * this resource
     *
     * @abstract
     * @param string resource path to check
     * @returns array of lock entries each consisting
     *                of 'type' ('shared'/'exclusive'), 'token' and 'timeout'
     */

    /* abstract
       function getLocks($path)
       {
           // dummy entry for PHPDoc
       }
    */

    // }}}

    // }}}

    // {{{ WebDAV HTTP method wrappers

    // {{{ options

    /**
     * OPTIONS method handler
     *
     * The OPTIONS method handler creates a valid OPTIONS reply including Dav:
     * and Allowed: heaers based on the implemented methods found in the actual
     * instance
     *
     * @param void
     * @return void
     */
    function options()
    {
        // get allowed methods
        $allow = $this->_allow();

        // dav header
        $dav = array(1); // assume we are always dav class 1 compliant
        if (in_array('LOCK', $allow) && in_array('UNLOCK', $allow)) {
            $dav[] = 2; // dav class 2 requires that locking is supported
        }

        // tell clients what we found
        $this->setResponseHeader('Allow: ' . implode(', ', $allow));
        $this->setResponseHeader('DAV: ' . implode(',', $dav));
        $this->setResponseHeader('Content-Length: 0');

        // Microsoft clients default to the Frontpage protocol unless we tell
        // them to use WebDAV
        $this->setResponseHeader('MS-Author-Via: DAV');

        $this->setResponseStatus('200 OK');
    }

    // }}}

    // {{{ propfind_request_helper

    /**
     * PROPFIND request helper - prepares data-structures from PROPFIND requests
     *
     * @param options
     * @return void
     */
    function propfind_request_helper(&$options)
    {
        $options = array();
        $options['path'] = $this->path;

        // get depth from header (default is 'infinity')
        $options['depth'] = 'infinity';
        if (!empty($_SERVER['HTTP_DEPTH'])) {
            $options['depth'] = $_SERVER['HTTP_DEPTH'];
        }

        // analyze request payload
        $parser = new _parse_propfind($this->openRequestBody());
        if (!$parser->success) {
            $this->setResponseStatus('400 Bad Request');
            return;
        }

        $options['props'] = $parser->props;

        return true;
    }

    // }}}

    // {{{ propfind_response_helper

    /**
     * PROPFIND response helper - format PROPFIND response
     *
     * @param options
     * @param files
     * @return void
     */
    function propfind_response_helper($options, $files)
    {
        $responses = array();

        // now loop over all returned files
        foreach ($files as $file) {
            $response = array();

            if (empty($file['href'])) {
                $response['href'] = $this->getHref($file['path']);
            } else {
                $response['href'] = $file['href'];
            }

            $response['propstat'] = array();

            // collect namespaces here
            $response['namespaces'] = array();
            if (!empty($options['namespaces'])) {
                $response['namespaces'] = $options['namespaces'];
            }

            // Microsoft needs this special namespace for date and time values
            $response['namespaces'][HTTP_WEBDAV_SERVER_DATATYPE_NAMESPACE] =
                'ns' . count($response['namespaces']);

            if (is_array($options['props'])) {

                // loop over all requested properties
                foreach ($options['props'] as $reqprop) {
                    $status = '200 OK';
                    $prop = $this->getProp($reqprop, $file, $options);

                    if (!empty($prop['status'])) {
                        $status = $prop['status'];
                    }

                    if (empty($response['propstat'][$status])) {
                        $response['propstat'][$status] = array();
                    }

                    $response['propstat'][$status][] = $prop;

                    // namespace handling
                    if (empty($prop['ns']) || // empty namespace
                            $prop['ns'] == 'DAV:' || // default namespace
                            !empty($response['namespaces'][$prop['ns']])) { // already known
                        continue;
                    }

                    // register namespace
                    $response['namespaces'][$prop['ns']] = 'ns' . count($response['namespaces']);
                }
            } else if (is_array($file['props'])) {

                // loop over all returned properties
                foreach ($file['props'] as $prop) {
                    $status = '200 OK';

                    if (!empty($prop['status'])) {
                        $status = $prop['status'];
                    }

                    if (empty($response['propstat'][$status])) {
                        $response['propstat'][$status] = array();
                    }

                    if ($options['props'] == 'propname') {

                        // only names of all existing properties were requested
                        // so remove values
                        unset($prop['value']);
                    }

                    $response['propstat'][$status][] = $prop;
                        unset($prop['value']);

                    // namespace handling
                    if (empty($prop['ns']) || // empty namespace
                            $prop['ns'] == 'DAV:' || // default namespace
                            !empty($response['namespaces'][$prop['ns']])) { // already known
                        continue;
                    }

                    // register namespace
                    $response['namespaces'][$prop['ns']] = 'ns' . count($response['namespaces']);
                }
            }

            $responses[] = $response;
        }

        $this->_multistatusResponseHelper($responses);
    }

    // }}}

    // {{{ propfind_wrapper

    /**
     * PROPFIND method wrapper
     *
     * @param void
     * @return void
     */
    function propfind_wrapper()
    {
        // prepare data-structure from PROPFIND request
        if (!$this->propfind_request_helper($options)) {
            return;
        }

        // call user handler
        if (!$this->propfind($options, $files)) {
            return;
        }

        // format PROPFIND response
        $this->propfind_response_helper($options, $files);
    }

    // }}}

    // {{{ proppatch_request_helper

    /**
     * PROPPATCH request helper - prepares data-structures from PROPPATCH requests
     *
     * @param options
     * @return void
     */
    function proppatch_request_helper(&$options)
    {
        $options = array();
        $options['path'] = $this->path;

        $propinfo = new _parse_proppatch($this->openRequestBody());

        if (!$propinfo->success) {
            $this->setResponseStatus('400 Bad Request');
            return;
        }

        $options['props'] = $propinfo->props;

        return true;
    }

    // }}}

    // {{{ proppatch_response_helper

    /**
     * PROPPATCH response helper - format PROPPATCH response
     *
     * @param options
     * @param responsedescr
     * @return void
     */
    function proppatch_response_helper($options, $responsedescription=null)
    {
        $response = array();

        if (empty($options['href'])) {
            $response['href'] = $this->getHref($options['path']);
        } else {
            $response['href'] = $options['href'];
        }

        $response['propstat'] = array();

        // collect namespaces here
        $response['namespaces'] = array();
        if (!empty($options['namespaces'])) {
            $response['namespaces'] = $options['namespaces'];
        }

        if (!empty($options['props']) && is_array($options['props'])) {
            foreach ($options['props'] as $prop) {
                $status = '200 OK';
                if (!empty($prop['status'])) {
                    $status = $prop['status'];
                }

                if (empty($response['propstat'][$status])) {
                    $response['propstat'][$status] = array();
                }

                $response['propstat'][$status][] = $prop;

                // namespace handling
                if (empty($prop['ns']) || // empty namespace
                        $prop['ns'] == 'DAV:' || // default namespace
                        !empty($response['namespaces'][$prop['ns']])) { // already known
                    continue;
                }

                // register namespace
                $response['namespaces'][$prop['ns']] = 'ns' . count($response['namespaces']);
            }
        }

        $response['responsedescription'] = $responsedescription;

        $this->_multistatusResponseHelper(array($response));
    }

    // }}}

    // {{{ proppatch_wrapper

    /**
     * PROPPATCH method wrapper
     *
     * @param void
     * @return void
     */
    function proppatch_wrapper()
    {
        // check resource is not locked
        if (!$this->check_locks_wrapper($this->path)) {
            $this->setResponseStatus('423 Locked');
            return;
        }

        // perpare data-structure from PROPATCH request
        if (!$this->proppatch_request_helper($options)) {
            return;
        }

        // call user handler
        $responsedescription = $this->proppatch($options);

        // format PROPPATCH response
        $this->proppatch_response_helper($options, $responsedescription);
    }

    // }}}

    // {{{ mkcol_wrapper

    /**
     * MKCOL method wrapper
     *
     * @param void
     * @return void
     */
    function mkcol_wrapper()
    {
        $options = array();
        $options['path'] = $this->path;

        $status = $this->mkcol($options);

        $this->setResponseStatus($status);
    }

    // }}}

    // {{{ get_request_helper

    /**
     * GET request helper - prepares data-structures from GET requests
     *
     * @param options
     * @return void
     */
    function get_request_helper(&$options)
    {
        // TODO check for invalid stream

        $options = array();
        $options['path'] = $this->path;

        $this->_get_ranges($options);

        return true;
    }

    /**
     * Parse HTTP Range: header
     *
     * @param  array options array to store result in
     * @return void
     */
    function _get_ranges(&$options)
    {
        // process Range: header if present
        if (!empty($_SERVER['HTTP_RANGE'])) {

            // we only support standard 'bytes' range specifications for now
            if (ereg('bytes[[:space:]]*=[[:space:]]*(.+)', $_SERVER['HTTP_RANGE'], $matches)) {
                $options['ranges'] = array();

                // ranges are comma separated
                foreach (explode(',', $matches[1]) as $range) {
                    // ranges are either from-to pairs or just end positions
                    list($start, $end) = explode('-', $range);
                    $options['ranges'][] = ($start === '') ? array('last' => $end) : array('start' => $start, 'end' => $end);
                }
            }
        }
    }

    // }}}

    // {{{ get_response_helper

    /**
     * GET response helper - format GET response
     *
     * @param options
     * @param status
     * @return void
     */
    function get_response_helper($options, $status)
    {
        if (empty($status)) {
            $status = '404 Not Found';
        }

        // set headers before we start printing
        $this->setResponseStatus($status);

        if ($status !== true) {
            return;
        }

        if (empty($options['mimetype'])) {
            $options['mimetype'] = 'application/octet-stream';
        }
        $this->setResponseHeader("Content-Type: $options[mimetype]");

        if (!empty($options['mtime'])) {
            $this->setResponseHeader('Last-Modified:'
                . gmdate('D, d M Y H:i:s', $options['mtime']) . 'GMT');
        }

        if ($options['stream']) {
            // GET handler returned a stream

            if (!empty($options['ranges']) &&
                    (fseek($options['stream'], 0, SEEK_SET) === 0)) {
                // partial request and stream is seekable

                if (count($options['ranges']) === 1) {
                    $range = $options['ranges'][0];

                    if (!empty($range['start'])) {
                        fseek($options['stream'], $range['start'], SEEK_SET);
                        if (feof($options['stream'])) {
                            $this->setResponseStatus(
                                '416 Requested Range Not Satisfiable');
                            return;
                        }

                        if (!empty($range['end'])) {
                            $size = $range['end'] - $range['start'] + 1;
                            $this->setResponseStatus('206 Partial');
                            $this->setResponseHeader("Content-Length: $size");
                            $this->setResponseHeader(
                                "Content-Range: $range[start]-$range[end]/"
                                . (!empty($options['size']) ? $options['size'] : '*'));
                            while ($size && !feof($options['stream'])) {
                                $buffer = fread($options['stream'], 4096);
                                $size -= strlen($buffer);
                                echo $buffer;
                            }
                        } else {
                            $this->setResponseStatus('206 Partial');
                            if (!empty($options['size'])) {
                                $this->setResponseHeader("Content-Length: "
                                    . ($options['size'] - $range['start']));
                                $this->setResponseHeader(
                                    "Content-Range: $range[start]-$range[end]/"
                                    . (!empty($options['size']) ? $options['size'] : '*'));
                            }
                            fpassthru($options['stream']);
                        }
                    } else {
                        $this->setResponseHeader("Content-Length: $range[last]");
                        fseek($options['stream'], -$range['last'], SEEK_END);
                        fpassthru($options['stream']);
                    }
                } else {
                    $this->_multipart_byterange_header(); // init multipart
                    foreach ($options['ranges'] as $range) {

                        // TODO what if size unknown? 500?
                        if (!empty($range['start'])) {
                            $from = $range['start'];
                            $to = !empty($range['end']) ? $range['end'] : $options['size'] - 1;
                        } else {
                            $from = $options['size'] - $range['last'] - 1;
                            $to = $options['size'] - 1;
                        }
                        $total = !empty($options['size']) ? $options['size'] : '*';
                        $size = $to - $from + 1;
                        $this->_multipart_byterange_header($options['mimetype'],
                            $from, $to, $total);

                        fseek($options['stream'], $start, SEEK_SET);
                        while ($size && !feof($options['stream'])) {
                            $buffer = fread($options['stream'], 4096);
                            $size -= strlen($buffer);
                            echo $buffer;
                        }
                    }

                    // end multipart
                    $this->_multipart_byterange_header();
                }
            } else {
                // normal request or stream isn't seekable, return full content
                if (!empty($options['size'])) {
                    $this->setResponseHeader("Content-Length: $options[size]");
                }

                fpassthru($options['stream']);
            }
        } else if (!empty($options['data']))  {
            if (is_array($options['data'])) {
                // reply to partial request
            } else {
                $this->setResponseHeader("Content-Length: "
                    . strlen($options['data']));
                echo $options['data'];
            }
        }
    }

    /**
     * Generate separator headers for multipart response
     *
     * First and last call happen without parameters to generate the initial
     * header and closing sequence, all calls inbetween require content
     * mimetype, start and end byte position and optionaly the total byte
     * length of the requested resource
     *
     * @param string mimetype
     * @param int start byte position
     * @param int end byte position
     * @param int total resource byte size
     */
    function _multipart_byterange_header($mimetype = false, $from = false,
        $to = false, $total = false)
    {
        if ($mimetype === false) {
            if (empty($this->multipart_separator)) {
                // init
                // a little naive, this sequence *might* be part of the content
                // but it's really not likely and rather expensive to check
                $this->multipart_separator = 'SEPARATOR_' . md5(microtime());

                // generate HTTP header
                $this->setResponseHeader(
                    'Content-Type: multipart/byteranges; boundary='
                    . $this->multipart_separator);
                return;
            }

            // end
            // generate closing multipart sequence
            echo "\n--{$this->multipart_separator}--";
            return;
        }

        // generate separator and header for next part
        echo "\n--{$this->multipart_separator}\n";
        echo "Content-Type: $mimetype\n";
        echo "Content-Range: $from-$to/"
            . ($total === false ? "*" : $total) . "\n\n";
    }

    // }}}

    // {{{ get_wrapper

    /**
     * GET method wrapper
     *
     * @param void
     * @return void
     */
    function get_wrapper()
    {
        // perpare data-structure from GET request
        if (!$this->get_request_helper($options)) {
            return;
        }

        // call user handler
        $status = $this->get($options);

        // format GET response
        $this->get_response_helper($options, $status);
    }

    // }}}

    // {{{ head_response_helper

    /**
     * HEAD response helper - format HEAD response
     *
     * @param options
     * @param status
     * @return void
     */
    function head_response_helper($options, $status)
    {
        if (empty($status)) {
            $status = '404 Not Found';
        }

        // set headers before we start printing
        $this->setResponseStatus($status);

        if ($status !== true) {
            return;
        }

        if (empty($options['mimetype'])) {
            $options['mimetype'] = 'application/octet-stream';
        }
        $this->setResponseHeader("Content-Type: $options[mimetype]");

        if (!empty($options['mtime'])) {
            $this->setResponseHeader('Last-Modified:'
                . gmdate('D, d M Y H:i:s', $options['mtime']) . 'GMT');
        }

        if (!empty($options['stream'])) {
            // GET handler returned a stream

            if (!empty($options['ranges'])
                    && (fseek($options['stream'], 0, SEEK_SET) === 0)) {
                // partial request and stream is seekable

                if (count($options['ranges']) === 1) {
                    $range = $options['ranges'][0];

                    if (!empty($range['start'])) {
                        fseek($options['stream'], $range['start'], SEEK_SET);
                        if (feof($options['stream'])) {
                            $this->setResponseStatus(
                                '416 Requested Range Not Satisfiable');
                            return;
                        }

                        if (!empty($range['end'])) {
                            $size = $range['end'] - $range['start'] + 1;
                            $this->setResponseStatus('206 Partial');
                            $this->setResponseHeader("Content-Length: $size");
                            $this->setResponseHeader(
                                "Content-Range: $range[start]-$range[end]/"
                                . (!empty($options['size']) ? $options['size'] : '*'));
                        } else {
                            $this->setResponseStatus('206 Partial');
                            if (!empty($options['size'])) {
                                $this->setResponseHeader("Content-Length: "
                                    . ($options['size'] - $range['start']));
                                $this->setResponseHeader(
                                    "Content-Range: $start-$end/"
                                    . (!empty($options['size']) ? $options['size'] : '*'));
                            }
                        }
                    } else {
                        $this->setResponseHeader(
                            "Content-Length: $range[last]");
                        fseek($options['stream'], -$range['last'], SEEK_END);
                    }
                } else {
                    $this->_multipart_byterange_header(); // init multipart
                    foreach ($options['ranges'] as $range) {

                        // TODO what if size unknown? 500?
                        if (!empty($range['start'])) {
                            $from = $range['start'];
                            $to = !empty($range['end']) ? $range['end'] :
                                $options['size'] - 1;
                        } else {
                            $from = $options['size'] - $range['last'] - 1;
                            $to = $options['size'] - 1;
                        }
                        $total = !empty($options['size']) ? $options['size'] :
                            '*';
                        $size = $to - $from + 1;
                        $this->_multipart_byterange_header($options['mimetype'],
                            $from, $to, $total);

                        fseek($options['stream'], $start, SEEK_SET);
                    }
                    $this->_multipart_byterange_header(); // end multipart
                }
            } else {
                // normal request or stream isn't seekable, return full content
                if (!empty($options['size'])) {
                    $this->setResponseHeader("Content-Length: $options[size]");
                }
            }
        } else if (!empty($options['data']))  {
            if (is_array($options['data'])) {
                // reply to partial request
            } else {
                $this->setResponseHeader("Content-Length: "
                    . strlen($options['data']));
            }
        }
    }

    // }}}

    // {{{ head_wrapper

    /**
     * HEAD method wrapper
     *
     * @param void
     * @return void
     */
    function head_wrapper()
    {
        $options = array();
        $options['path'] = $this->path;

        // call user handler
        if (method_exists($this, 'head')) {
            $status = $this->head($options);
        } else {

            // can emulate HEAD using GET
            ob_start();
            $status = $this->get($options);
            ob_end_clean();
        }

        // format HEAD response
        $this->head_response_helper($options, $status);
    }

    // }}}

    // {{{ put_request_helper

    /**
     * PUT request helper - prepares data-structures from PUT requests
     *
     * @param options
     * @return void
     */
    function put_request_helper(&$options)
    {
        $options = array();
        $options['path'] = $this->path;

        /* Content-Length may be zero */
        if (!isset($_SERVER['CONTENT_LENGTH'])) {
            return;
        }
        $options['content_length'] = $_SERVER['CONTENT_LENGTH'];

        // default content type if none given
        $options['content_type'] = 'application/unknown';

        // get the content-type
        if (!empty($_SERVER['CONTENT_TYPE'])) {

            // for now we do not support any sort of multipart requests
            if (!strncmp($_SERVER['CONTENT_TYPE'], 'multipart/', 10)) {
                $this->setResponseStatus('501 Not Implemented');
                echo 'The service does not support mulipart PUT requests';
                return;
            }

            $options['content_type'] = $_SERVER['CONTENT_TYPE'];
        }

        // RFC2616 2.6: The recipient of the entity MUST NOT ignore any
        // Content-* (e.g. Content-Range) headers that it does not understand
        // or implement and MUST return a 501 (Not Implemented) response in
        // such cases.
        foreach ($_SERVER as $key => $value) {
            if (strncmp($key, 'HTTP_CONTENT', 11)) {
                continue;
            }

            switch ($key) {
            case 'HTTP_CONTENT_ENCODING': // RFC2616 14.11

                // TODO support this if ext/zlib filters are available
                $this->setResponseStatus('501 Not Implemented');
                echo "The service does not support '$value' content encoding";
                return;

            case 'HTTP_CONTENT_LANGUAGE': // RFC2616 14.12

                // we assume it is not critical if this one is ignored in the
                // actual PUT implementation
                $options['content_language'] = $value;
                break;

            case 'HTTP_CONTENT_LENGTH':

                // defined on IIS and has the same value as CONTENT_LENGTH
                break;

            case 'HTTP_CONTENT_LOCATION': // RFC2616 14.14

                // meaning of the Content-Location header in PUT or POST
                // requests is undefined; servers are free to ignore it in
                // those cases
                break;

            case 'HTTP_CONTENT_RANGE': // RFC2616 14.16

                // single byte range requests are supported
                // the header format is also specified in RFC2616 14.16
                // TODO we have to ensure that implementations support this or send 501 instead
                if (!preg_match('@bytes\s+(\d+)-(\d+)/((\d+)|\*)@', $value, $matches)) {
                    $this->setResponseStatus('400 Bad Request');
                    echo 'The service does only support single byte ranges';
                    return;
                }

                $range = array('start' => $matches[1], 'end' => $matches[2]);
                if (is_numeric($matches[3])) {
                    $range['total_length'] = $matches[3];
                }
                $option['ranges'][] = $range;

                // TODO make sure the implementation supports partial PUT
                // this has to be done in advance to avoid data being overwritten
                // on implementations that do not support this...
                break;

            case 'HTTP_CONTENT_MD5': // RFC2616 14.15

                // TODO maybe we can just pretend here?
                $this->setResponseStatus('501 Not Implemented');
                echo 'The service does not support content MD5 checksum verification';
                return;

            case 'HTTP_CONTENT_TYPE':

                // defined on IIS and has the same value as CONTENT_TYPE
                break;

            default:

                // any other unknown Content-* headers
                $this->setResponseStatus('501 Not Implemented');
                echo "The service does not support '$key'";
                return;
            }
        }

        $options['stream'] = $this->openRequestBody();

        return true;
    }

    // }}}

    // {{{ put_response_helper

    /**
     * PUT response helper - format PUT response
     *
     * @param options
     * @param status
     * @return void
     */
    function put_response_helper($options, $status)
    {
        if (empty($status)) {
            $status = '403 Forbidden';
        } else if (is_resource($status)
                && get_resource_type($status) == 'stream') {
            $stream = $status;
            $status = isset($options['new']) && $options['new'] === false ? '204 No Content' : '201 Created';

            if (!empty($options['ranges'])) {

                // TODO multipart support is missing (see also above)
                if (0 == fseek($stream, $range[0]['start'], SEEK_SET)) {
                    $length = $range[0]['end'] - $range[0]['start'] + 1;
                    if (!fwrite($stream, fread($options['stream'], $length))) {
                        $status = '403 Forbidden';
                    }
                } else {
                    $status = '403 Forbidden';
                }
            } else {
                while (!feof($options['stream'])) {
                    $buf = fread($options['stream'], 4096);
                    if (fwrite($stream, $buf) != 4096) {
                        break;
                    }
                }
            }

            fclose($stream);
        }

        $this->setResponseStatus($status);
    }

    // }}}

    // {{{ put_wrapper

    /**
     * PUT method wrapper
     *
     * @param void
     * @return void
     */
    function put_wrapper()
    {
        // check resource is not locked
        if (!$this->check_locks_wrapper($this->path)) {
            $this->setResponseStatus('423 Locked');
            return;
        }

        // perpare data-structure from PUT request
        if (!$this->put_request_helper($options)) {
            return;
        }

        // call user handler
        $status = $this->put($options);

        // format PUT response
        $this->put_response_helper($options, $status);
    }

    // }}}

    // {{{ delete_wrapper

    /**
     * DELETE method wrapper
     *
     * @param void
     * @return void
     */
    function delete_wrapper()
    {
        // RFC2518 9.2 last paragraph
        if (!empty($_SERVER['HTTP_DEPTH'])
                && $_SERVER['HTTP_DEPTH'] != 'infinity') {
            $this->setResponseStatus('400 Bad Request');
            return;
        }

        // check resource is not locked
        if (!$this->check_locks_wrapper($this->path)) {
            $this->setResponseStatus('423 Locked');
            return;
        }

        $options = array();
        $options['path'] = $this->path;

        // call user handler
        $status = $this->delete($options);
        if ($status === true) {
            $status = '204 No Content';
        }

        $this->setResponseStatus($status);
    }

    // }}}

    // {{{ copymove_request_helper

    /**
     * COPY/MOVE request helper - prepares data-structures from COPY/MOVE
     * requests
     *
     * @param options
     * @return void
     */
    function copymove_request_helper(&$options)
    {
        $options = array();
        $options['path'] = $this->path;

        $options['depth'] = 'infinity';
        if (!empty($_SERVER['HTTP_DEPTH'])) {
            $options['depth'] = $_SERVER['HTTP_DEPTH'];
        }

        // RFC2518 9.6, 8.8.4 and 8.9.3
        $options['overwrite'] = true;
        if (!empty($_SERVER['HTTP_OVERWRITE'])) {
            $options['overwrite'] = $_SERVER['HTTP_OVERWRITE'] == 'T';
        }

        $url = parse_url($_SERVER['HTTP_DESTINATION']);

        // does the destination resource belong on this server?
        if ($url['host'] == $this->baseUrl['host']
                && (empty($url['port']) ? 80 : $url['port']) == (empty($this->baseUrl['port']) ? 80 : $this->baseUrl['port'])
                && !strncmp($url['path'], $this->baseUrl['path'], strlen($this->baseUrl['path']))) {
            if (!empty($this->baseurl['query'])) {
                foreach (explode('&', $this->baseUrl['query']) as $queryComponent) {
                    if (!in_array($queryComponent, explode('&', $url['query']))) {
                        $options['dest_url'] = $_SERVER['HTTP_DESTINATION'];

                        return true;
                    }
                }
            }

            $options['dest'] =
                substr($url['path'], strlen($this->baseUrl['path']));

            $options['dest'] = $this->_urldecode($options['dest']);
            $options['dest'] = trim($options['dest'], '/');

            // check source and destination are not the same - data could be lost
            // if overwrite is true - RFC2518 8.8.5
            if ($options['dest'] == $this->path) {
                $this->setResponseStatus('403 Forbidden');
                return;
            }

            return true;
        }

        $options['dest_url'] = $_SERVER['HTTP_DESTINATION'];

        return true;
    }

    // }}}

    // {{{ copy_wrapper

    /**
     * COPY method wrapper
     *
     * @param void
     * @return void
     */
    function copy_wrapper()
    {
        // no need to check source is not locked

        // perpare data-structure from COPY request
        if (!$this->copymove_request_helper($options)) {
            return;
        }

        // check destination is not locked
        if (!empty($options['dest']) &&
                !$this->check_locks_wrapper($options['dest'])) {
            $this->setResponseStatus('423 Locked');
            return;
        }

        // call user handler
        $status = $this->copy($options);
        if ($status === true) {
            $status = $options['new'] === false ? '204 No Content' :
                '201 Created';
        }

        $this->setResponseStatus($status);
    }

    // }}}

    // {{{ move_wrapper

    /**
     * MOVE method wrapper
     *
     * @param void
     * @return void
     */
    function move_wrapper()
    {
        // check resource is not locked
        if (!$this->check_locks_wrapper($this->path)) {
            $this->setResponseStatus('423 Locked');
            return;
        }

        // perpare data-structure from MOVE request
        if (!$this->copymove_request_helper($options)) {
            return;
        }

        // check destination is not locked
        if (!empty($options['dest']) &&
                !$this->check_locks_wrapper($options['dest'])) {
            $this->setResponseStatus('423 Locked');
            return;
        }

        // call user handler
        $status = $this->move($options);
        if ($status === true) {
            $status = $options['new'] === false ? '204 No Content' :
                '201 Created';
        }

        $this->setResponseStatus($status);
    }

    // }}}

    // {{{ lock_request_helper

    /**
     * LOCK request helper - prepares data-structures from LOCK requests
     *
     * @param options
     * @return void
     */
    function lock_request_helper(&$options)
    {
        $options = array();
        $options['path'] = $this->path;

        // a LOCK request with an If header but without a body is used to
        // refresh a lock.  Content-Lenght may be unset or zero.
        if (empty($_SERVER['CONTENT_LENGTH']) && !empty($_SERVER['HTTP_IF'])) {

            // FIXME: Refresh multiple locks?
            $options['update'] = substr($_SERVER['HTTP_IF'], 2, -2);

            return true;
        }

        $options['depth'] = 'infinity';
        if (!empty($_SERVER['HTTP_DEPTH'])) {
            $options['depth'] = $_SERVER['HTTP_DEPTH'];
        }

        if (!empty($_SERVER['HTTP_TIMEOUT'])) {
            $options['timeout'] = explode(',', $_SERVER['HTTP_TIMEOUT']);
        }

        // extract lock request information from request XML payload
        $lockinfo = new _parse_lockinfo($this->openRequestBody());
        if (!$lockinfo->success) {
            $this->setResponseStatus('400 Bad Request');
            return;
        }

        // new lock
        $options['scope'] = $lockinfo->lockscope;
        $options['type']  = $lockinfo->locktype;
        $options['owner'] = $lockinfo->owner;

        $options['token'] = $this->_new_locktoken();

        return true;
    }

    // }}}

    // {{{ lock_response_helper

    /**
     * LOCK response helper - format LOCK response
     *
     * @param options
     * @param status
     * @return void
     */
    function lock_response_helper($options, $status)
    {
        if (!empty($options['locks']) && is_array($options['locks'])) {
            $this->setResponseStatus('409 Conflict');

            $responses = array();
            foreach ($options['locks'] as $lock) {
                $response = array();

                if (empty($lock['href'])) {
                    $response['href'] = $this->getHref($lock['path']);
                } else {
                    $response['href'] = $lock['href'];
                }

                $response['status'] = '423 Locked';

                $responses[] = $response;
            }

            $this->_multistatusResponseHelper($responses);

            return;
        }

        if ($status === true) {
            $status = '200 OK';
        } else if ($status === false) {
            $status = '423 Locked';
        }

        // set headers before we start printing
        $this->setResponseStatus($status);

        if ($status{0} == 2) { // 2xx states are ok
            $this->setResponseHeader('Content-Type: text/xml; charset="utf-8"');

            // RFC2518 8.10.1: In order to indicate the lock token associated
            // with a newly created lock, a Lock-Token response header MUST be
            // included in the response for every successful LOCK request for a
            // new lock.  Note that the Lock-Token header would not be returned
            // in the response for a successful refresh LOCK request because a
            // new lock was not created.
            if (empty($options['update']) || !empty($options['token'])) {
                $this->setResponseHeader("Lock-Token: <$options[token]>");
            }

            $lock = array();
            foreach (array('scope', 'type', 'depth', 'owner') as $key) {
                $lock[$key] = $options[$key];
            }

            if (!empty($options['expires'])) {
                $lock['expires'] = $options['expires'];
            } else {
                $lock['timeout'] = $options['timeout'];
            }

            if (!empty($options['update'])) {
                $lock['token'] = $options['update'];
            } else {
                $lock['token'] = $options['token'];
            }

            echo "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
            echo "<D:prop xmlns:D=\"DAV:\">\n";
            echo "  <D:lockdiscovery>\n";
            echo '    ' . $this->_activelocksResponseHelper(array($lock))
                . "\n";
            echo "  </D:lockdiscovery>\n";
            echo "</D:prop>\n";
        }
    }

    // }}}

    // {{{ lock_wrapper

    /**
     * LOCK method wrapper
     *
     * @param void
     * @return void
     */
    function lock_wrapper()
    {
        // perpare data-structure from LOCK request
        if (!$this->lock_request_helper($options)) {
            return;
        }

        // check resource is not locked
        if (!empty($options['update'])
                && !$this->check_locks_wrapper(
                    $this->path, $options['scope'] == 'shared')) {
            $this->setResponseStatus('423 Locked');
            return;
        }

        $options['locks'] = $this->getDescendentsLocks($this->path);
        if (empty($options['locks'])) {

            // call user handler
            $status = $this->lock($options);
        }

        // format LOCK response
        $this->lock_response_helper($options, $status);
    }

    // }}}

    // {{{ unlock_request_helper

    /**
     * UNLOCK request helper - prepares data-structures from UNLOCK requests
     *
     * @param options
     * @return void
     */
    function unlock_request_helper(&$options)
    {
        $options = array();
        $options['path'] = $this->path;

        if (empty($_SERVER['HTTP_LOCK_TOKEN'])) {
            return;
        }

        // strip surrounding <>
        $options['token'] = substr(trim($_SERVER['HTTP_LOCK_TOKEN']), 1, -1);

        return true;
    }

    // }}}

    // {{{ unlock_wrapper

    /**
     * UNLOCK method wrapper
     *
     * @param void
     * @return void
     */
    function unlock_wrapper()
    {
        // perpare data-structure from DELETE request
        if (!$this->unlock_request_helper($options)) {
            return;
        }

        // call user handler
        $status = $this->unlock($options);

        // RFC2518 8.11.1
        if ($status === true) {
            $status = '204 No Content';
        }

        $this->setResponseStatus($status);
    }

    // }}}

    function _multistatusResponseHelper($responses)
    {
        // now we generate the response header...
        $this->setResponseStatus('207 Multi-Status', false);
        $this->setResponseHeader('Content-Type: text/xml; charset="utf-8"');

        // ...& payload
        echo "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
        echo "<D:multistatus xmlns:D=\"DAV:\">\n";

        foreach ($responses as $response) {

            // ignore empty or incomplete entries
            if (!is_array($response) || empty($response)) {
                continue;
            }

            $namespaces = '';
            if (!empty($response['namespaces'])) {
                foreach ($response['namespaces'] as $name => $prefix) {
                    $namespaces .= " xmlns:$prefix=\"$name\"";
                }
            }
            echo "  <D:response$namespaces>\n";
            echo "    <D:href>$response[href]</D:href>\n";

            // report all found properties and their values (if any)
            // nothing to do if no properties were returend for a file
            if (!empty($response['propstat']) &&
                    is_array($response['propstat'])) {

                foreach ($response['propstat'] as $status => $props) {
                    echo "    <D:propstat>\n";
                    echo "      <D:prop>\n";

                    foreach ($props as $prop) {
                        if (!is_array($prop) || empty($prop['name'])) {
                            continue;
                        }

                        // empty properties (cannot use empty for check as '0'
                        // is a legal value here)
                        if (empty($prop['value']) && (!isset($prop['value'])
                                || $prop['value'] !== 0)) {
                            if ($prop['ns'] == 'DAV:') {
                                echo "        <D:$prop[name]/>\n";
                                continue;
                            }

                            if (!empty($prop['ns'])) {
                                echo '        <' . $response['namespaces'][$prop['ns']] . ":$prop[name]/>\n";
                                continue;
                            }

                            echo "        <$prop[name] xmlns=\"\"/>";
                            continue;
                        }

                        // some WebDAV properties need special treatment
                        if ($prop['ns'] == 'DAV:') {

                            switch ($prop['name']) {
                            case 'creationdate':
                                echo '        <D:creationdate ' . $response['namespaces'][HTTP_WEBDAV_SERVER_DATATYPE_NAMESPACE] . ':dt="dateTime.tz">' . gmdate('Y-m-d\TH:i:s\Z', $prop['value']) . "</D:creationdate>\n";
                                break;

                            case 'getlastmodified':
                                echo '        <D:getlastmodified ' . $response['namespaces'][HTTP_WEBDAV_SERVER_DATATYPE_NAMESPACE] . ':dt="dateTime.rfc1123">' . gmdate('D, d M Y H:i:s', $prop['value']) . " UTC</D:getlastmodified>\n";
                                break;

                            case 'resourcetype':
                                echo "        <D:resourcetype><D:$prop[value]/></D:resourcetype>\n";
                                break;

                            case 'supportedlock':

                                if (is_array($prop['value'])) {
                                    $prop['value'] =
                                        $this->_lockentriesResponseHelper(
                                            $prop['value']);
                                }
                                echo "        <D:supportedlock>\n";
                                echo "          $prop[value]\n";
                                echo "        </D:supportedlock>\n";
                                break;

                            case 'lockdiscovery':

                                if (is_array($prop['value'])) {
                                    $prop['value'] =
                                        $this->_activelocksResponseHelper(
                                            $prop['value']);
                                }
                                echo "        <D:lockdiscovery>\n";
                                echo "          $prop[value]\n";
                                echo "        </D:lockdiscovery>\n";
                                break;

                            default:
                                echo "        <D:$prop[name]>" . $this->_prop_encode(htmlspecialchars($prop['value'])) . "</D:$prop[name]>\n";
                            }

                            continue;
                        }

                        if (!empty($prop['ns'])) {
                            echo '        <' . $response['namespaces'][$prop['ns']] . ":$prop[name]>" . $this->_prop_encode(htmlspecialchars($prop['value'])) . '</' . $response['namespaces'][$prop['ns']] . ":$prop[name]>\n";

                            continue;
                        }

                        echo "        <$prop[name] xmlns=\"\">" . $this->_prop_encode(htmlspecialchars($prop['value'])) . "</$prop[name]>\n";
                    }

                    echo "      </D:prop>\n";
                    echo "      <D:status>HTTP/1.1 $status</D:status>\n";
                    echo "    </D:propstat>\n";
                }
            }

            if (!empty($response['status'])) {
                echo "    <D:status>HTTP/1.1 $response[status]</D:status>\n";
            }

            if (!empty($response['responsedescription'])) {
                echo '    <D:responsedescription>' . $this->_prop_encode(htmlspecialchars($response['responsedescription'])) . "</D:responsedescription>\n";
            }

            echo "  </D:response>\n";
        }

        echo "</D:multistatus>\n";
    }

    function _activelocksResponseHelper($locks)
    {
        if (!is_array($locks) || empty($locks)) {
            return '';
        }

        foreach ($locks as $key => $lock) {
            if (!is_array($lock) || empty($lock)) {
                continue;
            }

            // check for 'timeout' or 'expires'
            $timeout = 'Infinite';
            if (!empty($lock['expires'])) {
                $timeout = 'Second-' . ($lock['expires'] - time());
            } else if (!empty($lock['timeout'])) {

                // more than a million is considered an absolute timestamp
                // less is more likely a relative value
                $timeout = "Second-$lock[timeout]";
                if ($lock['timeout'] > 1000000) {
                    $timeout = 'Second-' . ($lock['timeout'] - time());
                }
            }

            // genreate response block
            $locks[$key] = "<D:activelock>
            <D:lockscope><D:$lock[scope]/></D:lockscope>
            <D:locktype><D:$lock[type]/></D:locktype>
            <D:depth>" . ($lock['depth'] == 'infinity' ? 'Infinity' : $lock['depth']) . "</D:depth>
            <D:owner>$lock[owner]</D:owner>
            <D:timeout>$timeout</D:timeout>
            <D:locktoken><D:href>$lock[token]</D:href></D:locktoken>
          </D:activelock>";
        }

        return implode('', $locks);
    }

    function _lockentriesResponseHelper($locks)
    {
        if (!is_array($locks) || empty($locks)) {
            return '';
        }

        foreach ($locks as $key => $lock) {
            if (!is_array($lock) || empty($lock)) {
                continue;
            }

            $locks[$key] = "<D:lockentry>
            <D:lockscope><D:$lock[scope]/></D:lockscope>
            <D:locktype><D:$lock[type]/></D:locktype>
          </D:lockentry>";
        }

        return implode('', $locks);
    }

    function getHref($path)
    {
        return $this->baseUrl['path'] . '/' . $path;
    }

    function getProp($reqprop, $file, $options)
    {
        // check if property exists in response
        foreach ($file['props'] as $prop) {
            if ($reqprop['name'] == $prop['name']
                    && $reqprop['ns'] == $prop['ns']) {
                return $prop;
            }
        }

        if ($reqprop['name'] == 'lockdiscovery'
                && $reqprop['ns'] == 'DAV:'
                && method_exists($this, 'getLocks')) {
            return $this->mkprop('DAV:', 'lockdiscovery',
                $this->getLocks($file['path']));
        }

        // incase the requested property had a value, like calendar-data
        unset($reqprop['value']);
        $reqprop['status'] = '404 Not Found';

        return $reqprop;
    }

    function getDescendentsLocks($path)
    {
        $options = array();
        $options['path'] = $path;
        $options['depth'] = 'infinity';
        $options['props'] = array();
        $options['props'][] = $this->mkprop('DAV:', 'lockdiscovery', null);

        // call user handler
        if (!$this->propfind($options, $files)) {
            return;
        }

        return $files;
    }

    // {{{ _allow()

    /**
     * List implemented methods
     *
     * @param void
     * @return array something
     */
    function _allow()
    {
        // OPTIONS is always there
        $allow = array('OPTIONS');

        // all other methods need both a method_wrapper() and a method()
        // implementation
        // the base class defines only wrappers
        foreach(get_class_methods($this) as $method) {

            // strncmp breaks with negative len -
            // http://bugs.php.net/bug.php?id=36944
            //if (!strncmp('_wrapper', $method, -8)) {
            if (!strcmp(substr($method, -8), '_wrapper')) {
                $method = strtolower(substr($method, 0, -8));
                if (method_exists($this, $method) &&
                        ($method != 'lock' && $method != 'unlock' ||
                        method_exists($this, 'getLocks'))) {
                    $allow[] = $method;
                }
            }
        }

        // we can emulate a missing HEAD implemetation using GET
        if (in_array('GET', $allow)) {
            $allow[] = 'HEAD';
        }

        return $allow;
    }

    // }}}

    // {{{ mkprop

    /**
     * Helper for property element creation
     *
     * @param string XML namespace (optional)
     * @param string property name
     * @param string property value
     * @return array property array
     */
    function mkprop()
    {
        $args = func_get_args();

        $prop = array();
        $prop['ns'] = 'DAV:';
        if (count($args) > 2) {
            $prop['ns'] = array_shift($args);
        }

        $prop['name'] = array_shift($args);
        $prop['value'] = array_shift($args);
        $prop['status'] = array_shift($args);

        return $prop;
    }

    // }}}

    // {{{ check_auth_wrapper

    /**
     * Check authentication if implemented
     *
     * @param void
     * @return boolean true if authentication succeded or not necessary
     */
    function check_auth_wrapper()
    {
        if (method_exists($this, 'checkAuth')) {

            // PEAR style method name
            return $this->checkAuth(@$_SERVER['AUTH_TYPE'],
                @$_SERVER['PHP_AUTH_USER'],
                @$_SERVER['PHP_AUTH_PW']);
        }

        if (method_exists($this, 'check_auth')) {

            // old (pre 1.0) method name
            return $this->check_auth(@$_SERVER['AUTH_TYPE'],
                @$_SERVER['PHP_AUTH_USER'],
                @$_SERVER['PHP_AUTH_PW']);
        }

        // no method found -> no authentication required
        return true;
    }

    // }}}

    // {{{ UUID stuff

    /**
     * Generate Unique Universal IDentifier for lock token
     *
     * @param void
     * @return string a new UUID
     */
    function _new_uuid()
    {
        // use uuid extension from PECL if available
        if (function_exists('uuid_create')) {
            return uuid_create();
        }

        // fallback
        $uuid = md5(microtime() . getmypid()); // this should be random enough for now

        // set variant and version fields for 'true' random uuid
        $uuid{12} = '4';
        $n = 8 + (ord($uuid{16}) & 3);
        $hex = '0123456789abcdef';
        $uuid{16} = $hex{$n};

        // return formated uuid
        return substr($uuid,  0, 8)
            . '-' . substr($uuid,  8, 4)
            . '-' . substr($uuid, 12, 4)
            . '-' . substr($uuid, 16, 4)
            . '-' . substr($uuid, 20);
    }

    /**
     * Create a new opaque lock token as defined in RFC2518
     *
     * @param void
     * @return string new RFC2518 opaque lock token
     */
    function _new_locktoken()
    {
        return 'opaquelocktoken:' . $this->_new_uuid();
    }

    // }}}

    // {{{ WebDAV If: header parsing

    /**
     *
     *
     * @param string header string to parse
     * @param int current parsing position
     * @return array next token (type and value)
     */
    function _if_header_lexer($string, &$pos)
    {
        // skip whitespace
        while (ctype_space($string{$pos})) {
            ++$pos;
        }

        // already at end of string?
        if (strlen($string) <= $pos) {
            return;
        }

        // get next character
        $c = $string{$pos++};

        // now it depends on what we found
        switch ($c) {

            // URLs are enclosed in <...>
            case '<':
                $pos2 = strpos($string, '>', $pos);
                $uri = substr($string, $pos, $pos2 - $pos);
                $pos = $pos2 + 1;
                return array('URI', $uri);

            // ETags are enclosed in [...]
            case '[':
                $type = 'ETAG_STRONG';
                if ($string{$pos} == 'W') {
                    $type = 'ETAG_WEAK';
                    $pos += 2;
                }

                $pos2 = strpos($string, ']', $pos);
                $etag = substr($string, $pos + 1, $pos2 - $pos - 2);
                $pos = $pos2 + 1;
                return array($type, $etag);

            // 'N' indicates negation
            case 'N':
                $pos += 2;
                return array('NOT', 'Not');

            // anything else is passed verbatim char by char
            default:
                return array('CHAR', $c);
        }
    }

    /**
     * Parse If: header
     *
     * @param string header string
     * @return array URLs and their conditions
     */
    function _if_header_parser($str)
    {
        $pos = 0;
        $len = strlen($str);

        $uris = array();

        // parser loop
        while ($pos < $len) {

            // get next token
            $token = $this->_if_header_lexer($str, $pos);

            // check for URL
            $uri = '';
            if ($token[0] == 'URI') {
                $uri = $token[1]; // remember URL
                $token = $this->_if_header_lexer($str, $pos); // get next token
            }

            // sanity check
            if ($token[0] != 'CHAR' || $token[1] != '(') {
                return;
            }

            $list = array();
            $level = 1;
            while ($level) {
                $token = $this->_if_header_lexer($str, $pos);

                $not = '';
                if ($token[0] == 'NOT') {
                    $not = '!';
                    $token = $this->_if_header_lexer($str, $pos);
                }

                switch ($token[0]) {
                    case 'CHAR':
                        switch ($token[1]) {
                            case '(':
                                $level++;
                                break;

                            case ')':
                                $level--;
                                break;

                            default:
                                return;
                        }
                        break;

                    case 'URI':
                        $list[] = $not . "<$token[1]>";
                        break;

                    case 'ETAG_WEAK':
                        $list[] = $not . "[W/'$token[1]']";
                        break;

                    case 'ETAG_STRONG':
                        $list[] = $not . "['$token[1]']";
                        break;

                    default:
                        return;
                }
            }

            // RFC2518 9.4.1: The No-tag-list production describes a series of
            // state tokens and ETags.  If multiple No-tag-list productions are
            // used then one only needs to match the state of the resource for
            // the method to be allowed to continue.
            //
            // FIXME: Since only one list of conditions must be satisfied, it
            // is a mistake to merge all lists of conditions.  Instead, a URL
            // should reference an array of arrays of conditions, the inner
            // array representing a conjunction and the outer array
            // representing a disjunction, or $uris shouldn't be associative,
            // but be an array of productions array('href' => $href,
            // 'conditions' => array($condition, ...))
            if (!empty($uris[$uri])) {
                $uris[$uri] = array_merge($uris[$uri], $list);
                continue;
            }
            $uris[$uri] = $list;
        }

        return $uris;
    }

    /**
     * Check if conditions from If: headers are met
     *
     * The If: header is an extension to HTTP/1.1 defined in RFC2518 9.4
     *
     * @param void
     * @return boolean
     */
    function _check_if_header_conditions()
    {
        if (empty($_SERVER['HTTP_IF'])) {
            return true;
        }

        $this->_if_header_uris =
            $this->_if_header_parser($_SERVER['HTTP_IF']);

        // any match is ok
        foreach ($this->_if_header_uris as $uri => $conditions) {

            // RFC2518 9.4.1: If a method, due to the presence of a Depth or
            // Destination header, is applied to multiple resources then the
            // No-tag-list production MUST be applied to each resource the
            // method is applied to.
            if (empty($uri)) {
                $uri = $this->getHref($this->path);
            }

            // all must match
            foreach ($conditions as $condition) {

                // lock tokens may be free form (RFC2518 6.3)
                // but if opaquelocktokens are used (RFC2518 6.4)
                // we have to check the format (litmus tests this)
                if (!strncmp($condition, '<opaquelocktoken:', strlen('<opaquelocktoken'))) {
                    if (!ereg('^<opaquelocktoken:[[:xdigit:]]{8}-[[:xdigit:]]{4}-[[:xdigit:]]{4}-[[:xdigit:]]{4}-[[:xdigit:]]{12}>$', $condition)) {
                        return;
                    }
                }

                if (!$this->_check_uri_condition($uri, $condition)) {
                    continue 2;
                }
            }

            return true;
        }
    }

    /**
     * Check a single URL condition parsed from an if-header
     *
     * @abstract
     * @param string URL to check
     * @param string condition to check for this URL
     * @return boolean condition check result
     */
    function _check_uri_condition($uri, $condition)
    {
        // not really implemented here,
        // implementations must override
        return true;
    }

    /**
     * For each lock on the requested resource, check that the lock token is in
     * the If header.  If requesting a shared lock, check only exclusive locks
     * on the requested resource.
     *
     * @param array of locks
     * @param string path of resource to check
     * @param boolean exclusive lock?
     * @return boolean true if the request is allowed
     */
    function check_locks_helper($locks, $path, $exclusive_only=false)
    {
        $conditions = array();
        if (!empty($_SERVER['HTTP_IF'])) {
            $conditions = $this->_if_header_parser($_SERVER['HTTP_IF']);
        }

        foreach ($locks as $lock) {
            if ($exclusive_only && ($lock['scope'] == 'shared')) {
                continue;
            }

            // for both Tagged-list and No-tag-list productions
            foreach (array($this->getHref($path), '') as $href) {
                if (!empty($conditions[$href])
                        && in_array("<$lock[token]>", $conditions[$href])) {
                    continue 2;
                }
            }

            return false;
        }

        return true;
    }

    /**
     * @param string path of resource to check
     * @param boolean exclusive lock?
     */
    function check_locks_wrapper($path, $exclusive_only=false)
    {
        if (!method_exists($this, 'getLocks')) {
            return true;
        }

        return $this->check_locks_helper(
            $this->getLocks($path), $path, $exclusive_only);
    }

    // }}}

    /**
     * Open request body input stream
     *
     * Because it's not possible to write to php://input (unlike the potential
     * to set request variables) and not possible until PHP 5.1 to register
     * alternative stream wrappers with php:// URLs, this function enables
     * sub-classes to override the request body.  Gallery uses this for unit
     * testing.  This function also collects all instances of opening the
     * request body in one place.
     *
     * @return resource a file descriptor
     */
    function openRequestBody()
    {
        return fopen('php://input', 'rb');
    }

    /**
     * Set HTTP response header
     *
     * This function enables sub-classes to override header-setting.  Gallery
     * uses this to avoid replacing headers elsewhere in the application, and
     * for testability.
     *
     * @param string status code and message
     * @return void
     */
    function setResponseHeader($header, $replace=true)
    {
        $key = 'status';
        if (strncasecmp($header, 'HTTP/', 5) !== 0) {
            $key = strtolower(substr($header, 0, strpos($header, ':')));
        }

        if ($replace || empty($this->headers[$key])) {
            header($header);
            $this->headers[$key] = $header;
        }
    }

    /**
     * Set HTTP response status and mirror it in a private header
     *
     * @param string status code and message
     * @return void
     */
    function setResponseStatus($status, $replace=true)
    {
        // simplified success case
        if ($status === true) {
            $status = '200 OK';
        }

        // didn't set a more specific status code
        if (empty($status)) {
            $status = '500 Internal Server Error';
        }

        // generate HTTP status response
        $this->setResponseHeader("HTTP/1.1 $status", $replace);
        $this->setResponseHeader("X-WebDAV-Status: $status", $replace);
    }

    /**
     * Private minimalistic version of PHP urlencode
     *
     * Only blanks and XML special chars must be encoded here.  Full urlencode
     * encoding confuses some clients.
     *
     * @param string URL to encode
     * @return string encoded URL
     */
    function _urlencode($url)
    {
        return strtr($url, array(' ' => '%20',
                '&' => '%26',
                '<' => '%3C',
                '>' => '%3E'));
    }

    /**
     * Private version of PHP urldecode
     *
     * Not really needed but added for completenes.
     *
     * @param string URL to decode
     * @return string decoded URL
     */
    function _urldecode($path)
    {
        return urldecode($path);
    }

    /**
     * UTF-8 encode property values if not already done so
     *
     * @param string text to encode
     * @return string UTF-8 encoded text
     */
    function _prop_encode($text)
    {
        switch (strtolower($this->_prop_encoding)) {
        case 'utf-8':
            return $text;
        case 'iso-8859-1':
        case 'iso-8859-15':
        case 'latin-1':
        default:
            return utf8_encode($text);
        }
    }

    /**
     * Make sure path ends in a slash
     *
     * @param string directory path
     * @return string directory path with trailing slash
     */
    function _slashify($path)
    {
        if (substr($path, -1) != '/') {
            $path .= '/';
        }

        return $path;
    }
}

// Local variables:
// tab-width: 4
// c-basic-offset: 4
// End:
?>
');
expand_6421a0d81d($outputDir, 'lib/HTTP/WebDAV/Tools/_parse_lockinfo.php', '<?php
//
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Hartmut Holzgraefe <hholzgra@php.net>                       |
// |          Christian Stocker <chregu@bitflux.ch>                       |
// +----------------------------------------------------------------------+
//
// $Id: _parse_lockinfo.php 15342 2006-12-01 21:14:46Z andy_st $

/**
 * Helper class for parsing LOCK request bodies
 *
 * @package HTTP_WebDAV_Server
 * @author Hartmut Holzgraefe <hholzgra@php.net>
 * @version 0.99.1dev
 */
class _parse_lockinfo
{
    /**
     * Success state flag
     *
     * @var boolean
     * @access public
     */
    var $success = false;

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

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

    /**
     * Lock owner information
     *
     * @var string
     * @access public
     */
    var $owner = '';

    /**
     * Flag that is set during lock owner read
     *
     * @var boolean
     * @access private
     */
    var $collect_owner = false;

    /**
     * Constructor
     *
     * @param resource input stream file descriptor
     * @access public
     */
    function _parse_lockinfo($handle)
    {
        // open input stream
        if (!$handle) {
            $this->success = false;
            return;
        }

        // success state flag
        $this->success = true;

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

        // create namespace aware XML parser
        $parser = xml_parser_create_ns('UTF-8', ' ');

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

        xml_set_character_data_handler($parser, array(&$this, '_data'));

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

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

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

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

        // free parser resource
        xml_parser_free($parser);

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

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

        // everything within the <owner> tag needs to be collected
        if ($this->collect_owner) {
            $ns_short = '';
            $ns_attr = '';
            if ($ns) {
                if ($ns == 'DAV:') {
                    $ns_short = 'D:';
                } else {
                    $ns_attr = ' xmlns="' . $ns . '"';
                }
            }
            $this->owner .= "<$ns_short$name$ns_attr>";
        } else if ($ns == 'DAV:') {
            // parse only the essential tags
            switch ($name) {
            case 'write':
                $this->locktype = $name;
                break;
            case 'exclusive':
            case 'shared':
                $this->lockscope = $name;
                break;
            case 'owner':
                $this->collect_owner = true;
                break;
            }
        }
    }

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

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

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

    /**
     * Character data handler
     *
     * @access private
     * @param resource parser
     * @param string data
     * @return void
     */
    function _data($parser, $data)
    {
        // only the <owner> tag has data content
        if ($this->collect_owner) {
            $this->owner .= $data;
        }
    }
}
?>
');
expand_6421a0d81d($outputDir, 'lib/HTTP/WebDAV/Tools/_parse_propfind.php', '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');
expand_6421a0d81d($outputDir, 'lib/HTTP/WebDAV/Tools/_parse_proppatch.php', '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');
expand_6421a0d81d($outputDir, 'module.inc', '<?php
/*
 * Gallery - a web based photo album viewer and editor
 * Copyright (C) 2000-2007 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.
 */

/**
 * WebDAV Module.  Mount Gallery on your desktop.
 * @package WebDav
 * @author Jack Bates <ms419@freezone.co.uk>
 * @version $Revision: 16471 $
 */
class WebDavModule extends GalleryModule /* and GalleryEventListener */ {

    function WebDavModule() {
	global $gallery;

	$this->setId('webdav');
	$this->setName($gallery->i18n('WebDAV'));
	$this->setVersion('1.0.0.2'); /* Update upgrade() too! */
	$this->setDescription($gallery->i18n('Mount Gallery on your desktop.'));
	$this->setGroup('interfaces', $gallery->i18n('Remote Interfaces'));
	$this->setCallbacks('getItemLinks|getSiteAdminViews|registerEventListeners');
	$this->setRequiredCoreApi(array(7, 17));
	$this->setRequiredModuleApi(array(3, 5));
    }

    /**
     * @see GalleryModule::performFactoryRegistrations
     */
    function performFactoryRegistrations() {
	$ret = GalleryCoreApi::registerFactoryImplementation(
	    'ItemAddPlugin', 'ItemAddWebDav', 'ItemAddWebDav',
	    'modules/webdav/ItemAddWebDav.inc', 'webdav', null);
	if ($ret) {
	    return $ret;
	}
    }

    /**
     * @see GalleryModule::registerEventListeners
     */
    function registerEventListeners() {
	return GalleryCoreApi::registerEventListener(
	    'Gallery::ActivatePlugin', new WebDavModule(), true);
    }

    /**
     * @see GalleryModule::upgrade
     */
    function upgrade($currentVersion) {
	global $gallery;

	switch ($currentVersion) {
	case null:
	    /* Initial install */

	    /* Activate essential rewrite rules */
	    $ret = $this->_activateRewriteRules();
	    if ($ret && !($ret->getErrorCode() & ERROR_CONFIGURATION_REQUIRED)) {
		return $ret;
	    }

	    break;

	case '0.0.3':
	    /* Add WebDavSiteAdmin and WebDavLockMap */

	case '0.0.4':
	    /* Add modules/webdav/webdav.php and WebDavUrlGenerator */

	case '0.0.5':
	    /* Add WebDavInitEventListener */

	case '0.0.6':
	    /* Add item link */

	case '0.2.0':
	    /*
	     * Activate essential short URL rules automatically
	     * Set HTTP response status on all errors
	     */

	case '0.3.0':
	    /*
	     * Eliminate WebDavUrlGenerator, WebDavInitEventListener and WebDavSiteAdmin
	     * Register WebDavActivatePluginEventListener
	     */

	case '0.4.0':
	    /*
	     * Move parsePath from WebDavHelper to WebDavRewriteHelper, to avoid loading
	     * WebDavHelper just to generate URLs
	     */

	case '0.4.1':
	    /* Add GalleryView::isControllerLike to WebDAV view */

	case '0.4.2':
	    /* Add support for the php-cgi server API */

	case '0.6.0':
	    /* Remove view with WebDAV permission */
	    $ret = GalleryCoreApi::unregisterModulePermissions($this->getId());
	    if ($ret) {
		return $ret;
	    }
	case '0.6.1':
	    /*
	     * Add dependency on latest changes in GalleryModule::getRewriteRules and on
	     * GalleryUrlGenerator::generateUrl's protocol option.
	     */

	case '0.6.2':
	    /* Add configuration checks */
	case '0.7.0':
	    /* Add whitelist for external interface */
	case '0.7.1':
	    /* Rename WebDavMount to DownloadDavMount */
	case '0.7.2':
	    /* Add HttpAuth check through interface */
	case '0.7.3':
	    /* Version 1.0.0 for Gallery 2.2 release */

	case '1.0.0':
	    /* Avoid matching paths starting with 'w[^/]' with URL rewrite rule keyword */
	    $ret = $this->_activateRewriteRules();
	    if ($ret && !($ret->getErrorCode() & ERROR_CONFIGURATION_REQUIRED)) {
		return $ret;
	    }
	case '1.0.0.1':
	    /* Fix entity-type bug (1681406) */

	case 'end of upgrade path':
	    break;

	default:
	    return GalleryCoreApi::error(ERROR_BAD_PLUGIN, __FILE__, __LINE__,
		sprintf('Unknown module version %s', $currentVersion));
	}
    }

    /**
     * @see GalleryModule::activate
     * @todo The explicit rewrite module version check can be removed on the next major Module API
     *       version.
     */
    function activate($postActivationEvent=true) {
	/* Ensure the rewrite module is compatible, 'pattern' is optional since v1.1.8 of rewrite */
	list ($ret, $modules) = GalleryCoreApi::fetchPluginList('module');
	if ($ret) {
	    return array($ret, null);
	}

	if (isset($modules['rewrite'])) {
	    list ($ret, $rewrite) = GalleryCoreApi::loadPlugin('module', 'rewrite', true);
	    if ($ret) {
		return array($ret, null);
	    }

	    if (version_compare($rewrite->getVersion(), '1.1.8', '<')) {
		return array(GalleryCoreApi::error(ERROR_CONFIGURATION_REQUIRED), null);
	    }
	}

	list ($ret, $redirect) = parent::activate($postActivationEvent);
	if ($ret) {
	    return array($ret, null);
	}

	return array(null, $redirect);
    }

    /**
     * @see GalleryModule::getItemLinks
     */
    function getItemLinks($items, $wantsDetailedLinks, $permissions, $userId) {
	$links = array();
	foreach ($items as $item) {
	    if (!$item->getCanContainChildren() || empty($wantsDetailedLinks[$item->getId()])) {
		continue;
	    }
	    $links[$item->getId()][] = array(
			'text' => $this->translate('Mount with WebDAV'),
			'params' => array('view' => 'webdav.WebDavMount',
					  'itemId' => $item->getId()));
	}

	return array(null, $links);
    }

    /**
     * @see GalleryModule::getSiteAdminViews
     */
    function getSiteAdminViews() {
	return array(null, array(array('name' => $this->translate($this->getName()),
				       'view' => 'webdav.WebDavSiteAdmin')));
    }

    /**
     * @see GalleryModule::getRewriteRules
     */
    function getRewriteRules() {
	global $gallery;
	$urlGenerator =& $gallery->getUrlGenerator();

	$rules = array();

	/* Use short URL because most WebDAV clients don't support query strings */
	$rules['connect'] = array(
	    'comment' => $this->translate('Connect to WebDAV'),
	    'help' => $this->translate(
		'Use short URL because most WebDAV clients don\'t support query strings.'
		. '  The Windows WebDAV client requires that you don\'t add a slash before the'
		. ' %path% variable.'),
	    'match' => array('controller' => 'webdav.WebDav'),
	    'pattern' => 'w%path%',
	    'keywords' => array(
		'path' => array(
		    'pattern' => '(/[^?]*)?',
		    'function' => array('webdav', 'WebDavRewriteHelper', 'parsePath'),
		    'help' => $this->translate('Path to an item (eg. /album/image.jpg.html)'))));

	/* Give davmount resources the correct extension */
	$rules['davmount'] = array(
	    'comment' => $this->translate('Mount WebDAV'),
	    'help' => $this->translate(
		'Give davmount resources the correct extension.'),
	    'match' => array('view' => 'webdav.DownloadDavMount'),

	    /* TODO: How to work with the root album? */
	    'pattern' => 'v/%path%.davmount',
	    'keywords' => array(
		'path' => array(
		    'pattern' => '([^?]+)',
		    'function' => array('rewrite', 'RewriteSimpleHelper', 'parsePath'),
		    'help' => $this->translate('Path to an item (eg. /album/image.jpg.html)'))),
	    'onLoad' => array('rewrite', 'RewriteSimpleHelper', 'loadItemIdFromPath'));

	/*
	 * Only define the rule to redirect OPTIONS requests so we can set DAV headers if it is
	 * already active, or if OPTIONS responses are missing DAV headers
	 */
	list ($ret, $rewriteApi) = GalleryCoreApi::newFactoryInstance('RewriteApi');
	if ($ret) {
	    if ($gallery->getDebug()) {
		$gallery->debug('Error in WebDavModule::getRewriteRules: ' . $ret->getAsText());
	    }
	    return $rules;
	}
	if (!isset($rewriteApi)) {
	    return $rules;
	}

	list ($ret, $isCompatible) = $rewriteApi->isCompatibleWithApi(array(1, 1));
	if ($ret) {
	    if ($gallery->getDebug()) {
		$gallery->debug('Error in WebDavModule::getRewriteRules: ' . $ret->getAsText());
	    }
	    return $rules;
	}
	if (!$isCompatible) {
	    return $rules;
	}

	list ($ret, $activeRules) = $rewriteApi->fetchActiveRulesForModule($this->getId());
	if ($ret) {
	    if ($gallery->getDebug()) {
		$gallery->debug('Error in WebDavModule::getRewriteRules: ' . $ret->getAsText());
	    }
	    return $rules;
	}
	if (!in_array('options', $activeRules)) {
	    /* Check that OPTIONS responses include the DAV headers */
	    GalleryCoreApi::requireOnce('modules/webdav/classes/WebDavHelper.class');
	    if (WebDavHelper::checkDavHeaders($urlGenerator->generateUrl(
		    array('controller' => 'webdav.WebDav'),
		    array('forceFullUrl' => true,
			  'htmlEntities' => false)))) {
		return $rules;
	    }
	}

	/* Redirect OPTIONS requests so we can set DAV headers */
	$rules['options'] = array(
	    'comment' => $this->translate('OPTIONS Requests'),
	    'help' => $this->translate(
		'Redirect OPTIONS requests so we can set DAV headers.'),

	    /* Use trailing '/' to avoid 301 Moved Permanently */
	    'match' => array('href' => 'modules/webdav/data/options/'),
	    'conditions' => array(array('test' => 'REQUEST_METHOD',
					'pattern' => 'OPTIONS')));

	return $rules;
    }

    /**
     * @see GalleryEventListener::handleEvent
     */
    function handleEvent($event) {
	switch ($event->getEventName()) {
	case 'Gallery::ActivatePlugin':
	    $data = $event->getData();
	    if ($data['pluginType'] != 'module' || $data['pluginId'] != 'rewrite') {
		return array(null, null);
	    }

	    $ret = $this->_activateRewriteRules();
	    if ($ret && !($ret->getErrorCode() & ERROR_CONFIGURATION_REQUIRED)) {
		return array($ret, null);
	    }

	    return array(null, null);

	case 'Gallery::Error':
	    $data = $event->getData();
	    if (($data['error']->getErrorCode() & ERROR_PERMISSION_DENIED)) {
		/* Prompt for authentication */
		list ($ret, $httpAuthInterface) =
		    GalleryCoreApi::newFactoryInstance('HttpAuthInterface_1_0');
		if ($ret) {
		    return array($ret, null);
		}
		if (isset($httpAuthInterface)) {
		    $ret = $httpAuthInterface->requestAuthentication();
		    if ($ret) {
			return array($ret, null);
		    }
		}
	    }

	    /* Suppress generating HTML error pages for WebDAV clients */
	    return array(null, array('suppressBody' => true));
	}

	return array(null, null);
    }

    /**
     * Activate essential rewrite rules.
     * @return object GalleryStatus a status code
     */
    function _activateRewriteRules() {
	list ($ret, $rewriteApi) = GalleryCoreApi::newFactoryInstance('RewriteApi');
	if ($ret) {
	    return $ret;
	}
	if (!isset($rewriteApi)) {
	    return GalleryCoreApi::error(ERROR_CONFIGURATION_REQUIRED);
	}

	list ($ret, $isCompatible) = $rewriteApi->isCompatibleWithApi(array(1, 1));
	if ($ret) {
	    return $ret;
	}
	if (!$isCompatible) {
	    return GalleryCoreApi::error(ERROR_CONFIGURATION_REQUIRED);
	}

	list ($ret, $success) = $rewriteApi->activateRewriteRulesForModule($this->getId());
	if ($ret) {
	    return $ret;
	}
	if (!$success) {
	    return GalleryCoreApi::error(ERROR_CONFIGURATION_REQUIRED);
	}

	return null;
    }
}
?>
');
expand_6421a0d81d($outputDir, 'po/GNUmakefile', 'R0FMTEVSWURJUiA/PSAuLi8uLi8uLgpUT09MRElSID89ICQoR0FMTEVSWURJUikvbGliL3Rvb2xzCgppbmNsdWRlICQoVE9PTERJUikvcG8vR05VbWFrZWZpbGUuaW5jCgo=');
expand_6421a0d81d($outputDir, 'po/strings.raw', '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');
expand_6421a0d81d($outputDir, 'templates/ItemAddWebDav.tpl', 'eyoKICogJFJldmlzaW9uOiAxNTcwNCAkCiAqIElmIHlvdSB3YW50IHRvIGN1c3RvbWl6ZSB0aGlzIGZpbGUsIGRvIG5vdCBlZGl0IGl0IGRpcmVjdGx5IHNpbmNlIGZ1dHVyZSB1cGdyYWRlcwogKiBtYXkgb3ZlcndyaXRlIGl0LiAgSW5zdGVhZCwgY29weSBpdCBpbnRvIGEgbmV3IGRpcmVjdG9yeSBjYWxsZWQgImxvY2FsIiBhbmQgZWRpdCB0aGF0CiAqIHZlcnNpb24uICBHYWxsZXJ5IHdpbGwgbG9vayBmb3IgdGhhdCBmaWxlIGZpcnN0IGFuZCB1c2UgaXQgaWYgaXQgZXhpc3RzLgogKn0KPGRpdiBjbGFzcz0iZ2JCbG9jayI+CntpbmNsdWRlIGZpbGU9ImdhbGxlcnk6bW9kdWxlcy93ZWJkYXYvdGVtcGxhdGVzL1dlYkRhdk1vdW50LnRwbCIgaXNWaWV3PWZhbHNlfQo8L2Rpdj4K');
expand_6421a0d81d($outputDir, 'templates/WebDavMount.tpl', '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');
expand_6421a0d81d($outputDir, 'templates/WebDavSiteAdmin.tpl', '{*
 * $Revision: 15721 $
 * If you want to customize this file, do not edit it directly since future upgrades
 * may overwrite it.  Instead, copy it into a new directory called "local" and edit that
 * version.  Gallery will look for that file first and use it if it exists.
 *}
<div class="gbBlock gcBackground1">
  <h2> {g->text text="WebDAV Settings"} </h2>
</div>

{if !$WebDavSiteAdmin.code}
  <div class="gbBlock">
    <h3 class="giSuccess"> {g->text text="Configuration checked successfully"} </h3>

    <p class="giDescription">
      {g->text text="Most WebDAV clients will successfully connect.  Documentation on mounting Gallery with WebDAV is in the %sGallery Codex%s." arg1="<a href=\"http://codex.gallery2.org/index.php/Gallery2:Modules:webdav:user\">" arg2="</a>"}
    </p>

    <p class="giDescription">
      {g->text text="The URL to connect to Gallery with WebDAV is:"} <a href="{g->url arg1="controller=webdav.WebDav" forceFullUrl=true forceSessionId=false useAuthToken=false}"> {g->url arg1="controller=webdav.WebDav" forceFullUrl=true forceSessionId=false useAuthToken=false} </a>
    </p>
  </div>
{/if}

{if $WebDavSiteAdmin.code & WEBDAV_STATUS_NO_XML_PARSER}
  <div class="gbBlock">
    <h3 class="giError"> {g->text text="PHP has no XML support"} </h3>

    <p class="giDescription">
      {g->text text="You can't connect with WebDAV because PHP has no XML support on this server.  Troubleshooting documentation is in the %sGallery Codex%s." arg1="<a href=\"http://codex.gallery2.org/index.php/Gallery2:Modules:webdav:admin\">" arg2="</a>"}
    </p>
  </div>
{/if}

{if $WebDavSiteAdmin.code & WEBDAV_STATUS_METHOD_NOT_HANDLED}
  <div class="gbBlock">
    <h3 class="giError"> {g->text text="WebDAV requests not handled"} </h3>

    <p class="giDescription">
      {g->text text="You can't connect with WebDAV because this server doesn't pass WebDAV requests to Gallery.  Troubleshooting documentation is in the %sGallery Codex%s." arg1="<a href=\"http://codex.gallery2.org/index.php/Gallery2:Modules:webdav:admin\">" arg2="</a>"}
    </p>
  </div>
{/if}

{if $WebDavSiteAdmin.code & WEBDAV_STATUS_HTTPAUTH_MODULE_DISABLED}
  <div class="gbBlock">
    <h3 class="giWarning"> {g->text text="HTTP auth module disabled"} </h3>

    <p class="giDescription">
      {capture assign="adminPluginsUrl"}{g->url arg1="view=core.SiteAdmin" arg2="subView=core.AdminPlugins" return=true}{/capture}
      {g->text text="You can connect with WebDAV anonymously, but you can't do anything which requires you to login because the HTTP auth module is disabled.  You should activate the HTTP auth module in the %sSite Admin Plugins option%s.  Troubleshooting documentation is in the %sGallery Codex%s." arg1="<a href=\"$adminPluginsUrl\">" arg2="</a>" arg3="<a href=\"http://codex.gallery2.org/index.php/Gallery2:Modules:webdav:admin\">" arg4="</a>"}
    </p>
  </div>
{elseif $WebDavSiteAdmin.code & WEBDAV_STATUS_HTTPAUTH_AUTH_PLUGINS_DISABLED}
  <div class="gbBlock">
    <h3 class="giWarning"> {g->text text="HTTP auth plugin disabled"} </h3>

    <p class="giDescription">
      {g->text text="You can connect with WebDAV anonymously, but you can't do anything which requires you to login because neither HTTP authentication nor server authentication are enabled in the HTTP auth module.  You should activate HTTP authentication in the settings of the HTTP auth module."}
    </p>
  </div>

{/if}

{if $WebDavSiteAdmin.code & WEBDAV_STATUS_CONNECT_RULE_DISABLED}
  <div class="gbBlock">
    <h3 class="giWarning"> {g->text text="'Connect to WebDAV' rule disabled"} </h3>

    <p class="giDescription">
      {capture assign="adminRewriteUrl"}{g->url arg1="view=core.SiteAdmin" arg2="subView=rewrite.AdminRewrite" return=true}{/capture}
      {g->text text="Most WebDAV clients will fail to connect because the URL rewrite rule to generate short WebDAV URLs is disabled.  You should activate the 'Connect to WebDAV' rule in the %sSite Admin URL Rewrite option%s.  Troubleshooting documentation is in the %sGallery Codex%s." arg1="<a href=\"$adminRewriteUrl\">" arg2="</a>" arg3="<a href=\"http://codex.gallery2.org/index.php/Gallery2:Modules:webdav:admin\">" arg4="</a>"}
    </p>

    <p class="giDescription">
      {g->text text="The URL to connect to Gallery with WebDAV is:"} <a href="{g->url arg1="controller=webdav.WebDav" forceFullUrl=true forceSessionId=false useAuthToken=false}"> {g->url arg1="controller=webdav.WebDav" forceFullUrl=true forceSessionId=false useAuthToken=false} </a>
    </p>
  </div>
{/if}

{if $WebDavSiteAdmin.code & WEBDAV_STATUS_MISSING_DAV_HEADERS}
  <div class="gbBlock">
    <h3 class="giWarning"> {g->text text="Missing DAV headers"} </h3>

    <p class="giDescription">
      {g->text text="Some WebDAV clients, e.g. Mac OS X WebDAVFS, will fail to connect because OPTIONS responses are missing DAV headers.  Troubleshooting documentation is in the %sGallery Codex%s." arg1="<a href=\"http://codex.gallery2.org/index.php/Gallery2:Modules:webdav:admin\">" arg2="</a>"}
    </p>
  </div>
{/if}

{if $WebDavSiteAdmin.code & WEBDAV_STATUS_ALTERNATIVE_URL_HEADERS}
  <div class="gbBlock">
    <h3 class="giWarning"> {g->text text="Alternative URL missing DAV headers"} </h3>

    <p class="giDescription">
      {g->text text="Because OPTIONS responses are missing DAV headers, we try to fall back on an alternative URL, but alternative URL responses are also missing DAV headers.  Troubleshooting documentation is in the %sGallery Codex%s." arg1="<a href=\"http://codex.gallery2.org/index.php/Gallery2:Modules:webdav:admin\">" arg2="</a>"}
    </p>
  </div>
{/if}

{if $WebDavSiteAdmin.code & WEBDAV_STATUS_REWRITE_MODULE_DISABLED}
  <div class="gbBlock">
    <h3 class="giWarning"> {g->text text="URL rewrite module disabled"} </h3>

    <p class="giDescription">
      {capture assign="adminPluginsUrl"}{g->url arg1="view=core.SiteAdmin" arg2="subView=core.AdminPlugins" return=true}{/capture}
      {g->text text="Most WebDAV clients will fail to connect because the URL rewrite module is disabled.  You should activate the URL rewrite module in the %sSite Admin Plugins option%s and choose either Apache mod_rewrite or ISAPI_Rewrite.  Troubleshooting documentation is in the %sGallery Codex%s." arg1="<a href=\"$adminPluginsUrl\">" arg2="</a>" arg3="<a href=\"http://codex.gallery2.org/index.php/Gallery2:Modules:webdav:admin\">" arg4="</a>"}
    </p>
  </div>
{/if}

{if $WebDavSiteAdmin.code & WEBDAV_STATUS_BAD_REWRITE_PARSER}
  <div class="gbBlock">
    <h3 class="giWarning"> {g->text text="Bad URL rewrite configuration"} </h3>

    <p class="giDescription">
      {capture assign="adminPluginsUrl"}{g->url arg1="view=core.SiteAdmin" arg2="subView=core.AdminPlugins" return=true}{/capture}
      {g->text text="PHP PathInfo rewrite doesn't support the rule to fall back on an alternative URL.  You should uninstall and reinstall the URL rewrite module in the %sSite Admin Plugins option%s and choose either Apache mod_rewrite or ISAPI_Rewrite.  Troubleshooting information is in the %sGallery Codex%s." arg1="<a href=\"$adminPluginsUrl\">" arg2="</a>" arg3="<a href=\"http://codex.gallery2.org/index.php/Gallery2:Modules:webdav:admin\">" arg4="</a>"}
    </p>
  </div>
{/if}

{if $WebDavSiteAdmin.code & WEBDAV_STATUS_OPTIONS_RULE_DISABLED}
  <div class="gbBlock">
    <h3 class="giWarning"> {g->text text="'OPTIONS Requests' rule disabled"} </h3>

    <p class="giDescription">
      {capture assign="adminRewriteUrl"}{g->url arg1="view=core.SiteAdmin" arg2="subView=rewrite.AdminRewrite" return=true}{/capture}
      {g->text text="The URL rewrite rule to fall back on an alternative URL is disabled.  You should activate the WebDAV 'OPTIONS Requests' rule in the %sSite Admin URL Rewrite option%s.  Troubleshooting documentation is in the %sGallery Codex%s." arg1="<a href=\"$adminRewriteUrl\">" arg2="</a>" arg3="<a href=\"http://codex.gallery2.org/index.php/Gallery2:Modules:webdav:admin\">" arg4="</a>"}
    </p>
  </div>
{/if}

{if $WebDavSiteAdmin.code & WEBDAV_STATUS_ERROR_UNKNOWN}
  <div class="gbBlock">
    <h3 class="giWarning"> {g->text text="Unknown Cause"} </h3>

    <p class="giDescription">
      {g->text text="Some WebDAV clients, e.g. Mac OS X WebDAVFS, will fail to connect and automated checks failed to find a cause.  Troubleshooting documentation is in the %sGallery Codex%s." arg1="<a href=\"http://codex.gallery2.org/index.php/Gallery2:Modules:webdav:admin\">" arg2="</a>"}
    </p>
  </div>
{/if}
');
expand_6421a0d81d($outputDir, 'templates/blocks/WebDavUrl.tpl', 'eyoKICogJFJldmlzaW9uOiAxNTcwNCAkCiAqIElmIHlvdSB3YW50IHRvIGN1c3RvbWl6ZSB0aGlzIGZpbGUsIGRvIG5vdCBlZGl0IGl0IGRpcmVjdGx5IHNpbmNlIGZ1dHVyZSB1cGdyYWRlcwogKiBtYXkgb3ZlcndyaXRlIGl0LiAgSW5zdGVhZCwgY29weSBpdCBpbnRvIGEgbmV3IGRpcmVjdG9yeSBjYWxsZWQgImxvY2FsIiBhbmQgZWRpdCB0aGF0CiAqIHZlcnNpb24uICBHYWxsZXJ5IHdpbGwgbG9vayBmb3IgdGhhdCBmaWxlIGZpcnN0IGFuZCB1c2UgaXQgaWYgaXQgZXhpc3RzLgogKn0KPGRpdiBjbGFzcz0ieyRjbGFzc30iPgogIDxoMz4ge2ctPnRleHQgdGV4dD0iV2ViREFWIFVSTCJ9IDwvaDM+CntpbmNsdWRlIGZpbGU9ImdhbGxlcnk6bW9kdWxlcy93ZWJkYXYvdGVtcGxhdGVzL1dlYkRhdk1vdW50LnRwbCIgaXNWaWV3PWZhbHNlfQo8L2Rpdj4KIA==');
expand_6421a0d81d($outputDir, 'templates/blocks/blocks.inc', 'PD9waHAKJGJsb2NrcyA9IGFycmF5KAogICAgJ1dlYkRhdlVybCcgPT4gYXJyYXkoCgknZGVzY3JpcHRpb24nID0+ICRnYWxsZXJ5LT5pMThuKCdXZWJEQVYgVVJMJykpKTsKPz4K');
}
function expand_6421a0d81d($outputDir, $relativePath, $data) {
$fd = fopen($outputDir . $relativePath, 'w');
fwrite($fd, base64_decode($data));
fclose($fd);
}
$unpackFunction = "unpack_6421a0d81d";
?>
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists