df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski

adea2e45fa61f1097aadc490a0aeaf4831b729ccChristian Maeder

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski#include "mod_dav.h"

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski#include "http_log.h"

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski#include "http_config.h"

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski#include "http_protocol.h"

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski#include "http_core.h"

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski#include "apr_strings.h"

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski#include "memory.h"

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowskiconst char *dav_lock_get_activelock(request_rec *r, dav_lock *lock,

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski dav_buffer *pbuf)

adea2e45fa61f1097aadc490a0aeaf4831b729ccChristian Maeder{

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski dav_lock *lock_scan;

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski const dav_hooks_locks *hooks = DAV_GET_HOOKS_LOCKS(r);

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski int count = 0;

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski dav_buffer work_buf = { 0 };

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski apr_pool_t *p = r->pool;

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski

adea2e45fa61f1097aadc490a0aeaf4831b729ccChristian Maeder /* If no locks or no lock provider, there are no locks */

b1f59a4ea7c96f4c03a4d7cfcb9c5e66871cfbbbChristian Maeder if (lock == NULL || hooks == NULL) {

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski /*

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski return "";

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski }

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski /*

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski for (lock_scan = lock; lock_scan != NULL; lock_scan = lock_scan->next)

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski count++;

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski /* if a buffer was not provided, then use an internal buffer */

adea2e45fa61f1097aadc490a0aeaf4831b729ccChristian Maeder if (pbuf == NULL)

88ece6e49930670e8fd3ee79c89a2e918d2fbd0cChristian Maeder pbuf = &work_buf;

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski /* reset the length before we start appending stuff */

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski pbuf->cur_len = 0;

88ece6e49930670e8fd3ee79c89a2e918d2fbd0cChristian Maeder

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski /* prep the buffer with a "good" size */

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski dav_check_bufsize(p, pbuf, count * 300);

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski for (; lock != NULL; lock = lock->next) {

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski char tmp[100];

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski#if DAV_DEBUG

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski if (lock->rectype == DAV_LOCKREC_INDIRECT_PARTIAL) {

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski /* ### crap. design error */

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski dav_buffer_append(p, pbuf,

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski "DESIGN ERROR: attempted to product an "

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski "activelock element from a partial, indirect "

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski "lock record. Creating an XML parsing error "

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski "to ease detection of this situation: <");

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski }

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski#endif

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski dav_buffer_append(p, pbuf, "<D:activelock>" DEBUG_CR "<D:locktype>");

df11e5eab86d8247f58e301d8f0a2c6ecf4c9541Till Mossakowski switch (lock->type) {

case DAV_LOCKTYPE_WRITE:

dav_buffer_append(p, pbuf, "<D:write/>");

break;

default:

/* ### internal error. log something? */

break;

}

dav_buffer_append(p, pbuf, "</D:locktype>" DEBUG_CR "<D:lockscope>");

switch (lock->scope) {

case DAV_LOCKSCOPE_EXCLUSIVE:

dav_buffer_append(p, pbuf, "<D:exclusive/>");

break;

case DAV_LOCKSCOPE_SHARED:

dav_buffer_append(p, pbuf, "<D:shared/>");

break;

default:

/* ### internal error. log something? */

break;

}

dav_buffer_append(p, pbuf, "</D:lockscope>" DEBUG_CR);

sprintf(tmp, "<D:depth>%s</D:depth>" DEBUG_CR,

lock->depth == DAV_INFINITY ? "infinity" : "0");

dav_buffer_append(p, pbuf, tmp);

if (lock->owner) {

/*

dav_buffer_append(p, pbuf, lock->owner);

}

dav_buffer_append(p, pbuf, "<D:timeout>");

if (lock->timeout == DAV_TIMEOUT_INFINITE) {

dav_buffer_append(p, pbuf, "Infinite");

}

else {

time_t now = time(NULL);

sprintf(tmp, "Second-%lu", lock->timeout - now);

dav_buffer_append(p, pbuf, tmp);

}

dav_buffer_append(p, pbuf,

"</D:timeout>" DEBUG_CR

"<D:locktoken>" DEBUG_CR

"<D:href>");

dav_buffer_append(p, pbuf,

(*hooks->format_locktoken)(p, lock->locktoken));

dav_buffer_append(p, pbuf,

"</D:href>" DEBUG_CR

"</D:locktoken>" DEBUG_CR

"</D:activelock>" DEBUG_CR);

}

return pbuf->buf;

}

dav_error * dav_lock_parse_lockinfo(request_rec *r,

const dav_resource *resource,

dav_lockdb *lockdb,

const ap_xml_doc *doc,

dav_lock **lock_request)

{

apr_pool_t *p = r->pool;

dav_error *err;

ap_xml_elem *child;

dav_lock *lock;

if (!dav_validate_root(doc, "lockinfo")) {

return dav_new_error(p, HTTP_BAD_REQUEST, 0,

"The request body contains an unexpected "

"XML root element.");

}

if ((err = (*lockdb->hooks->create_lock)(lockdb, resource,

&lock)) != NULL) {

return dav_push_error(p, err->status, 0,

"Could not parse the lockinfo due to an "

"internal problem creating a lock structure.",

err);

}

lock->depth = dav_get_depth(r, DAV_INFINITY);

if (lock->depth == -1) {

return dav_new_error(p, HTTP_BAD_REQUEST, 0,

"An invalid Depth header was specified.");

}

lock->timeout = dav_get_timeout(r);

/* Parse elements in the XML body */

for (child = doc->root->first_child; child; child = child->next) {

if (strcmp(child->name, "locktype") == 0

&& child->first_child

&& lock->type == DAV_LOCKTYPE_UNKNOWN) {

if (strcmp(child->first_child->name, "write") == 0) {

lock->type = DAV_LOCKTYPE_WRITE;

continue;

}

}

if (strcmp(child->name, "lockscope") == 0

&& child->first_child

&& lock->scope == DAV_LOCKSCOPE_UNKNOWN) {

if (strcmp(child->first_child->name, "exclusive") == 0)

lock->scope = DAV_LOCKSCOPE_EXCLUSIVE;

else if (strcmp(child->first_child->name, "shared") == 0)

lock->scope = DAV_LOCKSCOPE_SHARED;

if (lock->scope != DAV_LOCKSCOPE_UNKNOWN)

continue;

}

if (strcmp(child->name, "owner") == 0 && lock->owner == NULL) {

const char *text;

/* quote all the values in the <DAV:owner> element */

ap_xml_quote_elem(p, child);

/*

ap_xml_to_text(p, child, AP_XML_X2T_FULL_NS_LANG, doc->namespaces,

NULL, &text, NULL);

lock->owner = text;

continue;

}

return dav_new_error(p, HTTP_PRECONDITION_FAILED, 0,

apr_psprintf(p,

"The server cannot satisfy the "

"LOCK request due to an unknown XML "

"element (\"%s\") within the "

"DAV:lockinfo element.",

child->name));

}

*lock_request = lock;

return NULL;

}

static dav_error * dav_lock_walker(dav_walk_resource *wres, int calltype)

{

dav_walker_ctx *ctx = wres->walk_ctx;

dav_error *err;

/* We don't want to set indirects on the target */

if ((*wres->resource->hooks->is_same_resource)(wres->resource,

ctx->w.root))

return NULL;

if ((err = (*ctx->w.lockdb->hooks->append_locks)(ctx->w.lockdb,

wres->resource, 1,

ctx->lock)) != NULL) {

if (ap_is_HTTP_SERVER_ERROR(err->status)) {

/* ### add a higher-level description? */

return err;

}

/* add to the multistatus response */

dav_add_response(wres, err->status, NULL);

/*

}

return NULL;

}

dav_error * dav_add_lock(request_rec *r, const dav_resource *resource,

dav_lockdb *lockdb, dav_lock *lock,

dav_response **response)

{

dav_error *err;

int depth = lock->depth;

*response = NULL;

/* Requested lock can be:

/*

if (!resource->collection) {

depth = 0;

}

/* In all cases, first add direct entry in lockdb */

/*

if ((err = (*lockdb->hooks->append_locks)(lockdb, resource, 0,

lock)) != NULL) {

/* ### maybe add a higher-level description */

return err;

}

if (depth > 0) {

/* Walk existing collection and set indirect locks */

dav_walker_ctx ctx = { { 0 } };

dav_response *multi_status;

ctx.w.walk_type = DAV_WALKTYPE_NORMAL | DAV_WALKTYPE_AUTH;

ctx.w.func = dav_lock_walker;

ctx.w.walk_ctx = &ctx;

ctx.w.pool = r->pool;

ctx.w.root = resource;

ctx.w.lockdb = lockdb;

ctx.r = r;

ctx.lock = lock;

err = (*resource->hooks->walk)(&ctx.w, DAV_INFINITY, &multi_status);

if (err != NULL) {

/* implies a 5xx status code occurred. screw the multistatus */

return err;

}

if (multi_status != NULL) {

/* manufacture a 207 error for the multistatus response */

*response = multi_status;

return dav_new_error(r->pool, HTTP_MULTI_STATUS, 0,

"Error(s) occurred on resources during the "

"addition of a depth lock.");

}

}

return NULL;

}

DAV_DECLARE(dav_error*) dav_lock_query(dav_lockdb *lockdb,

const dav_resource *resource,

dav_lock **locks)

{

/* If no lock database, return empty result */

if (lockdb == NULL) {

*locks = NULL;

return NULL;

}

/* ### insert a higher-level description? */

return (*lockdb->hooks->get_locks)(lockdb, resource,

DAV_GETLOCKS_RESOLVED,

locks);

}

static dav_error * dav_unlock_walker(dav_walk_resource *wres, int calltype)

{

dav_walker_ctx *ctx = wres->walk_ctx;

dav_error *err;

if ((err = (*ctx->w.lockdb->hooks->remove_lock)(ctx->w.lockdb,

wres->resource,

ctx->locktoken)) != NULL) {

/* ### should we stop or return a multistatus? looks like STOP */

/* ### add a higher-level description? */

return err;

}

return NULL;

}

static dav_error * dav_get_direct_resource(apr_pool_t *p,

dav_lockdb *lockdb,

const dav_locktoken *locktoken,

const dav_resource *resource,

const dav_resource **direct_resource)

{

if (lockdb->hooks->lookup_resource != NULL) {

return (*lockdb->hooks->lookup_resource)(lockdb, locktoken,

resource, direct_resource);

}

*direct_resource = NULL;

/* Find the top of this lock-

while (resource != NULL) {

dav_error *err;

dav_lock *lock;

/*

if ((err = (*lockdb->hooks->find_lock)(lockdb, resource, locktoken,

1, &lock)) != NULL) {

/* ### add a higher-level desc? */

return err;

}

/* not found! that's an error. */

if (lock == NULL) {

return dav_new_error(p, HTTP_BAD_REQUEST, 0,

"The specified locktoken does not correspond "

"to an existing lock on this resource.");

}

if (lock->rectype == DAV_LOCKREC_DIRECT) {

/* we found the direct lock. return this resource. */

*direct_resource = resource;

return NULL;

}

/* the lock was indirect. move up a level in the URL namespace */

resource = (*resource->hooks->get_parent_resource)(resource);

}

return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,

"The lock database is corrupt. A direct lock could "

"not be found for the corresponding indirect lock "

"on this resource.");

}

int dav_unlock(request_rec *r, const dav_resource *resource,

const dav_locktoken *locktoken)

{

int result;

dav_lockdb *lockdb;

const dav_resource *lock_resource = resource;

const dav_hooks_locks *hooks = DAV_GET_HOOKS_LOCKS(r);

const dav_hooks_repository *repos_hooks = resource->hooks;

dav_error *err;

/* If no locks provider, we shouldn't have been called */

if (hooks == NULL) {

/* ### map result to something nice; log an error */

return HTTP_INTERNAL_SERVER_ERROR;

}

/* 2518 requires the entire lock to be removed if resource/locktoken

if ((err = (*hooks->open_lockdb)(r, 0, 1, &lockdb)) != NULL) {

/* ### return err! maybe add a higher-level desc */

/* ### map result to something nice; log an error */

return HTTP_INTERNAL_SERVER_ERROR;

}

if (locktoken != NULL

&& (err = dav_get_direct_resource(r->pool, lockdb,

locktoken, resource,

&lock_resource)) != NULL) {

/* ### add a higher-level desc? */

/* ### should return err! */

return err->status;

}

/* At this point, lock_resource/locktoken refers to a direct lock (key), ie

if ((err = (*hooks->remove_lock)(lockdb, lock_resource,

locktoken)) != NULL) {

/* ### add a higher-level desc? */

/* ### return err! */

return HTTP_INTERNAL_SERVER_ERROR;

}

if (lock_resource->collection) {

dav_walker_ctx ctx = { { 0 } };

dav_response *multi_status;

ctx.w.walk_type = DAV_WALKTYPE_NORMAL | DAV_WALKTYPE_LOCKNULL;

ctx.w.func = dav_unlock_walker;

ctx.w.walk_ctx = &ctx;

ctx.w.pool = r->pool;

ctx.w.root = lock_resource;

ctx.w.lockdb = lockdb;

ctx.r = r;

ctx.locktoken = locktoken;

err = (*repos_hooks->walk)(&ctx.w, DAV_INFINITY, &multi_status);

/* ### fix this! */

/* ### do something with multi_status */

result = err == NULL ? OK : err->status;

}

else

result = OK;

(*hooks->close_lockdb)(lockdb);

return result;

}

static dav_error * dav_inherit_walker(dav_walk_resource *wres, int calltype)

{

dav_walker_ctx *ctx = wres->walk_ctx;

if (ctx->skip_root

&& (*wres->resource->hooks->is_same_resource)(wres->resource,

ctx->w.root)) {

return NULL;

}

/* ### maybe add a higher-level desc */

return (*ctx->w.lockdb->hooks->append_locks)(ctx->w.lockdb,

wres->resource, 1,

ctx->lock);

}

static dav_error * dav_inherit_locks(request_rec *r, dav_lockdb *lockdb,

const dav_resource *resource,

int use_parent)

{

dav_error *err;

const dav_resource *which_resource;

dav_lock *locks;

dav_lock *scan;

dav_lock *prev;

dav_walker_ctx ctx = { { 0 } };

const dav_hooks_repository *repos_hooks = resource->hooks;

dav_response *multi_status;

if (use_parent) {

which_resource = (*repos_hooks->get_parent_resource)(resource);

if (which_resource == NULL) {

/* ### map result to something nice; log an error */

return dav_new_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0,

"Could not fetch parent resource. Unable to "

"inherit locks from the parent and apply "

"them to this resource.");

}

}

else {

which_resource = resource;

}

if ((err = (*lockdb->hooks->get_locks)(lockdb, which_resource,

DAV_GETLOCKS_PARTIAL,

&locks)) != NULL) {

/* ### maybe add a higher-level desc */

return err;

}

if (locks == NULL) {

/* No locks to propagate, just return */

return NULL;

}

/*

for (scan = locks, prev = NULL;

scan != NULL;

prev = scan, scan = scan->next) {

if (scan->rectype == DAV_LOCKREC_DIRECT

&& scan->depth != DAV_INFINITY) {

if (prev == NULL)

locks = scan->next;

else

prev->next = scan->next;

}

}

/* <locks> has all our new locks. Walk down and propagate them. */

ctx.w.walk_type = DAV_WALKTYPE_NORMAL | DAV_WALKTYPE_LOCKNULL;

ctx.w.func = dav_inherit_walker;

ctx.w.walk_ctx = &ctx;

ctx.w.pool = r->pool;

ctx.w.root = resource;

ctx.w.lockdb = lockdb;

ctx.r = r;

ctx.lock = locks;

ctx.skip_root = !use_parent;

/* ### do something with multi_status */

return (*repos_hooks->walk)(&ctx.w, DAV_INFINITY, &multi_status);

}

int dav_get_resource_state(request_rec *r, const dav_resource *resource)

{

const dav_hooks_locks *hooks = DAV_GET_HOOKS_LOCKS(r);

if (resource->exists)

return DAV_RESOURCE_EXISTS;

if (hooks != NULL) {

dav_error *err;

dav_lockdb *lockdb;

int locks_present;

/*

if (r->path_info != NULL && *r->path_info != '\0') {

return DAV_RESOURCE_NULL;

}

if ((err = (*hooks->open_lockdb)(r, 1, 1, &lockdb)) == NULL) {

/* note that we might see some expired locks... *shrug* */

err = (*hooks->has_locks)(lockdb, resource, &locks_present);

(*hooks->close_lockdb)(lockdb);

}

if (err != NULL) {

/* ### don't log an error. return err. add higher-level desc. */

ap_log_rerror(APLOG_MARK, APLOG_ERR | APLOG_NOERRNO, 0, r,

"Failed to query lock-null status for %s",

r->filename);

return DAV_RESOURCE_ERROR;

}

if (locks_present)

return DAV_RESOURCE_LOCK_NULL;

}

return DAV_RESOURCE_NULL;

}

dav_error * dav_notify_created(request_rec *r,

dav_lockdb *lockdb,

const dav_resource *resource,

int resource_state,

int depth)

{

dav_error *err;

if (resource_state == DAV_RESOURCE_LOCK_NULL) {

/*

(void)(*lockdb->hooks->remove_locknull_state)(lockdb, resource);

/*

if (depth > 0 &&

(err = dav_inherit_locks(r, lockdb, resource, 0)) != NULL) {

/* ### add a higher level desc? */

return err;

}

}

else if (resource_state == DAV_RESOURCE_NULL) {

/* ### should pass depth to dav_inherit_locks so that it can

/* this resource should inherit locks from its parent */

if ((err = dav_inherit_locks(r, lockdb, resource, 1)) != NULL) {

err = dav_push_error(r->pool, err->status, 0,

"The resource was created successfully, but "

"there was a problem inheriting locks from "

"the parent resource.",

err);

return err;

}

}

/* else the resource already exists and its locks are correct. */

return NULL;

}