mod_dav.c revision 4b28d4385b48010bc271cba9b40b56e458cbd5d8
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2000 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
*/
/*
** DAV extension module for Apache 2.0.*
**
** This module is repository-independent. It depends on hooks provided by a
** repository implementation.
**
** APACHE ISSUES:
** - within a DAV hierarchy, if an unknown method is used and we default
** to Apache's implementation, it sends back an OPTIONS with the wrong
** set of methods -- there is NO HOOK for us.
** therefore: we need to manually handle the HTTP_METHOD_NOT_ALLOWED
** and HTTP_NOT_IMPLEMENTED responses (not ap_send_error_response).
** - process_mkcol_body() had to dup code from ap_setup_client_block().
** - it would be nice to get status lines from Apache for arbitrary
** status codes
** - it would be nice to be able to extend Apache's set of response
** codes so that it doesn't return 500 when an unknown code is placed
** into r->status.
** - http_vhost functions should apply "const" to their params
**
** DESIGN NOTES:
** - For PROPFIND, we batch up the entire response in memory before
** sending it. We may want to reorganize around sending the information
** as we suck it in from the propdb. Alternatively, we should at least
** generate a total Content-Length if we're going to buffer in memory
** so that we can keep the connection open.
*/
#include "httpd.h"
#include "http_config.h"
#include "http_core.h"
#include "http_log.h"
#include "http_main.h"
#include "http_protocol.h"
#include "http_request.h"
#include "util_script.h"
#include "mod_dav.h"
#include "dav_opaquelock.h"
enum {
DAV_ENABLED_UNSET = 0,
};
/* per-dir configuration */
typedef struct {
int enabled;
const char *dir;
int locktimeout;
int handle_get; /* cached from repository hook structure */
int allow_depthinfinity;
} dav_dir_conf;
/* per-server configuration */
typedef struct {
/* forward-declare for use in configuration lookup */
server_rec *s)
{
/* DBG0("dav_init_handler"); */
}
{
return newconf;
}
{
/* ### hmm. we should share the uuid state rather than copy it. if we
### do another merge, then we'll just get the old one, rather than
### an updated state.
### of course... the UUID generation should move into APR
*/
return newconf;
}
{
/* NOTE: dir==NULL creates the default per-dir config */
return conf;
}
{
/* DBG3("dav_merge_dir_config: new=%08lx base=%08lx overrides=%08lx",
(long)newconf, (long)base, (long)overrides); */
return newconf;
}
{
}
{
}
{
void *data;
const dav_hooks_locks *hooks;
hooks = ap_run_get_lock_hooks(r);
r->pool);
}
else
return hooks;
}
{
void *data;
const dav_hooks_db *hooks;
hooks = ap_run_get_propdb_hooks(r);
r->pool);
}
else
return hooks;
}
{
void *data;
const dav_hooks_vsn *hooks;
hooks = ap_run_get_vsn_hooks(r);
r->pool);
}
else
return hooks;
}
/*
* Command handler for the DAV directive, which is FLAG.
*/
{
if (arg)
else
return NULL;
}
/*
* Command handler for the DAVDepthInfinity directive, which is FLAG.
*/
int arg)
{
if (arg)
else
return NULL;
}
/*
* Command handler for DAVMinTimeout directive, which is TAKE1
*/
const char *arg1)
{
if (conf->locktimeout < 0)
return "DAVMinTimeout requires a non-negative integer.";
return NULL;
}
/*
* Command handler for DAVParam directive, which is TAKE2
*/
{
return NULL;
}
/*
** dav_error_response()
**
** Send a nice response back to the user. In most cases, Apache doesn't
** allow us to provide details in the body about what happened. This
** function allows us to completely specify the response body.
*/
{
r->content_type = "text/html";
/* since we're returning DONE, ensure the request body is consumed. */
(void) ap_discard_request_body(r);
/* begin the response now... */
ap_rvputs(r,
r->status_line,
&r->status_line[4],
NULL);
/* the response has been sent. */
/*
* ### Use of DONE obviates logging..!
*/
return DONE;
}
/*
** Apache's URI escaping does not replace '&' since that is a valid character
** in a URI (to form a query section). We must explicitly handle it so that
** we can embed the URI into an XML document.
*/
{
/* check the easy case... */
return e_uri;
/* more work needed... sigh. */
/*
** Note: this is a teeny bit of overkill since we know there are no
** '<' or '>' characters, but who cares.
*/
return ap_xml_quote_string(p, e_uri, 0);
}
{
/* Set the correct status and Content-Type */
/* Send all of the headers now */
/* Send the actual multistatus response now... */
"<D:multistatus xmlns:D=\"DAV:\"", r);
if (namespaces != NULL) {
int i;
for (i = namespaces->nelts; i--; ) {
ap_rprintf(r, " xmlns:ns%d=\"%s\"", i,
}
}
/* ap_rputc('>', r); */
ap_text *t;
ap_rputs("<D:response>", r);
}
else {
ap_rputs("<D:response", r);
}
ap_rputc('>', r);
}
/* use the Status-Line text from Apache. Note, this will
* default to 500 Internal Server Error if first->status
* is not a known (or valid) status code. */
ap_rprintf(r,
"<D:status>HTTP/1.1 %s</D:status>" DEBUG_CR,
}
else {
/* assume this includes <propstat> and is quoted properly */
}
}
/*
** We supply the description, so we know it doesn't have to
*/
ap_rputs("<D:responsedescription>", r);
}
}
}
/*
** dav_log_err()
**
** Write error information to the log.
*/
{
/* Log the errors */
/* ### should have a directive to log the first or all */
continue;
if (errscan->save_errno != 0) {
}
else {
"%s [%d, #%d]",
}
}
}
/*
** dav_handle_err()
**
** Handle the standard error processing. <err> must be non-NULL.
**
** <response> is set by the following:
** - dav_validate_request()
** - dav_add_lock()
** - repos_hooks->remove_resource
** - repos_hooks->move_resource
** - repos_hooks->copy_resource
*/
{
/* log the errors */
/* our error messages are safe; tell Apache this */
}
/* since we're returning DONE, ensure the request body is consumed. */
(void) ap_discard_request_body(r);
return DONE;
}
/* handy function for return values of methods that (may) create things */
int replaced)
{
const char *body;
rnew = r;
}
/* did the target resource already exist? */
if (replaced) {
/* Apache will supply a default message */
return HTTP_NO_CONTENT;
}
/* Per HTTP/1.1, S10.2.2: add a Location header to contain the
* URI that was created. */
/* ### rnew->uri does not contain an absoluteURI. S14.30 states that
* ### the Location header requires an absoluteURI. where to get it? */
/* ### disable until we get the right value */
#if 0
#endif
/* ### insert an ETag header? see HTTP/1.1 S10.2.2 */
/* Apache doesn't allow us to set a variable body for HTTP_CREATED, so
* we must manufacture the entire response. */
what,
}
/* ### move to dav_util? */
{
return def_depth;
}
return DAV_INFINITY;
}
return 0;
}
return 1;
}
/* The caller will return an HTTP_BAD_REQUEST. This will augment the
* default message that Apache provides. */
"An invalid Depth header was specified.");
return -1;
}
static int dav_get_overwrite(request_rec *r)
{
return 1; /* default is "T" */
}
return 0;
}
return 1;
}
/* The caller will return an HTTP_BAD_REQUEST. This will augment the
* default message that Apache provides. */
"An invalid Overwrite header was specified.");
return -1;
}
/* resolve a request URI to a resource descriptor */
{
void *data;
/* go look for the resource if it isn't already present */
int rv;
/* have somebody store it into the request's user data... */
/* Apache will supply a default error for this. */
return HTTP_NOT_FOUND;
}
return rv;
}
return OK;
}
{
return NULL;
}
/* open the thing lazily */
}
static int dav_parse_range(request_rec *r,
{
const char *range_c;
char *range;
char *dash;
char *slash;
return 0;
/* malformed header. ignore it (per S14.16 of RFC2616) */
return 0;
}
if (*range_end < *range_start
/* invalid range. ignore it (per S14.16 of RFC2616) */
return 0;
}
/* we now have a valid range */
return 1;
}
/* handle the GET method */
static int dav_method_get(request_rec *r)
{
int result;
/* This method should only be called when the resource is not
* visible to Apache. We will fetch the resource from the repository,
* then create a subrequest for Apache to handle.
*/
return result;
/* Apache will supply a default error for this. */
return HTTP_NOT_FOUND;
}
/* Check resource type */
return dav_error_response(r, HTTP_CONFLICT,
"Cannot GET this type of resource.");
}
/* Cannot handle GET of a collection from a repository */
if (resource->collection) {
return dav_error_response(r, HTTP_CONFLICT,
"No default response to GET for a "
"collection.");
}
/*
** We can use two different approaches for a GET.
**
** 1) get_pathname will return a pathname to a file which should be
** sent to the client. If the repository provides this, then we
** use it.
**
** This is the best alternative since it allows us to do a sub-
** request on the file, which gives the Apache framework a chance
** to deal with negotiation, MIME types, or whatever.
**
** 2) open_stream and read_stream.
*/
const char *pathname;
void *fhandle;
/* Ask repository for copy of file */
return HTTP_NOT_FOUND;
}
/* Convert to canonical filename, so Apache detects component
* separators (on Windows, it only looks for '/', not '\')
*/
/* Create a sub-request with the new filename */
return HTTP_INTERNAL_SERVER_ERROR;
}
/* This may be a HEAD request */
/* ### this enables header generation */
new_req->assbackwards = 0;
/* Run the sub-request */
/* Free resources */
return result;
}
else {
void *buffer;
int has_range;
/* set up the HTTP headers for the response */
"Unable to set up HTTP headers.",
err);
}
/* use plain READ mode unless we see a Content-Range */
/* process the Content-Range header (if present) */
if (has_range) {
/* use a read mode which is seekable */
/* prep the output */
r->status = HTTP_PARTIAL_CONTENT;
"Content-Range",
range_start, range_end));
}
if (r->header_only) {
return DONE;
}
/* ### assuming FORBIDDEN is probably not quite right... */
ap_psprintf(r->pool,
"Unable to GET contents for %s.",
err);
}
if (has_range
range_start)) != NULL) {
"Could not seek to beginning of the "
"specified Content-Range.", err);
}
/* all set. send the headers now. */
while (1) {
if (!has_range)
else {
/* note: range_end - range_start is an ssize_t */
}
break;
}
if (amt == 0) {
/* no more content */
break;
}
/* ### what to do with this error? */
break;
}
if (has_range) {
range_start += amt;
if (range_start > range_end)
break;
}
}
/*
** ### range_start should equal range_end+1. if it doesn't, then
** ### we did not send enough data to the client. the client will
** ### hang (and timeout) waiting for the data.
**
** ### what to do? abort the connection?
*/
return DONE;
}
/* NOTREACHED */
}
/* validate resource on POST, then pass it off to the default handler */
static int dav_method_post(request_rec *r)
{
int result;
/* Ask repository module to resolve the resource */
return result;
}
/* Note: depth == 0. Implies no need for a multistatus response. */
/* ### add a higher-level description? */
}
return DECLINED;
}
/* handle the PUT method */
static int dav_method_put(request_rec *r)
{
int resource_state;
const char *body;
int result;
int resource_existed = 0;
int resource_was_writable = 0;
int parent_was_writable = 0;
int has_range;
return result;
}
/* Ask repository module to resolve the resource */
return result;
}
/* If not a file or collection resource, PUT not allowed */
"Cannot create resource %s with PUT.",
}
/* Cannot PUT a collection */
if (resource->collection) {
return dav_error_response(r, HTTP_CONFLICT,
"Cannot PUT to a collection.");
}
/*
** Note: depth == 0 normally requires no multistatus response. However,
** if we pass DAV_VALIDATE_PARENT, then we could get an error on a URI
** other than the Request-URI, thereby requiring a multistatus.
**
** If the resource does not exist (DAV_RESOURCE_NULL), then we must
** check the resource *and* its parent. If the resource exists or is
** a locknull resource, then we check only the resource.
*/
/* ### add a higher-level description? */
}
/* make sure the resource can be modified (if versioning repository) */
0 /* not parent_only */,
&parent_was_writable)) != NULL) {
/* ### add a higher-level description? */
}
/* truncate and rewrite the file unless we see a Content-Range */
if (has_range) {
}
/* Create the new file in the repository */
/* ### assuming FORBIDDEN is probably not quite right... */
ap_psprintf(r->pool,
"Unable to PUT new contents for %s.",
err);
}
/* a range was provided. seek to the start */
}
if (ap_should_client_block(r)) {
long len;
/*
** Once we start reading the request, then we must read the
** whole darn thing. ap_discard_request_body() won't do anything
** for a partially-read request.
*/
DAV_READ_BLOCKSIZE)) > 0) {
/* write whatever we read, until we see an error */
}
}
/*
** ### specified in the Content-Range? eek...
*/
if (len == -1) {
/*
** Error reading request body. This has precedence over
** prior errors.
*/
"An error occurred while reading the "
"request body.");
}
}
/* no error during the write, but we hit one at close. use it. */
}
}
/*
** Ensure that we think the resource exists now.
** ### eek. if an error occurred during the write and we did not commit,
** ### then the resource might NOT exist (e.g. dav_fs_repos.c)
*/
}
/* restore modifiability of resources back to what they were */
/* check for errors now */
}
/* just log a warning */
"The PUT was successful, but there "
"was a problem reverting the writability of "
"the resource or its parent collection.",
err2);
}
/* ### place the Content-Type and Content-Language into the propdb */
if (locks_hooks != NULL) {
/* The file creation was successful, but the locking failed. */
"The file was PUT successfully, but there "
"was a problem opening the lock database "
"which prevents inheriting locks from the "
"parent resources.",
err);
}
/* The file creation was successful, but the locking failed. */
"The file was PUT successfully, but there "
"was a problem updating its lock "
"information.",
err);
}
}
/* NOTE: WebDAV spec, S8.7.1 states properties should be unaffected */
/* return an appropriate response (HTTP_CREATED or HTTP_NO_CONTENT) */
}
/* ### move this to dav_util? */
{
/* just drop some data into an dav_response */
if (propstats) {
}
}
/* handle the DELETE method */
static int dav_method_delete(request_rec *r)
{
const char *body;
int result;
int depth;
int parent_was_writable = 0;
/* We don't use the request body right now, so torch it. */
return result;
}
/* Ask repository module to resolve the resource */
return result;
/* Apache will supply a default error for this. */
return HTTP_NOT_FOUND;
}
/* 2518 says that depth must be infinity only for collections.
* For non-collections, depth is ignored, unless it is an illegal value (1).
*/
/* This supplies additional information for the default message. */
"Depth must be \"infinity\" for DELETE of a collection.");
return HTTP_BAD_REQUEST;
}
/* This supplies additional information for the default message. */
"Depth of \"1\" is not allowed for DELETE.");
return HTTP_BAD_REQUEST;
}
/* Check for valid resource type */
/* ### allow DAV_RESOURCE_TYPE_REVISION with All-Bindings header */
"Cannot delete resource %s.",
}
/*
** the delete. Each of the failing resources will be listed within
** a DAV:multistatus body, wrapped into a 424 response.
**
** Note that a failure on the resource itself does not generate a
** multistatus response -- only internal members/collections.
*/
ap_psprintf(r->pool,
"Could not DELETE %s due to a failed "
"precondition (e.g. locks).",
err);
}
/* ### RFC 2518 s. 8.10.5 says to remove _all_ locks, not just those
* locked by the token(s) in the if_header.
*/
return result;
}
/* if versioned resource, make sure parent is checked out */
&parent_was_writable)) != NULL) {
/* ### add a higher-level description? */
}
/* try to remove the resource */
/* restore writability of parent back to what it was */
0, 0, parent_was_writable);
/* check for errors now */
ap_psprintf(r->pool,
"Could not DELETE %s.",
err);
}
/* just log a warning */
"The DELETE was successful, but there "
"was a problem reverting the writability of "
"its parent collection.",
err2);
}
/* ### HTTP_NO_CONTENT if no body, HTTP_OK if there is a body (some day) */
/* Apache will supply a default error for this. */
return HTTP_NO_CONTENT;
}
/* handle the OPTIONS method */
static int dav_method_options(request_rec *r)
{
const char *options;
const char *dav_level;
const char *vsn_level;
int result;
const char *uris;
/* per HTTP/1.1 S9.2, we can discard this body */
return result;
}
/* no body */
ap_set_content_length(r, 0);
/* resolve the resource */
return result;
/* determine which providers are available */
dav_level = "1";
if (locks_hooks != NULL) {
dav_level = "1,2";
}
}
/* gather property set URIs from all the liveprop providers */
if (*uris) {
}
/* this tells MSFT products to skip looking for FrontPage extensions */
/*
** Three cases: resource is null (3), is lock-null (7.4), or exists.
**
** All cases support OPTIONS and LOCK.
** (Lock-) null resources also support MKCOL and PUT.
** Lock-null support PROPFIND and UNLOCK.
** Existing resources support lots of stuff.
*/
/* ### take into account resource type */
switch (dav_get_resource_state(r, resource))
{
case DAV_RESOURCE_EXISTS:
/* resource exists */
if (resource->collection) {
"OPTIONS, "
"GET, HEAD, POST, DELETE, TRACE, "
"PROPFIND, PROPPATCH, COPY, MOVE",
NULL);
}
else {
/* files also support PUT */
"OPTIONS, "
"GET, HEAD, POST, DELETE, TRACE, "
"PROPFIND, PROPPATCH, COPY, MOVE, PUT",
NULL);
}
break;
case DAV_RESOURCE_LOCK_NULL:
/* resource is lock-null. */
NULL);
break;
case DAV_RESOURCE_NULL:
/* resource is null. */
NULL);
break;
default:
/* ### internal error! */
options = "OPTIONS";
break;
}
/* If there is a versioning provider, add versioning options */
const char *vsn_options = NULL;
/* ### take into account resource type */
vsn_options = ", MKRESOURCE";
}
vsn_options = ", CHECKIN";
}
vsn_options = ", CHECKIN, UNCHECKOUT";
else
vsn_options = ", CHECKOUT";
if (vsn_options != NULL)
}
/* ### this will send a Content-Type. the default OPTIONS does not. */
/* ### the default (ap_send_http_options) returns OK, but I believe
* ### that is because it is the default handler and nothing else
* ### will run after the thing. */
/* we've sent everything necessary to the client. */
return DONE;
}
{
const ap_xml_elem *elem;
ap_text_header hdr = { 0 };
/* just return if we built the thing already */
return;
}
"<D:propstat>" DEBUG_CR
"<D:prop>" DEBUG_CR);
}
"</D:prop>" DEBUG_CR
"<D:status>HTTP/1.1 404 Not Found</D:status>" DEBUG_CR
"</D:propstat>" DEBUG_CR);
}
{
dav_get_props_result propstats = { 0 };
/*
** Note: ctx->doc can only be NULL for DAV_PROPFIND_IS_ALLPROP. Since
** dav_get_allprops() does not need to do namespace translation,
** we're okay.
**
** Note: we cast to lose the "const". The propdb won't try to change
** the resource, however, since we are opening readonly.
*/
/* ### do something with err! */
dav_get_props_result badprops = { 0 };
/* some props were expected on this collection/resource */
}
else {
/* no props on this collection/resource */
}
return NULL;
}
/* ### what to do about closing the propdb on server failure? */
}
else {
}
return NULL;
}
/* handle the PROPFIND method */
static int dav_method_propfind(request_rec *r)
{
int depth;
int result;
const ap_xml_elem *child;
dav_walker_ctx ctx = { 0 };
/* Ask repository module to resolve the resource */
return result;
/* Apache will supply a default error for this. */
return HTTP_NOT_FOUND;
}
/* dav_get_depth() supplies additional information for the
* default message. */
return HTTP_BAD_REQUEST;
}
if (depth == DAV_INFINITY) {
&dav_module);
/* default is to DISALLOW these requests */
return dav_error_response(r, HTTP_FORBIDDEN,
ap_psprintf(r->pool,
"PROPFIND requests with a "
"Depth of \"infinity\" are "
"not allowed for %s.",
ap_escape_html(r->pool,
r->uri)));
}
}
return result;
}
/* note: doc == NULL if no request body */
/* This supplies additional information for the default message. */
"The \"propfind\" element was not found.");
return HTTP_BAD_REQUEST;
}
/* ### validate that only one of these three elements is present */
/* note: no request body implies allprop */
}
}
}
else {
/* "propfind" element must have one of the above three children */
/* This supplies additional information for the default message. */
"The \"propfind\" element does not contain one of "
"the required child elements (the specific command).");
return HTTP_BAD_REQUEST;
}
ctx.r = r;
/* ### should open read-only */
"The lock database could not be opened, "
"preventing access to the various lock "
"properties for the PROPFIND.",
err);
}
/* if we have a lock database, then we can walk locknull resources */
}
}
/* ### add a higher-level description? */
}
/* return a 207 (Multi-Status) response now. */
/* if a 404 was generated for an HREF, then we need to spit out the
* doc's namespaces for use by the 404. Note that <response> elements
* will override these ns0, ns1, etc, but NOT within the <response>
* scope for the badprops. */
/* NOTE: propstat_404 != NULL implies doc != NULL */
doc->namespaces);
}
else {
}
/* the response has been sent. */
return DONE;
}
{
ap_text_header hdr = { 0 };
const char *s;
/* ### might be nice to sort by status code and description */
for ( ; i-- > 0; ++ctx ) {
ap_text_append(p, &hdr,
"<D:propstat>" DEBUG_CR
"<D:prop>");
/* nothing was assigned here yet, so make it a 424 */
if (err424_set == NULL)
"Attempted DAV:set operation "
"could not be completed due "
"to other errors.");
}
if (err424_delete == NULL)
"Attempted DAV:remove "
"operation could not be "
"completed due to other "
"errors.");
}
}
s = ap_psprintf(p,
"<D:status>"
"HTTP/1.1 %d (status)"
"</D:status>" DEBUG_CR,
ap_text_append(p, &hdr, s);
/* ### we should use compute_desc if necessary... */
}
}
}
{
ap_text_header hdr = { 0 };
/*
** ### we probably need to revise the way we assemble the response...
** ### this code assumes everything will return status==200.
*/
ap_text_append(p, &hdr,
"<D:propstat>" DEBUG_CR
"<D:prop>" DEBUG_CR);
for ( ; i-- > 0; ++ctx ) {
}
ap_text_append(p, &hdr,
"</D:prop>" DEBUG_CR
"<D:status>HTTP/1.1 200 OK</D:status>" DEBUG_CR
"</D:propstat>" DEBUG_CR);
}
{
}
/*
** Call <func> for each context. This can stop when an error occurs, or
** simply iterate through the whole list.
**
** Returns 1 if an error occurs (and the iteration is aborted). Returns 0
** if all elements are processed.
**
** If <reverse> is true (non-zero), then the list is traversed in
** reverse order.
*/
int reverse)
{
if (reverse)
ctx += i;
while (i--) {
if (reverse)
--ctx;
return 1;
}
if (!reverse)
++ctx;
}
return 0;
}
/* handle the PROPPATCH method */
static int dav_method_proppatch(request_rec *r)
{
int result;
int failure = 0;
dav_response resp = { 0 };
/* Ask repository module to resolve the resource */
return result;
/* Apache will supply a default error for this. */
return HTTP_NOT_FOUND;
}
return result;
}
/* note: doc == NULL if no request body */
/* This supplies additional information for the default message. */
"The request body does not contain "
"a \"propertyupdate\" element.");
return HTTP_BAD_REQUEST;
}
/* Check If-Headers and existing locks */
/* Note: depth == 0. Implies no need for a multistatus response. */
/* ### add a higher-level description? */
}
ap_psprintf(r->pool,
"Could not open the property "
"database for %s.",
err);
}
/* ### what to do about closing the propdb on server failure? */
/* ### validate "live" properties */
/* set up an array to hold property operation contexts */
/* do a first pass to ensure that all "remove" properties exist */
int is_remove;
continue;
}
/* This supplies additional information for the default message. */
"A \"prop\" element is missing inside "
"the propertyupdate command.");
return HTTP_BAD_REQUEST;
}
ctx->r = r; /* for later use by dav_prop_log_errors() */
if ( DAV_PROP_CTX_HAS_ERR(*ctx) ) {
failure = 1;
}
}
}
/* execute all of the operations */
failure = 1;
}
if (failure) {
}
else {
}
/* make sure this gets closed! */
/* log any errors that occurred */
/* ### should probably use something new to pass along this text... */
/* the response has been sent. */
return DONE;
}
static int process_mkcol_body(request_rec *r)
{
/* This is snarfed from ap_setup_client_block(). We could get pretty
* close to this behavior by passing REQUEST_NO_BODY, but we need to
* return HTTP_UNSUPPORTED_MEDIA_TYPE (while ap_setup_client_block
* returns HTTP_REQUEST_ENTITY_TOO_LARGE). */
/* make sure to set the Apache request fields properly. */
r->read_body = REQUEST_NO_BODY;
r->read_chunked = 0;
r->remaining = 0;
if (tenc) {
/* Use this instead of Apache's default error string */
"Unknown Transfer-Encoding %s", tenc);
return HTTP_NOT_IMPLEMENTED;
}
r->read_chunked = 1;
}
else if (lenp) {
++pos;
}
if (*pos != '\0') {
/* This supplies additional information for the default message. */
"Invalid Content-Length %s", lenp);
return HTTP_BAD_REQUEST;
}
}
if (r->read_chunked || r->remaining > 0) {
/* ### log something? */
/* Apache will supply a default error for this. */
return HTTP_UNSUPPORTED_MEDIA_TYPE;
}
/*
** Get rid of the body. this will call ap_setup_client_block(), but
** our copy above has already verified its work.
*/
return ap_discard_request_body(r);
}
/* handle the MKCOL method */
static int dav_method_mkcol(request_rec *r)
{
int resource_state;
int result;
int parent_was_writable = 0;
/* handle the request body */
/* ### this may move lower once we start processing bodies */
return result;
}
&dav_module);
/* Ask repository module to resolve the resource */
return result;
/* oops. something was already there! */
/* Apache will supply a default error for this. */
/* ### we should provide a specific error message! */
return HTTP_METHOD_NOT_ALLOWED;
}
/*
** Check If-Headers and existing locks.
**
** Note: depth == 0 normally requires no multistatus response. However,
** if we pass DAV_VALIDATE_PARENT, then we could get an error on a URI
** other than the Request-URI, thereby requiring a multistatus.
**
** If the resource does not exist (DAV_RESOURCE_NULL), then we must
** check the resource *and* its parent. If the resource exists or is
** a locknull resource, then we check only the resource.
*/
/* ### add a higher-level description? */
}
/* if versioned resource, make sure parent is checked out */
&parent_was_writable)) != NULL) {
/* ### add a higher-level description? */
}
/* try to create the collection */
/* restore modifiability of parent back to what it was */
0, 0, parent_was_writable);
/* check for errors now */
}
/* just log a warning */
"The MKCOL was successful, but there "
"was a problem reverting the writability of "
"its parent collection.",
err2);
}
if (locks_hooks != NULL) {
/* The directory creation was successful, but the locking failed. */
"The MKCOL was successful, but there "
"was a problem opening the lock database "
"which prevents inheriting locks from the "
"parent resources.",
err);
}
/* The dir creation was successful, but the locking failed. */
"The MKCOL was successful, but there "
"was a problem updating its lock "
"information.",
err);
}
}
/* return an appropriate response (HTTP_CREATED) */
}
/* handle the COPY and MOVE methods */
{
const char *body;
const char *dest;
int is_dir;
int overwrite;
int depth;
int result;
int replaced;
int src_parent_was_writable = 0;
int dst_parent_was_writable = 0;
int resource_state;
/* Ask repository module to resolve the resource */
return result;
/* Apache will supply a default error for this. */
return HTTP_NOT_FOUND;
}
}
/* get the destination URI */
/* Look in headers provided by Netscape's Roaming Profiles */
}
/* This supplies additional information for the default message. */
"The request is missing a Destination header.");
return HTTP_BAD_REQUEST;
}
/* This supplies additional information for the default message. */
return HTTP_BAD_REQUEST;
}
/* ### this assumes that dav_lookup_uri() only generates a status
* ### that Apache can provide a status line for!! */
}
/* ### how best to report this... */
"Destination URI had an error.");
}
/* Resolve destination resource */
return result;
/* are the two resources handled by the same repository? */
/* ### this message exposes some backend config, but screw it... */
return dav_error_response(r, HTTP_BAD_GATEWAY,
"Destination URI is handled by a "
"different repository than the source URI. "
"MOVE or COPY between repositories is "
"not possible.");
}
/* get and parse the overwrite header value */
if ((overwrite = dav_get_overwrite(r)) < 0) {
/* dav_get_overwrite() supplies additional information for the
* default message. */
return HTTP_BAD_REQUEST;
}
/* quick failure test: if dest exists and overwrite is false. */
/* Supply some text for the error response body. */
return dav_error_response(r, HTTP_PRECONDITION_FAILED,
"Destination is not empty and "
"Overwrite is not \"T\"");
}
/* are the source and destination the same? */
/* Supply some text for the error response body. */
return dav_error_response(r, HTTP_FORBIDDEN,
"Source and Destination URIs are the same.");
}
/* get and parse the Depth header value. "0" and "infinity" are legal. */
/* dav_get_depth() supplies additional information for the
* default message. */
return HTTP_BAD_REQUEST;
}
if (depth == 1) {
/* This supplies additional information for the default message. */
"Depth must be \"0\" or \"infinity\" for COPY or MOVE.");
return HTTP_BAD_REQUEST;
}
/* This supplies additional information for the default message. */
"Depth must be \"infinity\" when moving a collection.");
return HTTP_BAD_REQUEST;
}
/*
** Check If-Headers and existing locks for each resource in the source
** if we are performing a MOVE. We will return a 424 response with a
** DAV:multistatus body. The multistatus responses will contain the
** information about any resource that fails the validation.
**
** We check the parent resource, too, since this is a MOVE. Moving the
** resource effectively removes it from the parent collection, so we
** must ensure that we have met the appropriate conditions.
**
** If a problem occurs with the Request-URI itself, then a plain error
** (rather than a multistatus) will be returned.
*/
if (is_move
ap_psprintf(r->pool,
"Could not MOVE %s due to a failed "
"precondition on the source "
"(e.g. locks).",
err);
}
/*
** Check If-Headers and existing locks for destination. Note that we
** use depth==infinity since the target (hierarchy) will be deleted
**
** Note that we are overwriting the target, which implies a DELETE, so
** will return a 424 error if any of the validations fail.
** (see dav_method_delete() for more information)
*/
ap_psprintf(r->pool,
"failed precondition on the "
"destination (e.g. locks).",
err);
}
if (is_dir
&& depth == DAV_INFINITY
/* Supply some text for the error response body. */
return dav_error_response(r, HTTP_FORBIDDEN,
"Source collection contains the "
"Destination.");
}
if (is_dir
/* The destination must exist (since it contains the source), and
* a condition above implies Overwrite==T. Obviously, we cannot
* delete the Source.
*/
/* Supply some text for the error response body. */
return dav_error_response(r, HTTP_FORBIDDEN,
"Destination collection contains the Source "
"and Overwrite has been specified.");
}
/* ### for now, we don't need anything in the body */
return result;
}
/* ### add a higher-level description? */
}
/* remove any locks from the old resources */
/*
** ### this is Yet Another Traversal. if we do a rename(), then we
** ### really don't have to do this in some cases since the inode
** ### values will remain constant across the move. but we can't
** ### know that fact from outside the provider :-(
**
** ### since a failure after this would have removed locks (technically,
** ### this is okay to do, but really...)
*/
/* ### this is wrong! it blasts direct locks on parent resources */
/* ### pass lockdb! */
}
/* remember whether target resource existed */
/* if this is a move, then the source parent collection will be modified */
if (is_move) {
1 /* parent_only */,
&src_parent_was_writable)) != NULL) {
/* ### add a higher-level description? */
}
}
/* prepare the destination collection for modification */
&dst_parent_was_writable)) != NULL) {
/* could not make destination writable:
* if move, restore state of source parent
*/
if (is_move) {
1 /* undo */,
0, 0,
}
/* ### add a higher-level description? */
}
/* If source and destination parents are the same, then
* use the same object, so status updates to one are reflected
* in the other.
*/
if (resource_parent != NULL
/* New resource will be same kind as source */
/* If target exists, remove it first (we know Ovewrite must be TRUE).
*/
if (is_move)
else
}
/* restore parent collection states */
0, 0, dst_parent_was_writable);
if (is_move) {
0, 0, src_parent_was_writable);
}
else
ap_psprintf(r->pool,
err);
}
/* check for errors from reverting writability */
/* just log a warning */
"problem reverting the writability of the "
"source parent collection.",
err2);
}
/* just log a warning */
"problem reverting the writability of the "
"destination parent collection.",
err3);
}
/* propagate any indirect locks at the target */
"was a problem updating the lock "
"information.",
err);
}
}
/* return an appropriate response (HTTP_CREATED or HTTP_NO_CONTENT) */
}
/* dav_method_lock: Handler to implement the DAV LOCK method
** Returns appropriate HTTP_* response.
*/
static int dav_method_lock(request_rec *r)
{
const dav_hooks_locks *locks_hooks;
int result;
int depth;
int new_lock_request = 0;
int resource_state;
/* If no locks provider, decline the request */
if (locks_hooks == NULL)
return DECLINED;
return result;
"Depth must be 0 or \"infinity\" for LOCK.");
return HTTP_BAD_REQUEST;
}
/* Ask repository module to resolve the resource */
return result;
/*
** Open writable. Unless an error occurs, we'll be
** writing into the database.
*/
/* ### add a higher-level description? */
}
/* ### add a higher-level description to err? */
goto error;
}
new_lock_request = 1;
}
/*
** Check If-Headers and existing locks.
**
** If this will create a locknull resource, then the LOCK will affect
** validate the parent resource's conditions.
*/
ap_psprintf(r->pool,
"Could not LOCK %s due to a failed "
"precondition (e.g. other locks).",
err);
goto error;
}
if (new_lock_request == 0) {
/*
** Refresh request
** ### Assumption: We can renew multiple locks on the same resource
** ### at once. First harvest all the positive lock-tokens given in
** ### the If header. Then modify the lock entries for this resource
** ### with the new Timeout val.
*/
ap_psprintf(r->pool,
"The lock refresh for %s failed "
"because no lock tokens were "
"specified in an \"If:\" "
"header.",
err);
goto error;
}
dav_get_timeout(r),
/* ### add a higher-level description to err? */
goto error;
}
} else {
/* New lock request */
char *locktoken_txt;
&dav_module);
/* apply lower bound (if any) from DAVMinTimeout directive */
/* ### add a higher-level description to err? */
goto error;
}
">", NULL);
}
else {
ap_rprintf(r,
"<D:lockdiscovery>" DEBUG_CR
"%s" DEBUG_CR
"</D:lockdiscovery>" DEBUG_CR,
}
ap_rputs("</D:prop>", r);
/* the response has been sent. */
return DONE;
}
/* dav_method_unlock: Handler to implement the DAV UNLOCK method
* Returns appropriate HTTP_* response.
*/
static int dav_method_unlock(request_rec *r)
{
const dav_hooks_locks *locks_hooks;
int result;
const char *const_locktoken_txt;
char *locktoken_txt;
int resource_state;
/* If no locks provider, decline the request */
if (locks_hooks == NULL)
return DECLINED;
"Unlock failed (%s): No Lock-Token specified in header", r->filename);
return HTTP_BAD_REQUEST;
}
if (locktoken_txt[0] != '<') {
/* ### should provide more specifics... */
return HTTP_BAD_REQUEST;
}
/* ### should provide more specifics... */
return HTTP_BAD_REQUEST;
}
ap_psprintf(r->pool,
"The UNLOCK on %s failed -- an "
"invalid lock token was specified "
"in the \"If:\" header.",
err);
}
/* Ask repository module to resolve the resource */
return result;
/*
** Check If-Headers and existing locks.
**
** Note: depth == 0 normally requires no multistatus response. However,
** if we pass DAV_VALIDATE_PARENT, then we could get an error on a URI
** other than the Request-URI, thereby requiring a multistatus.
**
** If the resource is a locknull resource, then the UNLOCK will affect
** the parent collection (much like a delete). For that case, we must
** validate the parent resource's conditions.
*/
/* ### add a higher-level description? */
}
/* ### RFC 2518 s. 8.11: If this resource is locked by locktoken,
* _all_ resources locked by locktoken are released. It does not say
* resource has to be the root of an infinte lock. Thus, an UNLOCK
* on any part of an infinte lock will remove the lock on all resources.
*
* For us, if r->filename represents an indirect lock (part of an infinity lock),
* we must actually perform an UNLOCK on the direct lock for this resource.
*/
return result;
}
return HTTP_NO_CONTENT;
}
/* handle the SEARCH method from DASL */
static int dav_method_search(request_rec *r)
{
/* ### we know this method, but we won't allow it yet */
/* Apache will supply a default error for this. */
return HTTP_METHOD_NOT_ALLOWED;
/* Do some error checking, like if the querygrammar is
* supported by the content type, and then pass the
* request on to the appropriate query module.
*/
}
/* handle the CHECKOUT method */
static int dav_method_checkout(request_rec *r)
{
int result;
/* If no versioning provider, decline the request */
return DECLINED;
/* ### eventually check body for DAV:checkin-policy */
return result;
}
/* Ask repository module to resolve the resource */
return result;
/* Apache will supply a default error for this. */
return HTTP_NOT_FOUND;
}
/* Check the state of the resource: must be a file or collection,
* must be versioned, and must not already be checked out.
*/
return dav_error_response(r, HTTP_CONFLICT,
"Cannot checkout this type of resource.");
}
return dav_error_response(r, HTTP_CONFLICT,
"Cannot checkout unversioned resource.");
}
return dav_error_response(r, HTTP_CONFLICT,
"The resource is already checked out to the workspace.");
}
/* ### do lock checks, once behavior is defined */
/* Do the checkout */
ap_psprintf(r->pool,
"Could not CHECKOUT resource %s.",
err);
}
/* no body */
ap_set_content_length(r, 0);
return DONE;
}
/* handle the UNCHECKOUT method */
static int dav_method_uncheckout(request_rec *r)
{
int result;
/* If no versioning provider, decline the request */
return DECLINED;
return result;
}
/* Ask repository module to resolve the resource */
return result;
/* Apache will supply a default error for this. */
return HTTP_NOT_FOUND;
}
/* Check the state of the resource: must be a file or collection,
* must be versioned, and must be checked out.
*/
return dav_error_response(r, HTTP_CONFLICT,
"Cannot uncheckout this type of resource.");
}
return dav_error_response(r, HTTP_CONFLICT,
"Cannot uncheckout unversioned resource.");
}
return dav_error_response(r, HTTP_CONFLICT,
"The resource is not checked out to the workspace.");
}
/* ### do lock checks, once behavior is defined */
/* Do the uncheckout */
ap_psprintf(r->pool,
"Could not UNCHECKOUT resource %s.",
err);
}
/* no body */
ap_set_content_length(r, 0);
return DONE;
}
/* handle the CHECKIN method */
static int dav_method_checkin(request_rec *r)
{
int result;
/* If no versioning provider, decline the request */
return DECLINED;
return result;
}
/* Ask repository module to resolve the resource */
return result;
/* Apache will supply a default error for this. */
return HTTP_NOT_FOUND;
}
/* Check the state of the resource: must be a file or collection,
* must be versioned, and must be checked out.
*/
return dav_error_response(r, HTTP_CONFLICT,
"Cannot checkin this type of resource.");
}
return dav_error_response(r, HTTP_CONFLICT,
"Cannot checkin unversioned resource.");
}
return dav_error_response(r, HTTP_CONFLICT,
"The resource is not checked out to the workspace.");
}
/* ### do lock checks, once behavior is defined */
/* Do the checkin */
ap_psprintf(r->pool,
"Could not CHECKIN resource %s.",
err);
}
/* no body */
ap_set_content_length(r, 0);
return DONE;
}
/*
* Response handler for DAV resources
*/
static int dav_handler(request_rec *r)
{
/* quickly ignore any HTTP/0.9 requests */
if (r->assbackwards) {
return DECLINED;
}
/* ### do we need to do anything with r->proxyreq ?? */
&dav_module);
/*
* Set up the methods mask, since that's one of the reasons this handler
* gets called, and lower-level things may need the info.
*
* First, set the mask to the methods we handle directly. Since by
* definition we own our managed space, we unconditionally set
* the r->allowed field rather than ORing our values with anything
* any other module may have put in there.
*
* These are the HTTP-defined methods that we handle directly.
*/
r->allowed = 0
| (1 << M_GET)
| (1 << M_PUT)
| (1 << M_DELETE)
| (1 << M_OPTIONS)
| (1 << M_INVALID);
/*
* These are the DAV methods we handle.
*/
r->allowed |= 0
| (1 << M_COPY)
| (1 << M_LOCK)
| (1 << M_UNLOCK)
| (1 << M_MKCOL)
| (1 << M_MOVE)
| (1 << M_PROPFIND)
| (1 << M_PROPPATCH);
/*
* These are methods that we don't handle directly, but let the
* server's default handler do for us as our agent.
*/
r->allowed |= 0
| (1 << M_POST);
/* ### hrm. if we return HTTP_METHOD_NOT_ALLOWED, then an Allow header
* ### is sent; it will need the other allowed states; since the default
* ### handler is not called on error, then it doesn't add the other
* ### allowed states, so we must */
/* ### we might need to refine this for just where we return the error.
* ### also, there is the issue with other methods (see ISSUES) */
/* ### more work necessary, now that we have M_foo for DAV methods */
/* dispatch the appropriate method handler */
if (r->method_number == M_GET) {
return dav_method_get(r);
}
if (r->method_number == M_PUT) {
return dav_method_put(r);
}
if (r->method_number == M_POST) {
return dav_method_post(r);
}
if (r->method_number == M_DELETE) {
return dav_method_delete(r);
}
if (r->method_number == M_OPTIONS) {
return dav_method_options(r);
}
if (r->method_number == M_PROPFIND) {
return dav_method_propfind(r);
}
if (r->method_number == M_PROPPATCH) {
return dav_method_proppatch(r);
}
if (r->method_number == M_MKCOL) {
return dav_method_mkcol(r);
}
if (r->method_number == M_COPY) {
return dav_method_copymove(r, DAV_DO_COPY);
}
if (r->method_number == M_MOVE) {
return dav_method_copymove(r, DAV_DO_MOVE);
}
if (r->method_number == M_LOCK) {
return dav_method_lock(r);
}
if (r->method_number == M_UNLOCK) {
return dav_method_unlock(r);
}
/*
* NOTE: When Apache moves creates defines for the add'l DAV methods,
* then it will no longer use M_INVALID. This code must be
* updated each time Apache adds method defines.
*/
if (r->method_number != M_INVALID) {
return DECLINED;
}
return dav_method_search(r);
}
return dav_method_checkout(r);
}
return dav_method_uncheckout(r);
}
return dav_method_checkin(r);
}
#if 0
return dav_method_mkresource(r);
}
return dav_method_report(r);
}
#endif
/* ### add'l methods for Advanced Collections, ACLs, DASL */
return DECLINED;
}
static int dav_type_checker(request_rec *r)
{
&dav_module);
/* if DAV is not enabled, then we've got nothing to do */
return DECLINED;
}
if (r->method_number == M_GET) {
/*
** ### need some work to pull Content-Type and Content-Language
** ### from the property database.
*/
/*
** If the repository hasn't indicated that it will handle the
** GET method, then just punt.
**
** ### this isn't quite right... taking over the response can break
** ### things like mod_negotiation. need to look into this some more.
*/
if (!conf->handle_get) {
return DECLINED;
}
}
/* ### we should (instead) trap the ones that we DO understand */
/* ### the handler DOES handle POST, so we need to fix one of these */
if (r->method_number != M_POST) {
/*
** ### config option "take over" the handler here? i.e. how do
** ### we lock down this hierarchy so that we are the ultimate
** ### arbiter? (or do we simply depend on the administrator
** ### to avoid conflicting configurations?)
**
** ### I think the OK stops running type-checkers. need to look.
*/
r->handler = "dav-handler";
return OK;
}
return DECLINED;
}
static void register_hooks(void)
{
}
/*---------------------------------------------------------------------------
**
** Configuration info for the module
*/
static const command_rec dav_cmds[] =
{
"specify minimum allowed timeout"),
"allow Depth infinity PROPFIND requests"),
"DAVParam <parameter name> <parameter value>"),
{ NULL }
};
static const handler_rec dav_handlers[] =
{
{"dav-handler", dav_handler},
{ NULL }
};
{
dav_create_dir_config, /* dir config creater */
dav_merge_dir_config, /* dir merger --- default is to override */
dav_create_server_config, /* server config */
dav_merge_server_config, /* merge server config */
dav_cmds, /* command table */
dav_handlers, /* handlers */
register_hooks, /* register hooks */
};
)
(request_rec *r, const char *root_dir,
const char *workspace),
(request_rec *r), (r), NULL);
(request_rec *r), (r), NULL);
(request_rec *r), (r), NULL);
(request_rec *r,
const dav_hooks_liveprop **hooks),