Adding upstream version 2.4.38.upstream/2.4.38upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

34 files changed, 21142 insertions, 0 deletions

diff --git a/modules/dav/fs/Makefile.in b/modules/dav/fs/Makefile.in
new file mode 100644
index 0000000..7c5c149
--- /dev/null
+++ b/modules/dav/fs/Makefile.in
@@ -0,0 +1,3 @@
+# a modules Makefile has no explicit targets -- they will be defined by
+# whatever modules are enabled. just grab special.mk to deal with this.
+include $(top_srcdir)/build/special.mk
diff --git a/modules/dav/fs/NWGNUmakefile b/modules/dav/fs/NWGNUmakefile
new file mode 100644
index 0000000..e402428
--- /dev/null
+++ b/modules/dav/fs/NWGNUmakefile
@@ -0,0 +1,269 @@
+#
+# Declare the sub-directories to be built here
+#
+
+SUBDIRS = \
+	$(EOLIST)
+
+#
+# Get the 'head' of the build environment.  This includes default targets and
+# paths to tools
+#
+
+include $(AP_WORK)/build/NWGNUhead.inc
+
+#
+# build this level's files
+
+#
+# Make sure all needed macro's are defined
+#
+
+#
+# These directories will be at the beginning of the include list, followed by
+# INCDIRS
+#
+XINCDIRS	+= \
+			$(APR)/include \
+			$(APRUTIL)/include \
+			$(AP_WORK)/include \
+			$(AP_WORK)/server/mpm/netware \
+			$(AP_WORK)/modules/dav/main \
+			$(NWOS) \
+			$(EOLIST)
+
+#
+# These flags will come after CFLAGS
+#
+XCFLAGS		+= \
+			$(EOLIST)
+
+#
+# These defines will come after DEFINES
+#
+XDEFINES	+= \
+			$(EOLIST)
+
+#
+# These flags will be added to the link.opt file
+#
+XLFLAGS		+= \
+			$(EOLIST)
+
+#
+# These values will be appended to the correct variables based on the value of
+# RELEASE
+#
+ifeq "$(RELEASE)" "debug"
+XINCDIRS	+= \
+			$(EOLIST)
+
+XCFLAGS		+= \
+			$(EOLIST)
+
+XDEFINES	+= \
+			$(EOLIST)
+
+XLFLAGS		+= \
+			$(EOLIST)
+endif
+
+ifeq "$(RELEASE)" "noopt"
+XINCDIRS	+= \
+			$(EOLIST)
+
+XCFLAGS		+= \
+			$(EOLIST)
+
+XDEFINES	+= \
+			$(EOLIST)
+
+XLFLAGS		+= \
+			$(EOLIST)
+endif
+
+ifeq "$(RELEASE)" "release"
+XINCDIRS	+= \
+			$(EOLIST)
+
+XCFLAGS		+= \
+			$(EOLIST)
+
+XDEFINES	+= \
+			$(EOLIST)
+
+XLFLAGS		+= \
+			$(EOLIST)
+endif
+
+#
+# These are used by the link target if an NLM is being generated
+# This is used by the link 'name' directive to name the nlm.  If left blank
+# TARGET_nlm (see below) will be used.
+#
+NLM_NAME	= moddavfs
+
+#
+# This is used by the link '-desc ' directive.
+# If left blank, NLM_NAME will be used.
+#
+NLM_DESCRIPTION	= Apache $(VERSION_STR) DAV FileSystem Sub-Module
+
+#
+# This is used by the '-threadname' directive.  If left blank,
+# NLM_NAME Thread will be used.
+NLM_THREAD_NAME	= $(NLM_NAME) Thread
+
+#
+# If this is specified, it will override VERSION value in
+# $(AP_WORK)/build/NWGNUenvironment.inc
+#
+NLM_VERSION	=
+
+#
+# If this is specified, it will override the default of 64K
+#
+NLM_STACK_SIZE	= 65536
+
+
+#
+# If this is specified it will be used by the link '-entry' directive
+#
+NLM_ENTRY_SYM	=
+
+#
+# If this is specified it will be used by the link '-exit' directive
+#
+NLM_EXIT_SYM	=
+
+#
+# If this is specified it will be used by the link '-check' directive
+#
+NLM_CHECK_SYM	=
+
+#
+# If this is specified it will be used by the link '-flags' directive
+#
+NLM_FLAGS	=
+
+#
+# Declare all target files (you must add your files here)
+#
+
+#
+# If there is an NLM target, put it here
+#
+TARGET_nlm = \
+	$(OBJDIR)/$(NLM_NAME).nlm \
+	$(EOLIST)
+
+#
+# If there is an LIB target, put it here
+#
+TARGET_lib = \
+	$(EOLIST)
+
+#
+# These are the OBJ files needed to create the NLM target above.
+# Paths must all use the '/' character
+#
+FILES_nlm_objs = \
+	$(OBJDIR)/mod_dav_fs.o \
+	$(OBJDIR)/dbm.o \
+	$(OBJDIR)/lock.o \
+	$(OBJDIR)/repos.o \
+	$(OBJDIR)/libprews.o \
+	$(EOLIST)
+
+#
+# These are the LIB files needed to create the NLM target above.
+# These will be added as a library command in the link.opt file.
+#
+FILES_nlm_libs = \
+	$(PRELUDE) \
+	$(EOLIST)
+
+#
+# These are the modules that the above NLM target depends on to load.
+# These will be added as a module command in the link.opt file.
+#
+FILES_nlm_modules = \
+	Apache2 \
+	Libc \
+	mod_dav \
+	$(EOLIST)
+
+#
+# If the nlm has a msg file, put it's path here
+#
+FILE_nlm_msg =
+
+#
+# If the nlm has a hlp file put it's path here
+#
+FILE_nlm_hlp =
+
+#
+# If this is specified, it will override $(NWOS)\copyright.txt.
+#
+FILE_nlm_copyright =
+
+#
+# Any additional imports go here
+#
+FILES_nlm_Ximports = \
+	@libc.imp \
+	@aprlib.imp \
+	@httpd.imp \
+	@../main/dav.imp \
+	$(EOLIST)
+
+# Don't link with Winsock if standard sockets are being used
+ifndef USE_STDSOCKETS
+FILES_nlm_Ximports += @ws2nlm.imp \
+	$(EOLIST)
+endif
+
+#
+# Any symbols exported to here
+#
+FILES_nlm_exports = \
+	dav_fs_module \
+	$(EOLIST)
+
+#
+# These are the OBJ files needed to create the LIB target above.
+# Paths must all use the '/' character
+#
+FILES_lib_objs = \
+	$(EOLIST)
+
+#
+# implement targets and dependancies (leave this section alone)
+#
+
+libs :: $(OBJDIR) $(TARGET_lib)
+
+nlms :: libs $(TARGET_nlm)
+
+#
+# Updated this target to create necessary directories and copy files to the
+# correct place.  (See $(AP_WORK)/build/NWGNUhead.inc for examples)
+#
+install :: nlms FORCE
+	$(call COPY,$(OBJDIR)/*.nlm, $(INSTALLBASE)/modules/)
+
+#
+# Any specialized rules here
+#
+
+vpath %.c ../../arch/netware
+
+#
+# Include the 'tail' makefile that has targets that depend on variables defined
+# in this makefile
+#
+
+include $(APBUILD)/NWGNUtail.inc
+
+
diff --git a/modules/dav/fs/config6.m4 b/modules/dav/fs/config6.m4
new file mode 100644
index 0000000..dd26ec8
--- /dev/null
+++ b/modules/dav/fs/config6.m4
@@ -0,0 +1,23 @@
+dnl modules enabled in this directory by default
+
+APACHE_MODPATH_INIT(dav/fs)
+
+dav_fs_objects="mod_dav_fs.lo dbm.lo lock.lo repos.lo"
+
+if test "x$enable_dav" != "x"; then
+  dav_fs_enable=$enable_dav
+else
+  dav_fs_enable=$dav_enable
+fi
+
+case "$host" in
+  *os2*)
+    # OS/2 DLLs must resolve all symbols at build time
+    # and we need some from main DAV module
+    dav_fs_objects="$dav_fs_objects ../main/mod_dav.la"
+    ;;
+esac
+
+APACHE_MODULE(dav_fs, DAV provider for the filesystem.  --enable-dav also enables mod_dav_fs., $dav_fs_objects, , $dav_fs_enable,,dav)
+
+APACHE_MODPATH_FINISH
diff --git a/modules/dav/fs/dbm.c b/modules/dav/fs/dbm.c
new file mode 100644
index 0000000..821168e
--- /dev/null
+++ b/modules/dav/fs/dbm.c
@@ -0,0 +1,771 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+** DAV extension module for Apache 2.0.*
+**  - Database support using DBM-style databases,
+**    part of the filesystem repository implementation
+*/
+
+/*
+** This implementation uses a SDBM database per file and directory to
+** record the properties. These databases are kept in a subdirectory (of
+** the directory in question or the directory that holds the file in
+** question) named by the macro DAV_FS_STATE_DIR (.DAV). The filename of the
+** database is equivalent to the target filename, and is
+** DAV_FS_STATE_FILE_FOR_DIR (.state_for_dir) for the directory itself.
+*/
+
+#include "apr_strings.h"
+#include "apr_file_io.h"
+
+#include "apr_dbm.h"
+
+#define APR_WANT_BYTEFUNC
+#include "apr_want.h"       /* for ntohs and htons */
+
+#include "mod_dav.h"
+#include "repos.h"
+#include "http_log.h"
+#include "http_main.h"      /* for ap_server_conf */
+
+APLOG_USE_MODULE(dav_fs);
+
+struct dav_db {
+    apr_pool_t *pool;
+    apr_dbm_t *file;
+
+    /* when used as a property database: */
+
+    int version;                /* *minor* version of this db */
+
+    dav_buffer ns_table;        /* table of namespace URIs */
+    short ns_count;             /* number of entries in table */
+    int ns_table_dirty;         /* ns_table was modified */
+    apr_hash_t *uri_index;      /* map URIs to (1-based) table indices */
+
+    dav_buffer wb_key;          /* work buffer for dav_gdbm_key */
+
+    apr_datum_t iter;           /* iteration key */
+};
+
+/* -------------------------------------------------------------------------
+ *
+ * GENERIC DBM ACCESS
+ *
+ * For the most part, this just uses the APR DBM functions. They are wrapped
+ * a bit with some error handling (using the mod_dav error functions).
+ */
+
+void dav_dbm_get_statefiles(apr_pool_t *p, const char *fname,
+                            const char **state1, const char **state2)
+{
+    if (fname == NULL)
+        fname = DAV_FS_STATE_FILE_FOR_DIR;
+
+    apr_dbm_get_usednames(p, fname, state1, state2);
+}
+
+static dav_error * dav_fs_dbm_error(dav_db *db, apr_pool_t *p,
+                                    apr_status_t status)
+{
+    int errcode;
+    const char *errstr;
+    dav_error *err;
+    char errbuf[200];
+
+    if (status == APR_SUCCESS)
+        return NULL;
+
+    p = db ? db->pool : p;
+
+    /* There might not be a <db> if we had problems creating it. */
+    if (db == NULL) {
+        errcode = 1;
+        errstr = "Could not open property database.";
+        if (APR_STATUS_IS_EDSOOPEN(status))
+            ap_log_error(APLOG_MARK, APLOG_CRIT, status, ap_server_conf, APLOGNO(00576)
+            "The DBM driver could not be loaded");
+    }
+    else {
+        (void) apr_dbm_geterror(db->file, &errcode, errbuf, sizeof(errbuf));
+        errstr = apr_pstrdup(p, errbuf);
+    }
+
+    err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, errcode, status, errstr);
+    return err;
+}
+
+/* ensure that our state subdirectory is present */
+/* ### does this belong here or in dav_fs_repos.c ?? */
+void dav_fs_ensure_state_dir(apr_pool_t * p, const char *dirname)
+{
+    const char *pathname = apr_pstrcat(p, dirname, "/" DAV_FS_STATE_DIR, NULL);
+
+    /* ### do we need to deal with the umask? */
+
+    /* just try to make it, ignoring any resulting errors */
+    (void) apr_dir_make(pathname, APR_OS_DEFAULT, p);
+}
+
+/* dav_dbm_open_direct:  Opens a *dbm database specified by path.
+ *    ro = boolean read-only flag.
+ */
+dav_error * dav_dbm_open_direct(apr_pool_t *p, const char *pathname, int ro,
+                                dav_db **pdb)
+{
+    apr_status_t status;
+    apr_dbm_t *file = NULL;
+
+    *pdb = NULL;
+
+    if ((status = apr_dbm_open(&file, pathname,
+                               ro ? APR_DBM_READONLY : APR_DBM_RWCREATE,
+                               APR_OS_DEFAULT, p))
+                != APR_SUCCESS
+        && !ro) {
+        /* ### do something with 'status' */
+
+        /* we can't continue if we couldn't open the file
+           and we need to write */
+        return dav_fs_dbm_error(NULL, p, status);
+    }
+
+    /* may be NULL if we tried to open a non-existent db as read-only */
+    if (file != NULL) {
+        /* we have an open database... return it */
+        *pdb = apr_pcalloc(p, sizeof(**pdb));
+        (*pdb)->pool = p;
+        (*pdb)->file = file;
+    }
+
+    return NULL;
+}
+
+static dav_error * dav_dbm_open(apr_pool_t * p, const dav_resource *resource,
+                                int ro, dav_db **pdb)
+{
+    const char *dirpath;
+    const char *fname;
+    const char *pathname;
+
+    /* Get directory and filename for resource */
+    /* ### should test this result value... */
+    (void) dav_fs_dir_file_name(resource, &dirpath, &fname);
+
+    /* If not opening read-only, ensure the state dir exists */
+    if (!ro) {
+        /* ### what are the perf implications of always checking this? */
+        dav_fs_ensure_state_dir(p, dirpath);
+    }
+
+    pathname = apr_pstrcat(p, dirpath, "/" DAV_FS_STATE_DIR "/",
+                              fname ? fname : DAV_FS_STATE_FILE_FOR_DIR,
+                              NULL);
+
+    /* ### readers cannot open while a writer has this open; we should
+       ### perform a few retries with random pauses. */
+
+    /* ### do we need to deal with the umask? */
+
+    return dav_dbm_open_direct(p, pathname, ro, pdb);
+}
+
+void dav_dbm_close(dav_db *db)
+{
+    apr_dbm_close(db->file);
+}
+
+dav_error * dav_dbm_fetch(dav_db *db, apr_datum_t key, apr_datum_t *pvalue)
+{
+    apr_status_t status;
+
+    if (!key.dptr) {
+        /* no key could be created (namespace not known) => no value */
+        memset(pvalue, 0, sizeof(*pvalue));
+        status = APR_SUCCESS;
+    } else {
+        status = apr_dbm_fetch(db->file, key, pvalue);
+    }
+
+    return dav_fs_dbm_error(db, NULL, status);
+}
+
+dav_error * dav_dbm_store(dav_db *db, apr_datum_t key, apr_datum_t value)
+{
+    apr_status_t status = apr_dbm_store(db->file, key, value);
+
+    return dav_fs_dbm_error(db, NULL, status);
+}
+
+dav_error * dav_dbm_delete(dav_db *db, apr_datum_t key)
+{
+    apr_status_t status = apr_dbm_delete(db->file, key);
+
+    return dav_fs_dbm_error(db, NULL, status);
+}
+
+int dav_dbm_exists(dav_db *db, apr_datum_t key)
+{
+    return apr_dbm_exists(db->file, key);
+}
+
+static dav_error * dav_dbm_firstkey(dav_db *db, apr_datum_t *pkey)
+{
+    apr_status_t status = apr_dbm_firstkey(db->file, pkey);
+
+    return dav_fs_dbm_error(db, NULL, status);
+}
+
+static dav_error * dav_dbm_nextkey(dav_db *db, apr_datum_t *pkey)
+{
+    apr_status_t status = apr_dbm_nextkey(db->file, pkey);
+
+    return dav_fs_dbm_error(db, NULL, status);
+}
+
+void dav_dbm_freedatum(dav_db *db, apr_datum_t data)
+{
+    apr_dbm_freedatum(db->file, data);
+}
+
+/* -------------------------------------------------------------------------
+ *
+ * PROPERTY DATABASE FUNCTIONS
+ */
+
+
+#define DAV_GDBM_NS_KEY         "METADATA"
+#define DAV_GDBM_NS_KEY_LEN     8
+
+typedef struct {
+    unsigned char major;
+#define DAV_DBVSN_MAJOR         4
+    /*
+    ** V4 -- 0.9.9 ..
+    **       Prior versions could have keys or values with invalid
+    **       namespace prefixes as a result of the xmlns="" form not
+    **       resetting the default namespace to be "no namespace". The
+    **       namespace would be set to "" which is invalid; it should
+    **       be set to "no namespace".
+    **
+    ** V3 -- 0.9.8
+    **       Prior versions could have values with invalid namespace
+    **       prefixes due to an incorrect mapping of input to propdb
+    **       namespace indices. Version bumped to obsolete the old
+    **       values.
+    **
+    ** V2 -- 0.9.7
+    **       This introduced the xml:lang value into the property value's
+    **       record in the propdb.
+    **
+    ** V1 -- .. 0.9.6
+    **       Initial version.
+    */
+
+
+    unsigned char minor;
+#define DAV_DBVSN_MINOR         0
+
+    short ns_count;
+
+} dav_propdb_metadata;
+
+struct dav_deadprop_rollback {
+    apr_datum_t key;
+    apr_datum_t value;
+};
+
+struct dav_namespace_map {
+    int *ns_map;
+};
+
+/*
+** Internal function to build a key
+**
+** WARNING: returns a pointer to a "static" buffer holding the key. The
+**          value must be copied or no longer used if this function is
+**          called again.
+*/
+static apr_datum_t dav_build_key(dav_db *db, const dav_prop_name *name)
+{
+    char nsbuf[20];
+    apr_size_t l_ns, l_name = strlen(name->name);
+    apr_datum_t key = { 0 };
+
+    /*
+     * Convert namespace ID to a string. "no namespace" is an empty string,
+     * so the keys will have the form ":name". Otherwise, the keys will
+     * have the form "#:name".
+     */
+    if (*name->ns == '\0') {
+        nsbuf[0] = '\0';
+        l_ns = 0;
+    }
+    else {
+        long ns_id = (long)apr_hash_get(db->uri_index, name->ns,
+                                      APR_HASH_KEY_STRING);
+
+
+        if (ns_id == 0) {
+            /* the namespace was not found(!) */
+            return key;         /* zeroed */
+        }
+
+        l_ns = apr_snprintf(nsbuf, sizeof(nsbuf), "%ld", ns_id - 1);
+    }
+
+    /* assemble: #:name */
+    dav_set_bufsize(db->pool, &db->wb_key, l_ns + 1 + l_name + 1);
+    memcpy(db->wb_key.buf, nsbuf, l_ns);
+    db->wb_key.buf[l_ns] = ':';
+    memcpy(&db->wb_key.buf[l_ns + 1], name->name, l_name + 1);
+
+    /* build the database key */
+    key.dsize = l_ns + 1 + l_name + 1;
+    key.dptr = db->wb_key.buf;
+
+    return key;
+}
+
+static void dav_append_prop(apr_pool_t *pool,
+                            const char *name, const char *value,
+                            apr_text_header *phdr)
+{
+    const char *s;
+    const char *lang = value;
+
+    /* skip past the xml:lang value */
+    value += strlen(lang) + 1;
+
+    if (*value == '\0') {
+        /* the property is an empty value */
+        if (*name == ':') {
+            /* "no namespace" case */
+            s = apr_psprintf(pool, "<%s/>" DEBUG_CR, name+1);
+        }
+        else {
+            s = apr_psprintf(pool, "<ns%s/>" DEBUG_CR, name);
+        }
+    }
+    else if (*lang != '\0') {
+        if (*name == ':') {
+            /* "no namespace" case */
+            s = apr_psprintf(pool, "<%s xml:lang=\"%s\">%s</%s>" DEBUG_CR,
+                             name+1, lang, value, name+1);
+        }
+        else {
+            s = apr_psprintf(pool, "<ns%s xml:lang=\"%s\">%s</ns%s>" DEBUG_CR,
+                             name, lang, value, name);
+        }
+    }
+    else if (*name == ':') {
+        /* "no namespace" case */
+        s = apr_psprintf(pool, "<%s>%s</%s>" DEBUG_CR, name+1, value, name+1);
+    }
+    else {
+        s = apr_psprintf(pool, "<ns%s>%s</ns%s>" DEBUG_CR, name, value, name);
+    }
+
+    apr_text_append(pool, phdr, s);
+}
+
+static dav_error * dav_propdb_open(apr_pool_t *pool,
+                                   const dav_resource *resource, int ro,
+                                   dav_db **pdb)
+{
+    dav_db *db;
+    dav_error *err;
+    apr_datum_t key;
+    apr_datum_t value = { 0 };
+
+    *pdb = NULL;
+
+    /*
+    ** Return if an error occurred, or there is no database.
+    **
+    ** NOTE: db could be NULL if we attempted to open a readonly
+    **       database that doesn't exist. If we require read/write
+    **       access, then a database was created and opened.
+    */
+    if ((err = dav_dbm_open(pool, resource, ro, &db)) != NULL
+        || db == NULL)
+        return err;
+
+    db->uri_index = apr_hash_make(pool);
+
+    key.dptr = DAV_GDBM_NS_KEY;
+    key.dsize = DAV_GDBM_NS_KEY_LEN;
+    if ((err = dav_dbm_fetch(db, key, &value)) != NULL) {
+        /* ### push a higher-level description? */
+        return err;
+    }
+
+    if (value.dptr == NULL) {
+        dav_propdb_metadata m = {
+            DAV_DBVSN_MAJOR, DAV_DBVSN_MINOR, 0
+        };
+
+        /*
+        ** If there is no METADATA key, then the database may be
+        ** from versions 0.9.0 .. 0.9.4 (which would be incompatible).
+        ** These can be identified by the presence of an NS_TABLE entry.
+        */
+        key.dptr = "NS_TABLE";
+        key.dsize = 8;
+        if (dav_dbm_exists(db, key)) {
+            dav_dbm_close(db);
+
+            /* call it a major version error */
+            return dav_new_error(pool, HTTP_INTERNAL_SERVER_ERROR,
+                                 DAV_ERR_PROP_BAD_MAJOR, 0,
+                                 "Prop database has the wrong major "
+                                 "version number and cannot be used.");
+        }
+
+        /* initialize a new metadata structure */
+        dav_set_bufsize(pool, &db->ns_table, sizeof(m));
+        memcpy(db->ns_table.buf, &m, sizeof(m));
+    }
+    else {
+        dav_propdb_metadata m;
+        long ns;
+        const char *uri;
+
+        dav_set_bufsize(pool, &db->ns_table, value.dsize);
+        memcpy(db->ns_table.buf, value.dptr, value.dsize);
+
+        memcpy(&m, value.dptr, sizeof(m));
+        if (m.major != DAV_DBVSN_MAJOR) {
+            dav_dbm_close(db);
+
+            return dav_new_error(pool, HTTP_INTERNAL_SERVER_ERROR,
+                                 DAV_ERR_PROP_BAD_MAJOR, 0,
+                                 "Prop database has the wrong major "
+                                 "version number and cannot be used.");
+        }
+        db->version = m.minor;
+        db->ns_count = ntohs(m.ns_count);
+
+        dav_dbm_freedatum(db, value);
+
+        /* create db->uri_index */
+        for (ns = 0, uri = db->ns_table.buf + sizeof(dav_propdb_metadata);
+             ns++ < db->ns_count;
+             uri += strlen(uri) + 1) {
+
+            /* we must copy the key, in case ns_table.buf moves */
+            apr_hash_set(db->uri_index,
+                         apr_pstrdup(pool, uri), APR_HASH_KEY_STRING,
+                         (void *)ns);
+        }
+    }
+
+    *pdb = db;
+    return NULL;
+}
+
+static void dav_propdb_close(dav_db *db)
+{
+
+    if (db->ns_table_dirty) {
+        dav_propdb_metadata m;
+        apr_datum_t key;
+        apr_datum_t value;
+        dav_error *err;
+
+        key.dptr = DAV_GDBM_NS_KEY;
+        key.dsize = DAV_GDBM_NS_KEY_LEN;
+
+        value.dptr = db->ns_table.buf;
+        value.dsize = db->ns_table.cur_len;
+
+        /* fill in the metadata that we store into the prop db. */
+        m.major = DAV_DBVSN_MAJOR;
+        m.minor = db->version;          /* ### keep current minor version? */
+        m.ns_count = htons(db->ns_count);
+
+        memcpy(db->ns_table.buf, &m, sizeof(m));
+
+        err = dav_dbm_store(db, key, value);
+        if (err != NULL)
+            ap_log_error(APLOG_MARK, APLOG_WARNING, err->aprerr, ap_server_conf,
+                         APLOGNO(00577) "Error writing propdb: %s", err->desc);
+    }
+
+    dav_dbm_close(db);
+}
+
+static dav_error * dav_propdb_define_namespaces(dav_db *db, dav_xmlns_info *xi)
+{
+    int ns;
+    const char *uri = db->ns_table.buf + sizeof(dav_propdb_metadata);
+
+    /* within the prop values, we use "ns%d" for prefixes... register them */
+    for (ns = 0; ns < db->ns_count; ++ns, uri += strlen(uri) + 1) {
+
+        /* Empty URIs signify the empty namespace. These do not get a
+           namespace prefix. when we generate the value, we will simply
+           leave off the prefix, which is defined by mod_dav to be the
+           empty namespace. */
+        if (*uri == '\0')
+            continue;
+
+        /* ns_table.buf can move, so copy its value (we want the values to
+           last as long as the provided dav_xmlns_info). */
+        dav_xmlns_add(xi,
+                      apr_psprintf(xi->pool, "ns%d", ns),
+                      apr_pstrdup(xi->pool, uri));
+    }
+
+    return NULL;
+}
+
+static dav_error * dav_propdb_output_value(dav_db *db,
+                                           const dav_prop_name *name,
+                                           dav_xmlns_info *xi,
+                                           apr_text_header *phdr,
+                                           int *found)
+{
+    apr_datum_t key = dav_build_key(db, name);
+    apr_datum_t value;
+    dav_error *err;
+
+    if ((err = dav_dbm_fetch(db, key, &value)) != NULL)
+        return err;
+    if (value.dptr == NULL) {
+        *found = 0;
+        return NULL;
+    }
+    *found = 1;
+
+    dav_append_prop(db->pool, key.dptr, value.dptr, phdr);
+
+    dav_dbm_freedatum(db, value);
+
+    return NULL;
+}
+
+static dav_error * dav_propdb_map_namespaces(
+    dav_db *db,
+    const apr_array_header_t *namespaces,
+    dav_namespace_map **mapping)
+{
+    dav_namespace_map *m = apr_palloc(db->pool, sizeof(*m));
+    int i;
+    int *pmap;
+    const char **puri;
+
+    /*
+    ** Iterate over the provided namespaces. If a namespace already appears
+    ** in our internal map of URI -> ns_id, then store that in the map. If
+    ** we don't know the namespace yet, then add it to the map and to our
+    ** table of known namespaces.
+    */
+    m->ns_map = pmap = apr_palloc(db->pool, namespaces->nelts * sizeof(*pmap));
+    for (i = namespaces->nelts, puri = (const char **)namespaces->elts;
+         i-- > 0;
+         ++puri, ++pmap) {
+
+        const char *uri = *puri;
+        apr_size_t uri_len = strlen(uri);
+        long ns_id = (long)apr_hash_get(db->uri_index, uri, uri_len);
+
+        if (ns_id == 0) {
+            dav_check_bufsize(db->pool, &db->ns_table, uri_len + 1);
+            memcpy(db->ns_table.buf + db->ns_table.cur_len, uri, uri_len + 1);
+            db->ns_table.cur_len += uri_len + 1;
+
+            /* copy the uri in case the passed-in namespaces changes in
+               some way. */
+            apr_hash_set(db->uri_index, apr_pstrdup(db->pool, uri), uri_len,
+                         (void *)((long)(db->ns_count + 1)));
+
+            db->ns_table_dirty = 1;
+
+            *pmap = db->ns_count++;
+        }
+        else {
+            *pmap = ns_id - 1;
+        }
+    }
+
+    *mapping = m;
+    return NULL;
+}
+
+static dav_error * dav_propdb_store(dav_db *db, const dav_prop_name *name,
+                                    const apr_xml_elem *elem,
+                                    dav_namespace_map *mapping)
+{
+    apr_datum_t key = dav_build_key(db, name);
+    apr_datum_t value;
+
+    /* Note: mapping->ns_map was set up in dav_propdb_map_namespaces() */
+
+    /* ### use a db- subpool for these values? clear on exit? */
+
+    /* quote all the values in the element */
+    /* ### be nice to do this without affecting the element itself */
+    /* ### of course, the cast indicates Badness is occurring here */
+    apr_xml_quote_elem(db->pool, (apr_xml_elem *)elem);
+
+    /* generate a text blob for the xml:lang plus the contents */
+    apr_xml_to_text(db->pool, elem, APR_XML_X2T_LANG_INNER, NULL,
+                    mapping->ns_map,
+                    (const char **)&value.dptr, &value.dsize);
+
+    return dav_dbm_store(db, key, value);
+}
+
+static dav_error * dav_propdb_remove(dav_db *db, const dav_prop_name *name)
+{
+    apr_datum_t key = dav_build_key(db, name);
+    return dav_dbm_delete(db, key);
+}
+
+static int dav_propdb_exists(dav_db *db, const dav_prop_name *name)
+{
+    apr_datum_t key = dav_build_key(db, name);
+    return dav_dbm_exists(db, key);
+}
+
+static const char *dav_get_ns_table_uri(dav_db *db, int ns_id)
+{
+    const char *p = db->ns_table.buf + sizeof(dav_propdb_metadata);
+
+    while (ns_id--)
+        p += strlen(p) + 1;
+
+    return p;
+}
+
+static void dav_set_name(dav_db *db, dav_prop_name *pname)
+{
+    const char *s = db->iter.dptr;
+
+    if (s == NULL) {
+        pname->ns = pname->name = NULL;
+    }
+    else if (*s == ':') {
+        pname->ns = "";
+        pname->name = s + 1;
+    }
+    else {
+        int id = atoi(s);
+
+        pname->ns = dav_get_ns_table_uri(db, id);
+        if (s[1] == ':') {
+            pname->name = s + 2;
+        }
+        else {
+            pname->name = ap_strchr_c(s + 2, ':') + 1;
+        }
+    }
+}
+
+static dav_error * dav_propdb_next_name(dav_db *db, dav_prop_name *pname)
+{
+    dav_error *err;
+
+    /* free the previous key. note: if the loop is aborted, then the DBM
+       will toss the key (via pool cleanup) */
+    if (db->iter.dptr != NULL)
+        dav_dbm_freedatum(db, db->iter);
+
+    if ((err = dav_dbm_nextkey(db, &db->iter)) != NULL)
+        return err;
+
+    /* skip past the METADATA key */
+    if (db->iter.dptr != NULL && *db->iter.dptr == 'M')
+        return dav_propdb_next_name(db, pname);
+
+    dav_set_name(db, pname);
+    return NULL;
+}
+
+static dav_error * dav_propdb_first_name(dav_db *db, dav_prop_name *pname)
+{
+    dav_error *err;
+
+    if ((err = dav_dbm_firstkey(db, &db->iter)) != NULL)
+        return err;
+
+    /* skip past the METADATA key */
+    if (db->iter.dptr != NULL && *db->iter.dptr == 'M')
+        return dav_propdb_next_name(db, pname);
+
+    dav_set_name(db, pname);
+    return NULL;
+}
+
+static dav_error * dav_propdb_get_rollback(dav_db *db,
+                                           const dav_prop_name *name,
+                                           dav_deadprop_rollback **prollback)
+{
+    dav_deadprop_rollback *rb = apr_pcalloc(db->pool, sizeof(*rb));
+    apr_datum_t key;
+    apr_datum_t value;
+    dav_error *err;
+
+    key = dav_build_key(db, name);
+    rb->key.dptr = apr_pstrdup(db->pool, key.dptr);
+    rb->key.dsize = key.dsize;
+
+    if ((err = dav_dbm_fetch(db, key, &value)) != NULL)
+        return err;
+    if (value.dptr != NULL) {
+        rb->value.dptr = apr_pmemdup(db->pool, value.dptr, value.dsize);
+        rb->value.dsize = value.dsize;
+    }
+
+    *prollback = rb;
+    return NULL;
+}
+
+static dav_error * dav_propdb_apply_rollback(dav_db *db,
+                                             dav_deadprop_rollback *rollback)
+{
+    if (!rollback) {
+        return NULL; /* no rollback, nothing to do */
+    }
+
+    if (rollback->value.dptr == NULL) {
+        /* don't fail if the thing isn't really there. */
+        (void) dav_dbm_delete(db, rollback->key);
+        return NULL;
+    }
+
+    return dav_dbm_store(db, rollback->key, rollback->value);
+}
+
+const dav_hooks_db dav_hooks_db_dbm =
+{
+    dav_propdb_open,
+    dav_propdb_close,
+    dav_propdb_define_namespaces,
+    dav_propdb_output_value,
+    dav_propdb_map_namespaces,
+    dav_propdb_store,
+    dav_propdb_remove,
+    dav_propdb_exists,
+    dav_propdb_first_name,
+    dav_propdb_next_name,
+    dav_propdb_get_rollback,
+    dav_propdb_apply_rollback,
+
+    NULL /* ctx */
+};
diff --git a/modules/dav/fs/lock.c b/modules/dav/fs/lock.c
new file mode 100644
index 0000000..c058e2e
--- /dev/null
+++ b/modules/dav/fs/lock.c
@@ -0,0 +1,1445 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+** DAV filesystem lock implementation
+*/
+
+#include "apr.h"
+#include "apr_strings.h"
+#include "apr_file_io.h"
+#include "apr_uuid.h"
+
+#define APR_WANT_MEMFUNC
+#include "apr_want.h"
+
+#include "httpd.h"
+#include "http_log.h"
+
+#include "mod_dav.h"
+#include "repos.h"
+
+
+/* ---------------------------------------------------------------
+**
+** Lock database primitives
+**
+*/
+
+/*
+** LOCK DATABASES
+**
+** Lockdiscovery information is stored in the single lock database specified
+** by the DAVLockDB directive.  Information about this db is stored in the
+** global server configuration.
+**
+** KEY
+**
+** The database is keyed by a key_type unsigned char (DAV_TYPE_FNAME)
+** followed by the full path. The key_type DAV_TYPE_INODE is not used anymore.
+**
+** VALUE
+**
+** The value consists of a list of elements.
+**    DIRECT LOCK:     [char      (DAV_LOCK_DIRECT),
+**                      char      (dav_lock_scope),
+**                      char      (dav_lock_type),
+**                      int        depth,
+**                      time_t     expires,
+**                      apr_uuid_t locktoken,
+**                      char[]     owner,
+**                      char[]     auth_user]
+**
+**    INDIRECT LOCK:   [char      (DAV_LOCK_INDIRECT),
+**                      apr_uuid_t locktoken,
+**                      time_t     expires,
+**                      apr_size_t key_size,
+**                      char[]     key]
+**       The key is to the collection lock that resulted in this indirect lock
+*/
+
+#define DAV_TRUE                1
+#define DAV_FALSE               0
+
+#define DAV_CREATE_LIST         23
+#define DAV_APPEND_LIST         24
+
+/* Stored lock_discovery prefix */
+#define DAV_LOCK_DIRECT         1
+#define DAV_LOCK_INDIRECT       2
+
+/*
+ * not used anymore
+ * #define DAV_TYPE_INODE          10
+ */
+#define DAV_TYPE_FNAME          11
+
+
+/* ack. forward declare. */
+static dav_error * dav_fs_remove_locknull_member(apr_pool_t *p,
+                                                 const char *filename,
+                                                 dav_buffer *pbuf);
+
+/*
+** Use the opaquelock scheme for locktokens
+*/
+struct dav_locktoken {
+    apr_uuid_t uuid;
+};
+#define dav_compare_locktoken(plt1, plt2) \
+                memcmp(&(plt1)->uuid, &(plt2)->uuid, sizeof((plt1)->uuid))
+
+
+/* #################################################################
+** ### keep these structures (internal) or move fully to dav_lock?
+*/
+
+/*
+** We need to reliably size the fixed-length portion of
+** dav_lock_discovery; best to separate it into another
+** struct for a convenient sizeof, unless we pack lock_discovery.
+*/
+typedef struct dav_lock_discovery_fixed
+{
+    char scope;
+    char type;
+    int depth;
+    time_t timeout;
+} dav_lock_discovery_fixed;
+
+typedef struct dav_lock_discovery
+{
+    struct dav_lock_discovery_fixed f;
+
+    dav_locktoken *locktoken;
+    const char *owner;         /* owner field from activelock */
+    const char *auth_user;     /* authenticated user who created the lock */
+    struct dav_lock_discovery *next;
+} dav_lock_discovery;
+
+/* Indirect locks represent locks inherited from containing collections.
+ * They reference the lock token for the collection the lock is
+ * inherited from. A lock provider may also define a key to the
+ * inherited lock, for fast datbase lookup. The key is opaque outside
+ * the lock provider.
+ */
+typedef struct dav_lock_indirect
+{
+    dav_locktoken *locktoken;
+    apr_datum_t key;
+    struct dav_lock_indirect *next;
+    time_t timeout;
+} dav_lock_indirect;
+
+/* ################################################################# */
+
+
+/*
+** Stored direct lock info - full lock_discovery length:
+** prefix + Fixed length + lock token + 2 strings + 2 nulls (one for each string)
+*/
+#define dav_size_direct(a)   ( 1 + sizeof(dav_lock_discovery_fixed) \
+                                 + sizeof(apr_uuid_t) \
+                                 + ((a)->owner ? strlen((a)->owner) : 0) \
+                                 + ((a)->auth_user ? strlen((a)->auth_user) : 0) \
+                                 + 2)
+
+/* Stored indirect lock info - lock token and apr_datum_t */
+#define dav_size_indirect(a)  (1 + sizeof(apr_uuid_t) \
+                                 + sizeof(time_t) \
+                                 + sizeof((a)->key.dsize) + (a)->key.dsize)
+
+/*
+** The lockdb structure.
+**
+** The <db> field may be NULL, meaning one of two things:
+** 1) That we have not actually opened the underlying database (yet). The
+**    <opened> field should be false.
+** 2) We opened it readonly and it wasn't present.
+**
+** The delayed opening (determined by <opened>) makes creating a lockdb
+** quick, while deferring the underlying I/O until it is actually required.
+**
+** We export the notion of a lockdb, but hide the details of it. Most
+** implementations will use a database of some kind, but it is certainly
+** possible that alternatives could be used.
+*/
+struct dav_lockdb_private
+{
+    request_rec *r;                  /* for accessing the uuid state */
+    apr_pool_t *pool;                /* a pool to use */
+    const char *lockdb_path;         /* where is the lock database? */
+
+    int opened;                      /* we opened the database */
+    dav_db *db;                      /* if non-NULL, the lock database */
+};
+typedef struct
+{
+    dav_lockdb pub;
+    dav_lockdb_private priv;
+} dav_lockdb_combined;
+
+/*
+** The private part of the lock structure.
+*/
+struct dav_lock_private
+{
+    apr_datum_t key;   /* key into the lock database */
+};
+typedef struct
+{
+    dav_lock pub;
+    dav_lock_private priv;
+    dav_locktoken token;
+} dav_lock_combined;
+
+/*
+** This must be forward-declared so the open_lockdb function can use it.
+*/
+extern const dav_hooks_locks dav_hooks_locks_fs;
+
+
+/* internal function for creating locks */
+static dav_lock *dav_fs_alloc_lock(dav_lockdb *lockdb, apr_datum_t key,
+                                   const dav_locktoken *locktoken)
+{
+    dav_lock_combined *comb;
+
+    comb = apr_pcalloc(lockdb->info->pool, sizeof(*comb));
+    comb->pub.rectype = DAV_LOCKREC_DIRECT;
+    comb->pub.info = &comb->priv;
+    comb->priv.key = key;
+
+    if (locktoken == NULL) {
+        comb->pub.locktoken = &comb->token;
+        apr_uuid_get(&comb->token.uuid);
+    }
+    else {
+        comb->pub.locktoken = locktoken;
+    }
+
+    return &comb->pub;
+}
+
+/*
+** dav_fs_parse_locktoken
+**
+** Parse an opaquelocktoken URI into a locktoken.
+*/
+static dav_error * dav_fs_parse_locktoken(
+    apr_pool_t *p,
+    const char *char_token,
+    dav_locktoken **locktoken_p)
+{
+    dav_locktoken *locktoken;
+
+    if (ap_strstr_c(char_token, "opaquelocktoken:") != char_token) {
+        return dav_new_error(p,
+                             HTTP_BAD_REQUEST, DAV_ERR_LOCK_UNK_STATE_TOKEN, 0,
+                             "The lock token uses an unknown State-token "
+                             "format and could not be parsed.");
+    }
+    char_token += 16;
+
+    locktoken = apr_pcalloc(p, sizeof(*locktoken));
+    if (apr_uuid_parse(&locktoken->uuid, char_token)) {
+        return dav_new_error(p, HTTP_BAD_REQUEST, DAV_ERR_LOCK_PARSE_TOKEN, 0,
+                             "The opaquelocktoken has an incorrect format "
+                             "and could not be parsed.");
+    }
+
+    *locktoken_p = locktoken;
+    return NULL;
+}
+
+/*
+** dav_fs_format_locktoken
+**
+** Generate the URI for a locktoken
+*/
+static const char *dav_fs_format_locktoken(
+    apr_pool_t *p,
+    const dav_locktoken *locktoken)
+{
+    char buf[APR_UUID_FORMATTED_LENGTH + 1];
+
+    apr_uuid_format(buf, &locktoken->uuid);
+    return apr_pstrcat(p, "opaquelocktoken:", buf, NULL);
+}
+
+/*
+** dav_fs_compare_locktoken
+**
+** Determine whether two locktokens are the same
+*/
+static int dav_fs_compare_locktoken(
+    const dav_locktoken *lt1,
+    const dav_locktoken *lt2)
+{
+    return dav_compare_locktoken(lt1, lt2);
+}
+
+/*
+** dav_fs_really_open_lockdb:
+**
+** If the database hasn't been opened yet, then open the thing.
+*/
+static dav_error * dav_fs_really_open_lockdb(dav_lockdb *lockdb)
+{
+    dav_error *err;
+
+    if (lockdb->info->opened)
+        return NULL;
+
+    err = dav_dbm_open_direct(lockdb->info->pool,
+                              lockdb->info->lockdb_path,
+                              lockdb->ro,
+                              &lockdb->info->db);
+    if (err != NULL) {
+        return dav_push_error(lockdb->info->pool,
+                              HTTP_INTERNAL_SERVER_ERROR,
+                              DAV_ERR_LOCK_OPENDB,
+                              "Could not open the lock database.",
+                              err);
+    }
+
+    /* all right. it is opened now. */
+    lockdb->info->opened = 1;
+
+    return NULL;
+}
+
+/*
+** dav_fs_open_lockdb:
+**
+** "open" the lock database, as specified in the global server configuration.
+** If force is TRUE, then the database is opened now, rather than lazily.
+**
+** Note that only one can be open read/write.
+*/
+static dav_error * dav_fs_open_lockdb(request_rec *r, int ro, int force,
+                                      dav_lockdb **lockdb)
+{
+    dav_lockdb_combined *comb;
+
+    comb = apr_pcalloc(r->pool, sizeof(*comb));
+    comb->pub.hooks = &dav_hooks_locks_fs;
+    comb->pub.ro = ro;
+    comb->pub.info = &comb->priv;
+    comb->priv.r = r;
+    comb->priv.pool = r->pool;
+
+    comb->priv.lockdb_path = dav_get_lockdb_path(r);
+    if (comb->priv.lockdb_path == NULL) {
+        return dav_new_error(r->pool, HTTP_INTERNAL_SERVER_ERROR,
+                             DAV_ERR_LOCK_NO_DB, 0,
+                             "A lock database was not specified with the "
+                             "DAVLockDB directive. One must be specified "
+                             "to use the locking functionality.");
+    }
+
+    /* done initializing. return it. */
+    *lockdb = &comb->pub;
+
+    if (force) {
+        /* ### add a higher-level comment? */
+        return dav_fs_really_open_lockdb(*lockdb);
+    }
+
+    return NULL;
+}
+
+/*
+** dav_fs_close_lockdb:
+**
+** Close it. Duh.
+*/
+static void dav_fs_close_lockdb(dav_lockdb *lockdb)
+{
+    if (lockdb->info->db != NULL)
+        dav_dbm_close(lockdb->info->db);
+}
+
+/*
+** dav_fs_build_key:  Given a resource, return a apr_datum_t key
+**    to look up lock information for this file.
+*/
+static apr_datum_t dav_fs_build_key(apr_pool_t *p,
+                                    const dav_resource *resource)
+{
+    const char *pathname = dav_fs_pathname(resource);
+    apr_datum_t key;
+
+    /* ### does this allocation have a proper lifetime? need to check */
+    /* ### can we use a buffer for this? */
+
+    /* size is TYPE + pathname + null */
+    key.dsize = strlen(pathname) + 2;
+    key.dptr = apr_palloc(p, key.dsize);
+    *key.dptr = DAV_TYPE_FNAME;
+    memcpy(key.dptr + 1, pathname, key.dsize - 1);
+    if (key.dptr[key.dsize - 2] == '/')
+        key.dptr[--key.dsize - 1] = '\0';
+    return key;
+}
+
+/*
+** dav_fs_lock_expired:  return 1 (true) if the given timeout is in the past
+**    or present (the lock has expired), or 0 (false) if in the future
+**    (the lock has not yet expired).
+*/
+static int dav_fs_lock_expired(time_t expires)
+{
+    return expires != DAV_TIMEOUT_INFINITE && time(NULL) >= expires;
+}
+
+/*
+** dav_fs_save_lock_record:  Saves the lock information specified in the
+**    direct and indirect lock lists about path into the lock database.
+**    If direct and indirect == NULL, the key is removed.
+*/
+static dav_error * dav_fs_save_lock_record(dav_lockdb *lockdb, apr_datum_t key,
+                                           dav_lock_discovery *direct,
+                                           dav_lock_indirect *indirect)
+{
+    dav_error *err;
+    apr_datum_t val = { 0 };
+    char *ptr;
+    dav_lock_discovery *dp = direct;
+    dav_lock_indirect *ip = indirect;
+
+#if DAV_DEBUG
+    if (lockdb->ro) {
+        return dav_new_error(lockdb->info->pool,
+                             HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                             "INTERNAL DESIGN ERROR: the lockdb was opened "
+                             "readonly, but an attempt to save locks was "
+                             "performed.");
+    }
+#endif
+
+    if ((err = dav_fs_really_open_lockdb(lockdb)) != NULL) {
+        /* ### add a higher-level error? */
+        return err;
+    }
+
+    /* If nothing to save, delete key */
+    if (dp == NULL && ip == NULL) {
+        /* don't fail if the key is not present */
+        /* ### but what about other errors? */
+        (void) dav_dbm_delete(lockdb->info->db, key);
+        return NULL;
+    }
+
+    while(dp) {
+        val.dsize += dav_size_direct(dp);
+        dp = dp->next;
+    }
+    while(ip) {
+        val.dsize += dav_size_indirect(ip);
+        ip = ip->next;
+    }
+
+    /* ### can this be apr_palloc() ? */
+    /* ### hmmm.... investigate the use of a buffer here */
+    ptr = val.dptr = apr_pcalloc(lockdb->info->pool, val.dsize);
+    dp  = direct;
+    ip  = indirect;
+
+    while(dp) {
+        *ptr++ = DAV_LOCK_DIRECT;   /* Direct lock - lock_discovery struct follows */
+        memcpy(ptr, dp, sizeof(dp->f));   /* Fixed portion of struct */
+        ptr += sizeof(dp->f);
+        memcpy(ptr, dp->locktoken, sizeof(*dp->locktoken));
+        ptr += sizeof(*dp->locktoken);
+        if (dp->owner == NULL) {
+            *ptr++ = '\0';
+        }
+        else {
+            memcpy(ptr, dp->owner, strlen(dp->owner) + 1);
+            ptr += strlen(dp->owner) + 1;
+        }
+        if (dp->auth_user == NULL) {
+            *ptr++ = '\0';
+        }
+        else {
+            memcpy(ptr, dp->auth_user, strlen(dp->auth_user) + 1);
+            ptr += strlen(dp->auth_user) + 1;
+        }
+
+        dp = dp->next;
+    }
+
+    while(ip) {
+        *ptr++ = DAV_LOCK_INDIRECT;   /* Indirect lock prefix */
+        memcpy(ptr, ip->locktoken, sizeof(*ip->locktoken));   /* Locktoken */
+        ptr += sizeof(*ip->locktoken);
+        memcpy(ptr, &ip->timeout, sizeof(ip->timeout));   /* Expire time */
+        ptr += sizeof(ip->timeout);
+        memcpy(ptr, &ip->key.dsize, sizeof(ip->key.dsize));   /* Size of key */
+        ptr += sizeof(ip->key.dsize);
+        memcpy(ptr, ip->key.dptr, ip->key.dsize);   /* Key data */
+        ptr += ip->key.dsize;
+        ip = ip->next;
+    }
+
+    if ((err = dav_dbm_store(lockdb->info->db, key, val)) != NULL) {
+        /* ### more details? add an error_id? */
+        return dav_push_error(lockdb->info->pool,
+                              HTTP_INTERNAL_SERVER_ERROR,
+                              DAV_ERR_LOCK_SAVE_LOCK,
+                              "Could not save lock information.",
+                              err);
+    }
+
+    return NULL;
+}
+
+/*
+** dav_load_lock_record:  Reads lock information about key from lock db;
+**    creates linked lists of the direct and indirect locks.
+**
+**    If add_method = DAV_APPEND_LIST, the result will be appended to the
+**    head of the direct and indirect lists supplied.
+**
+**    Passive lock removal:  If lock has timed out, it will not be returned.
+**    ### How much "logging" does RFC 2518 require?
+*/
+static dav_error * dav_fs_load_lock_record(dav_lockdb *lockdb, apr_datum_t key,
+                                           int add_method,
+                                           dav_lock_discovery **direct,
+                                           dav_lock_indirect **indirect)
+{
+    apr_pool_t *p = lockdb->info->pool;
+    dav_error *err;
+    apr_size_t offset = 0;
+    int need_save = DAV_FALSE;
+    apr_datum_t val = { 0 };
+    dav_lock_discovery *dp;
+    dav_lock_indirect *ip;
+    dav_buffer buf = { 0 };
+
+    if (add_method != DAV_APPEND_LIST) {
+        *direct = NULL;
+        *indirect = NULL;
+    }
+
+    if ((err = dav_fs_really_open_lockdb(lockdb)) != NULL) {
+        /* ### add a higher-level error? */
+        return err;
+    }
+
+    /*
+    ** If we opened readonly and the db wasn't there, then there are no
+    ** locks for this resource. Just exit.
+    */
+    if (lockdb->info->db == NULL)
+        return NULL;
+
+    if ((err = dav_dbm_fetch(lockdb->info->db, key, &val)) != NULL)
+        return err;
+
+    if (!val.dsize)
+        return NULL;
+
+    while (offset < val.dsize) {
+        switch (*(val.dptr + offset++)) {
+        case DAV_LOCK_DIRECT:
+            /* Create and fill a dav_lock_discovery structure */
+
+            dp = apr_pcalloc(p, sizeof(*dp));
+            memcpy(dp, val.dptr + offset, sizeof(dp->f));
+            offset += sizeof(dp->f);
+            dp->locktoken = apr_pmemdup(p, val.dptr + offset, sizeof(*dp->locktoken));
+            offset += sizeof(*dp->locktoken);
+            if (*(val.dptr + offset) == '\0') {
+                ++offset;
+            }
+            else {
+                dp->owner = apr_pstrdup(p, val.dptr + offset);
+                offset += strlen(dp->owner) + 1;
+            }
+
+            if (*(val.dptr + offset) == '\0') {
+                ++offset;
+            }
+            else {
+                dp->auth_user = apr_pstrdup(p, val.dptr + offset);
+                offset += strlen(dp->auth_user) + 1;
+            }
+
+            if (!dav_fs_lock_expired(dp->f.timeout)) {
+                dp->next = *direct;
+                *direct = dp;
+            }
+            else {
+                need_save = DAV_TRUE;
+
+                /* Remove timed-out locknull fm .locknull list */
+                if (*key.dptr == DAV_TYPE_FNAME) {
+                    const char *fname = key.dptr + 1;
+                    apr_finfo_t finfo;
+                    apr_status_t rv;
+
+                    /* if we don't see the file, then it's a locknull */
+                    rv = apr_stat(&finfo, fname, APR_FINFO_MIN | APR_FINFO_LINK, p);
+                    if (rv != APR_SUCCESS && rv != APR_INCOMPLETE) {
+                        if ((err = dav_fs_remove_locknull_member(p, fname, &buf)) != NULL) {
+                            /* ### push a higher-level description? */
+                            return err;
+                        }
+                    }
+                }
+            }
+            break;
+
+        case DAV_LOCK_INDIRECT:
+            /* Create and fill a dav_lock_indirect structure */
+
+            ip = apr_pcalloc(p, sizeof(*ip));
+            ip->locktoken = apr_pmemdup(p, val.dptr + offset, sizeof(*ip->locktoken));
+            offset += sizeof(*ip->locktoken);
+            memcpy(&ip->timeout, val.dptr + offset, sizeof(ip->timeout));
+            offset += sizeof(ip->timeout);
+            memcpy(&ip->key.dsize, val.dptr + offset, sizeof(ip->key.dsize)); /* length of datum */
+            offset += sizeof(ip->key.dsize);
+            ip->key.dptr = apr_pmemdup(p, val.dptr + offset, ip->key.dsize);
+            offset += ip->key.dsize;
+
+            if (!dav_fs_lock_expired(ip->timeout)) {
+                ip->next = *indirect;
+                *indirect = ip;
+            }
+            else {
+                need_save = DAV_TRUE;
+                /* A locknull resource will never be locked indirectly */
+            }
+
+            break;
+
+        default:
+            dav_dbm_freedatum(lockdb->info->db, val);
+
+            /* ### should use a computed_desc and insert corrupt token data */
+            --offset;
+            return dav_new_error(p,
+                                 HTTP_INTERNAL_SERVER_ERROR,
+                                 DAV_ERR_LOCK_CORRUPT_DB, 0,
+                                 apr_psprintf(p,
+                                             "The lock database was found to "
+                                             "be corrupt. offset %"
+                                             APR_SIZE_T_FMT ", c=%02x",
+                                             offset, val.dptr[offset]));
+        }
+    }
+
+    dav_dbm_freedatum(lockdb->info->db, val);
+
+    /* Clean up this record if we found expired locks */
+    /*
+    ** ### shouldn't do this if we've been opened READONLY. elide the
+    ** ### timed-out locks from the response, but don't save that info back
+    */
+    if (need_save == DAV_TRUE) {
+        return dav_fs_save_lock_record(lockdb, key, *direct, *indirect);
+    }
+
+    return NULL;
+}
+
+/* resolve <indirect>, returning <*direct> */
+static dav_error * dav_fs_resolve(dav_lockdb *lockdb,
+                                  dav_lock_indirect *indirect,
+                                  dav_lock_discovery **direct,
+                                  dav_lock_discovery **ref_dp,
+                                  dav_lock_indirect **ref_ip)
+{
+    dav_error *err;
+    dav_lock_discovery *dir;
+    dav_lock_indirect *ind;
+
+    if ((err = dav_fs_load_lock_record(lockdb, indirect->key,
+                                       DAV_CREATE_LIST,
+                                       &dir, &ind)) != NULL) {
+        /* ### insert a higher-level description? */
+        return err;
+    }
+    if (ref_dp != NULL) {
+        *ref_dp = dir;
+        *ref_ip = ind;
+    }
+
+    for (; dir != NULL; dir = dir->next) {
+        if (!dav_compare_locktoken(indirect->locktoken, dir->locktoken)) {
+            *direct = dir;
+            return NULL;
+        }
+    }
+
+    /* No match found (but we should have found one!) */
+
+    /* ### use a different description and/or error ID? */
+    return dav_new_error(lockdb->info->pool,
+                         HTTP_INTERNAL_SERVER_ERROR,
+                         DAV_ERR_LOCK_CORRUPT_DB, 0,
+                         "The lock database was found to be corrupt. "
+                         "An indirect lock's direct lock could not "
+                         "be found.");
+}
+
+/* ---------------------------------------------------------------
+**
+** Property-related lock functions
+**
+*/
+
+/*
+** dav_fs_get_supportedlock:  Returns a static string for all supportedlock
+**    properties. I think we save more returning a static string than
+**    constructing it every time, though it might look cleaner.
+*/
+static const char *dav_fs_get_supportedlock(const dav_resource *resource)
+{
+    static const char supported[] = DEBUG_CR
+        "<D:lockentry>" DEBUG_CR
+        "<D:lockscope><D:exclusive/></D:lockscope>" DEBUG_CR
+        "<D:locktype><D:write/></D:locktype>" DEBUG_CR
+        "</D:lockentry>" DEBUG_CR
+        "<D:lockentry>" DEBUG_CR
+        "<D:lockscope><D:shared/></D:lockscope>" DEBUG_CR
+        "<D:locktype><D:write/></D:locktype>" DEBUG_CR
+        "</D:lockentry>" DEBUG_CR;
+
+    return supported;
+}
+
+/* ---------------------------------------------------------------
+**
+** General lock functions
+**
+*/
+
+/* ---------------------------------------------------------------
+**
+** Functions dealing with lock-null resources
+**
+*/
+
+/*
+** dav_fs_load_locknull_list:  Returns a dav_buffer dump of the locknull file
+**    for the given directory.
+*/
+static dav_error * dav_fs_load_locknull_list(apr_pool_t *p, const char *dirpath,
+                                             dav_buffer *pbuf)
+{
+    apr_finfo_t finfo;
+    apr_file_t *file = NULL;
+    dav_error *err = NULL;
+    apr_size_t amt;
+    apr_status_t rv;
+
+    dav_buffer_init(p, pbuf, dirpath);
+
+    if (pbuf->buf[pbuf->cur_len - 1] == '/')
+        pbuf->buf[--pbuf->cur_len] = '\0';
+
+    dav_buffer_place(p, pbuf, "/" DAV_FS_STATE_DIR "/" DAV_FS_LOCK_NULL_FILE);
+
+    /* reset this in case we leave w/o reading into the buffer */
+    pbuf->cur_len = 0;
+
+    if (apr_file_open(&file, pbuf->buf, APR_READ | APR_BINARY, APR_OS_DEFAULT,
+                p) != APR_SUCCESS) {
+        return NULL;
+    }
+
+    rv = apr_file_info_get(&finfo, APR_FINFO_SIZE, file);
+    if (rv != APR_SUCCESS) {
+        err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
+                            apr_psprintf(p,
+                                        "Opened but could not stat file %s",
+                                        pbuf->buf));
+        goto loaderror;
+    }
+
+    if (finfo.size != (apr_size_t)finfo.size) {
+        err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                            apr_psprintf(p,
+                                        "Opened but rejected huge file %s",
+                                        pbuf->buf));
+        goto loaderror;
+    }
+
+    amt = (apr_size_t)finfo.size;
+    dav_set_bufsize(p, pbuf, amt);
+    if ((rv = apr_file_read(file, pbuf->buf, &amt)) != APR_SUCCESS
+        || amt != finfo.size) {
+        err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
+                            apr_psprintf(p,
+                                        "Failure reading locknull file "
+                                        "for %s", dirpath));
+
+        /* just in case the caller disregards the returned error */
+        pbuf->cur_len = 0;
+        goto loaderror;
+    }
+
+  loaderror:
+    apr_file_close(file);
+    return err;
+}
+
+/*
+** dav_fs_save_locknull_list:  Saves contents of pbuf into the
+**    locknull file for dirpath.
+*/
+static dav_error * dav_fs_save_locknull_list(apr_pool_t *p, const char *dirpath,
+                                             dav_buffer *pbuf)
+{
+    const char *pathname;
+    apr_file_t *file = NULL;
+    dav_error *err = NULL;
+    apr_size_t amt;
+    apr_status_t rv;
+
+    if (pbuf->buf == NULL)
+        return NULL;
+
+    dav_fs_ensure_state_dir(p, dirpath);
+    pathname = apr_pstrcat(p,
+                          dirpath,
+                          dirpath[strlen(dirpath) - 1] == '/' ? "" : "/",
+                          DAV_FS_STATE_DIR "/" DAV_FS_LOCK_NULL_FILE,
+                          NULL);
+
+    if (pbuf->cur_len == 0) {
+        /* delete the file if cur_len == 0 */
+        if ((rv = apr_file_remove(pathname, p)) != APR_SUCCESS) {
+            return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
+                                 apr_psprintf(p,
+                                             "Error removing %s", pathname));
+        }
+        return NULL;
+    }
+
+    if ((rv = apr_file_open(&file, pathname,
+                            APR_WRITE | APR_CREATE | APR_TRUNCATE | APR_BINARY,
+                            APR_OS_DEFAULT, p)) != APR_SUCCESS) {
+        return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
+                             apr_psprintf(p,
+                                         "Error opening %s for writing",
+                                         pathname));
+    }
+
+    amt = pbuf->cur_len;
+    if ((rv = apr_file_write_full(file, pbuf->buf, amt, &amt)) != APR_SUCCESS
+        || amt != pbuf->cur_len) {
+        err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
+                            apr_psprintf(p,
+                                        "Error writing %" APR_SIZE_T_FMT
+                                        " bytes to %s",
+                                        pbuf->cur_len, pathname));
+    }
+
+    apr_file_close(file);
+    return err;
+}
+
+/*
+** dav_fs_remove_locknull_member:  Removes filename from the locknull list
+**    for directory path.
+*/
+static dav_error * dav_fs_remove_locknull_member(apr_pool_t *p,
+                                                 const char *filename,
+                                                 dav_buffer *pbuf)
+{
+    dav_error *err;
+    apr_size_t len;
+    apr_size_t scanlen;
+    char *scan;
+    const char *scanend;
+    char *dirpath = apr_pstrdup(p, filename);
+    char *fname = strrchr(dirpath, '/');
+    int dirty = 0;
+
+    if (fname != NULL)
+        *fname++ = '\0';
+    else
+        fname = dirpath;
+    len = strlen(fname) + 1;
+
+    if ((err = dav_fs_load_locknull_list(p, dirpath, pbuf)) != NULL) {
+        /* ### add a higher level description? */
+        return err;
+    }
+
+    for (scan = pbuf->buf, scanend = scan + pbuf->cur_len;
+         scan < scanend;
+         scan += scanlen) {
+        scanlen = strlen(scan) + 1;
+        if (len == scanlen && memcmp(fname, scan, scanlen) == 0) {
+            pbuf->cur_len -= scanlen;
+            memmove(scan, scan + scanlen, scanend - (scan + scanlen));
+            dirty = 1;
+            break;
+        }
+    }
+
+    if (dirty) {
+        if ((err = dav_fs_save_locknull_list(p, dirpath, pbuf)) != NULL) {
+            /* ### add a higher level description? */
+            return err;
+        }
+    }
+
+    return NULL;
+}
+
+/* Note: used by dav_fs_repos.c */
+dav_error * dav_fs_get_locknull_members(
+    const dav_resource *resource,
+    dav_buffer *pbuf)
+{
+    const char *dirpath;
+
+    /* ### should test this result value... */
+    (void) dav_fs_dir_file_name(resource, &dirpath, NULL);
+    return dav_fs_load_locknull_list(dav_fs_pool(resource), dirpath, pbuf);
+}
+
+/* ### fold into append_lock? */
+/* ### take an optional buf parameter? */
+static dav_error * dav_fs_add_locknull_state(
+    dav_lockdb *lockdb,
+    const dav_resource *resource)
+{
+    dav_buffer buf = { 0 };
+    apr_pool_t *p = lockdb->info->pool;
+    const char *dirpath;
+    const char *fname;
+    dav_error *err;
+
+    /* ### should test this result value... */
+    (void) dav_fs_dir_file_name(resource, &dirpath, &fname);
+
+    if ((err = dav_fs_load_locknull_list(p, dirpath, &buf)) != NULL) {
+        return dav_push_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,
+                              "Could not load .locknull file.", err);
+    }
+
+    dav_buffer_append(p, &buf, fname);
+    buf.cur_len++;   /* we want the null-term here */
+
+    if ((err = dav_fs_save_locknull_list(p, dirpath, &buf)) != NULL) {
+        return dav_push_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,
+                              "Could not save .locknull file.", err);
+    }
+
+    return NULL;
+}
+
+/*
+** dav_fs_remove_locknull_state:  Given a request, check to see if r->filename
+**    is/was a lock-null resource.  If so, return it to an existant state, i.e.
+**    remove it from the list in the appropriate .DAV/locknull file.
+*/
+static dav_error * dav_fs_remove_locknull_state(
+    dav_lockdb *lockdb,
+    const dav_resource *resource)
+{
+    dav_buffer buf = { 0 };
+    dav_error *err;
+    apr_pool_t *p = lockdb->info->pool;
+    const char *pathname = dav_fs_pathname(resource);
+
+    if ((err = dav_fs_remove_locknull_member(p, pathname, &buf)) != NULL) {
+        /* ### add a higher-level description? */
+        return err;
+    }
+
+    return NULL;
+}
+
+static dav_error * dav_fs_create_lock(dav_lockdb *lockdb,
+                                      const dav_resource *resource,
+                                      dav_lock **lock)
+{
+    apr_datum_t key;
+
+    key = dav_fs_build_key(lockdb->info->pool, resource);
+
+    *lock = dav_fs_alloc_lock(lockdb,
+                              key,
+                              NULL);
+
+    (*lock)->is_locknull = !resource->exists;
+
+    return NULL;
+}
+
+static dav_error * dav_fs_get_locks(dav_lockdb *lockdb,
+                                    const dav_resource *resource,
+                                    int calltype,
+                                    dav_lock **locks)
+{
+    apr_pool_t *p = lockdb->info->pool;
+    apr_datum_t key;
+    dav_error *err;
+    dav_lock *lock = NULL;
+    dav_lock *newlock;
+    dav_lock_discovery *dp;
+    dav_lock_indirect *ip;
+
+#if DAV_DEBUG
+    if (calltype == DAV_GETLOCKS_COMPLETE) {
+        return dav_new_error(lockdb->info->pool,
+                             HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                             "INTERNAL DESIGN ERROR: DAV_GETLOCKS_COMPLETE "
+                             "is not yet supported");
+    }
+#endif
+
+    key = dav_fs_build_key(p, resource);
+    if ((err = dav_fs_load_lock_record(lockdb, key, DAV_CREATE_LIST,
+                                       &dp, &ip)) != NULL) {
+        /* ### push a higher-level desc? */
+        return err;
+    }
+
+    /* copy all direct locks to the result list */
+    for (; dp != NULL; dp = dp->next) {
+        newlock = dav_fs_alloc_lock(lockdb, key, dp->locktoken);
+        newlock->is_locknull = !resource->exists;
+        newlock->scope = dp->f.scope;
+        newlock->type = dp->f.type;
+        newlock->depth = dp->f.depth;
+        newlock->timeout = dp->f.timeout;
+        newlock->owner = dp->owner;
+        newlock->auth_user = dp->auth_user;
+
+        /* hook into the result list */
+        newlock->next = lock;
+        lock = newlock;
+    }
+
+    /* copy all the indirect locks to the result list. resolve as needed. */
+    for (; ip != NULL; ip = ip->next) {
+        newlock = dav_fs_alloc_lock(lockdb, ip->key, ip->locktoken);
+        newlock->is_locknull = !resource->exists;
+
+        if (calltype == DAV_GETLOCKS_RESOLVED) {
+            if ((err = dav_fs_resolve(lockdb, ip, &dp, NULL, NULL)) != NULL) {
+                /* ### push a higher-level desc? */
+                return err;
+            }
+
+            newlock->scope = dp->f.scope;
+            newlock->type = dp->f.type;
+            newlock->depth = dp->f.depth;
+            newlock->timeout = dp->f.timeout;
+            newlock->owner = dp->owner;
+            newlock->auth_user = dp->auth_user;
+        }
+        else {
+            /* DAV_GETLOCKS_PARTIAL */
+            newlock->rectype = DAV_LOCKREC_INDIRECT_PARTIAL;
+        }
+
+        /* hook into the result list */
+        newlock->next = lock;
+        lock = newlock;
+    }
+
+    *locks = lock;
+    return NULL;
+}
+
+static dav_error * dav_fs_find_lock(dav_lockdb *lockdb,
+                                    const dav_resource *resource,
+                                    const dav_locktoken *locktoken,
+                                    int partial_ok,
+                                    dav_lock **lock)
+{
+    dav_error *err;
+    apr_datum_t key;
+    dav_lock_discovery *dp;
+    dav_lock_indirect *ip;
+
+    *lock = NULL;
+
+    key = dav_fs_build_key(lockdb->info->pool, resource);
+    if ((err = dav_fs_load_lock_record(lockdb, key, DAV_CREATE_LIST,
+                                       &dp, &ip)) != NULL) {
+        /* ### push a higher-level desc? */
+        return err;
+    }
+
+    for (; dp != NULL; dp = dp->next) {
+        if (!dav_compare_locktoken(locktoken, dp->locktoken)) {
+            *lock = dav_fs_alloc_lock(lockdb, key, locktoken);
+            (*lock)->is_locknull = !resource->exists;
+            (*lock)->scope = dp->f.scope;
+            (*lock)->type = dp->f.type;
+            (*lock)->depth = dp->f.depth;
+            (*lock)->timeout = dp->f.timeout;
+            (*lock)->owner = dp->owner;
+            (*lock)->auth_user = dp->auth_user;
+            return NULL;
+        }
+    }
+
+    for (; ip != NULL; ip = ip->next) {
+        if (!dav_compare_locktoken(locktoken, ip->locktoken)) {
+            *lock = dav_fs_alloc_lock(lockdb, ip->key, locktoken);
+            (*lock)->is_locknull = !resource->exists;
+
+            /* ### nobody uses the resolving right now! */
+            if (partial_ok) {
+                (*lock)->rectype = DAV_LOCKREC_INDIRECT_PARTIAL;
+            }
+            else {
+                (*lock)->rectype = DAV_LOCKREC_INDIRECT;
+                if ((err = dav_fs_resolve(lockdb, ip, &dp,
+                                          NULL, NULL)) != NULL) {
+                    /* ### push a higher-level desc? */
+                    return err;
+                }
+                (*lock)->scope = dp->f.scope;
+                (*lock)->type = dp->f.type;
+                (*lock)->depth = dp->f.depth;
+                (*lock)->timeout = dp->f.timeout;
+                (*lock)->owner = dp->owner;
+                (*lock)->auth_user = dp->auth_user;
+            }
+            return NULL;
+        }
+    }
+
+    return NULL;
+}
+
+static dav_error * dav_fs_has_locks(dav_lockdb *lockdb,
+                                    const dav_resource *resource,
+                                    int *locks_present)
+{
+    dav_error *err;
+    apr_datum_t key;
+
+    *locks_present = 0;
+
+    if ((err = dav_fs_really_open_lockdb(lockdb)) != NULL) {
+        /* ### insert a higher-level error description */
+        return err;
+    }
+
+    /*
+    ** If we opened readonly and the db wasn't there, then there are no
+    ** locks for this resource. Just exit.
+    */
+    if (lockdb->info->db == NULL)
+        return NULL;
+
+    key = dav_fs_build_key(lockdb->info->pool, resource);
+
+    *locks_present = dav_dbm_exists(lockdb->info->db, key);
+
+    return NULL;
+}
+
+static dav_error * dav_fs_append_locks(dav_lockdb *lockdb,
+                                       const dav_resource *resource,
+                                       int make_indirect,
+                                       const dav_lock *lock)
+{
+    apr_pool_t *p = lockdb->info->pool;
+    dav_error *err;
+    dav_lock_indirect *ip;
+    dav_lock_discovery *dp;
+    apr_datum_t key;
+
+    key = dav_fs_build_key(lockdb->info->pool, resource);
+    if ((err = dav_fs_load_lock_record(lockdb, key, 0, &dp, &ip)) != NULL) {
+        /* ### maybe add in a higher-level description */
+        return err;
+    }
+
+    /*
+    ** ### when we store the lock more directly, we need to update
+    ** ### lock->rectype and lock->is_locknull
+    */
+
+    if (make_indirect) {
+        for (; lock != NULL; lock = lock->next) {
+
+            /* ### this works for any <lock> rectype */
+            dav_lock_indirect *newi = apr_pcalloc(p, sizeof(*newi));
+
+            /* ### shut off the const warning for now */
+            newi->locktoken = (dav_locktoken *)lock->locktoken;
+            newi->timeout   = lock->timeout;
+            newi->key       = lock->info->key;
+            newi->next      = ip;
+            ip              = newi;
+        }
+    }
+    else {
+        for (; lock != NULL; lock = lock->next) {
+            /* create and link in the right kind of lock */
+
+            if (lock->rectype == DAV_LOCKREC_DIRECT) {
+                dav_lock_discovery *newd = apr_pcalloc(p, sizeof(*newd));
+
+                newd->f.scope = lock->scope;
+                newd->f.type = lock->type;
+                newd->f.depth = lock->depth;
+                newd->f.timeout = lock->timeout;
+                /* ### shut off the const warning for now */
+                newd->locktoken = (dav_locktoken *)lock->locktoken;
+                newd->owner = lock->owner;
+                newd->auth_user = lock->auth_user;
+                newd->next = dp;
+                dp = newd;
+            }
+            else {
+                /* DAV_LOCKREC_INDIRECT(_PARTIAL) */
+
+                dav_lock_indirect *newi = apr_pcalloc(p, sizeof(*newi));
+
+                /* ### shut off the const warning for now */
+                newi->locktoken = (dav_locktoken *)lock->locktoken;
+                newi->key       = lock->info->key;
+                newi->next      = ip;
+                ip              = newi;
+            }
+        }
+    }
+
+    if ((err = dav_fs_save_lock_record(lockdb, key, dp, ip)) != NULL) {
+        /* ### maybe add a higher-level description */
+        return err;
+    }
+
+    /* we have a special list for recording locknull resources */
+    /* ### ack! this can add two copies to the locknull list */
+    if (!resource->exists
+        && (err = dav_fs_add_locknull_state(lockdb, resource)) != NULL) {
+        /* ### maybe add a higher-level description */
+        return err;
+    }
+
+    return NULL;
+}
+
+static dav_error * dav_fs_remove_lock(dav_lockdb *lockdb,
+                                      const dav_resource *resource,
+                                      const dav_locktoken *locktoken)
+{
+    dav_error *err;
+    dav_buffer buf = { 0 };
+    dav_lock_discovery *dh = NULL;
+    dav_lock_indirect *ih = NULL;
+    apr_datum_t key;
+
+    key = dav_fs_build_key(lockdb->info->pool, resource);
+
+    if (locktoken != NULL) {
+        dav_lock_discovery *dp;
+        dav_lock_discovery *dprev = NULL;
+        dav_lock_indirect *ip;
+        dav_lock_indirect *iprev = NULL;
+
+        if ((err = dav_fs_load_lock_record(lockdb, key, DAV_CREATE_LIST,
+                                           &dh, &ih)) != NULL) {
+            /* ### maybe add a higher-level description */
+            return err;
+        }
+
+        for (dp = dh; dp != NULL; dp = dp->next) {
+            if (dav_compare_locktoken(locktoken, dp->locktoken) == 0) {
+                if (dprev)
+                    dprev->next = dp->next;
+                else
+                    dh = dh->next;
+            }
+            dprev = dp;
+        }
+
+        for (ip = ih; ip != NULL; ip = ip->next) {
+            if (dav_compare_locktoken(locktoken, ip->locktoken) == 0) {
+                if (iprev)
+                    iprev->next = ip->next;
+                else
+                    ih = ih->next;
+            }
+            iprev = ip;
+        }
+
+    }
+
+    /* save the modified locks, or remove all locks (dh=ih=NULL). */
+    if ((err = dav_fs_save_lock_record(lockdb, key, dh, ih)) != NULL) {
+        /* ### maybe add a higher-level description */
+        return err;
+    }
+
+    /*
+    ** If this resource is a locknull resource AND no more locks exist,
+    ** then remove the locknull member.
+    **
+    ** Note: remove_locknull_state() attempts to convert a locknull member
+    **       to a real member. In this case, all locks are gone, so the
+    **       locknull resource returns to the null state (ie. doesn't exist),
+    **       so there is no need to update the lockdb (and it won't find
+    **       any because a precondition is that none exist).
+    */
+    if (!resource->exists && dh == NULL && ih == NULL
+        && (err = dav_fs_remove_locknull_member(lockdb->info->pool,
+                                                dav_fs_pathname(resource),
+                                                &buf)) != NULL) {
+        /* ### maybe add a higher-level description */
+        return err;
+    }
+
+    return NULL;
+}
+
+static int dav_fs_do_refresh(dav_lock_discovery *dp,
+                             const dav_locktoken_list *ltl,
+                             time_t new_time)
+{
+    int dirty = 0;
+
+    for (; ltl != NULL; ltl = ltl->next) {
+        if (dav_compare_locktoken(dp->locktoken, ltl->locktoken) == 0)
+        {
+            dp->f.timeout = new_time;
+            dirty = 1;
+            break;
+        }
+    }
+
+    return dirty;
+}
+
+static dav_error * dav_fs_refresh_locks(dav_lockdb *lockdb,
+                                        const dav_resource *resource,
+                                        const dav_locktoken_list *ltl,
+                                        time_t new_time,
+                                        dav_lock **locks)
+{
+    dav_error *err;
+    apr_datum_t key;
+    dav_lock_discovery *dp;
+    dav_lock_discovery *dp_scan;
+    dav_lock_indirect *ip;
+    int dirty = 0;
+    dav_lock *newlock;
+
+    *locks = NULL;
+
+    key = dav_fs_build_key(lockdb->info->pool, resource);
+    if ((err = dav_fs_load_lock_record(lockdb, key, DAV_CREATE_LIST,
+                                       &dp, &ip)) != NULL) {
+        /* ### maybe add in a higher-level description */
+        return err;
+    }
+
+    /* ### we should be refreshing direct AND (resolved) indirect locks! */
+
+    /* refresh all of the direct locks on this resource */
+    for (dp_scan = dp; dp_scan != NULL; dp_scan = dp_scan->next) {
+        if (dav_fs_do_refresh(dp_scan, ltl, new_time)) {
+            /* the lock was refreshed. return the lock. */
+            newlock = dav_fs_alloc_lock(lockdb, key, dp_scan->locktoken);
+            newlock->is_locknull = !resource->exists;
+            newlock->scope = dp_scan->f.scope;
+            newlock->type = dp_scan->f.type;
+            newlock->depth = dp_scan->f.depth;
+            newlock->timeout = dp_scan->f.timeout;
+            newlock->owner = dp_scan->owner;
+            newlock->auth_user = dp_scan->auth_user;
+
+            newlock->next = *locks;
+            *locks = newlock;
+
+            dirty = 1;
+        }
+    }
+
+    /* if we refreshed any locks, then save them back. */
+    if (dirty
+        && (err = dav_fs_save_lock_record(lockdb, key, dp, ip)) != NULL) {
+        /* ### maybe add in a higher-level description */
+        return err;
+    }
+
+    /* for each indirect lock, find its direct lock and refresh it. */
+    for (; ip != NULL; ip = ip->next) {
+        dav_lock_discovery *ref_dp;
+        dav_lock_indirect *ref_ip;
+
+        if ((err = dav_fs_resolve(lockdb, ip, &dp_scan,
+                                  &ref_dp, &ref_ip)) != NULL) {
+            /* ### push a higher-level desc? */
+            return err;
+        }
+        if (dav_fs_do_refresh(dp_scan, ltl, new_time)) {
+            /* the lock was refreshed. return the lock. */
+            newlock = dav_fs_alloc_lock(lockdb, ip->key, dp_scan->locktoken);
+            newlock->is_locknull = !resource->exists;
+            newlock->scope = dp_scan->f.scope;
+            newlock->type = dp_scan->f.type;
+            newlock->depth = dp_scan->f.depth;
+            newlock->timeout = dp_scan->f.timeout;
+            newlock->owner = dp_scan->owner;
+            newlock->auth_user = dp_scan->auth_user;
+
+            newlock->next = *locks;
+            *locks = newlock;
+
+            /* save the (resolved) direct lock back */
+            if ((err = dav_fs_save_lock_record(lockdb, ip->key, ref_dp,
+                                               ref_ip)) != NULL) {
+                /* ### push a higher-level desc? */
+                return err;
+            }
+        }
+    }
+
+    return NULL;
+}
+
+
+const dav_hooks_locks dav_hooks_locks_fs =
+{
+    dav_fs_get_supportedlock,
+    dav_fs_parse_locktoken,
+    dav_fs_format_locktoken,
+    dav_fs_compare_locktoken,
+    dav_fs_open_lockdb,
+    dav_fs_close_lockdb,
+    dav_fs_remove_locknull_state,
+    dav_fs_create_lock,
+    dav_fs_get_locks,
+    dav_fs_find_lock,
+    dav_fs_has_locks,
+    dav_fs_append_locks,
+    dav_fs_remove_lock,
+    dav_fs_refresh_locks,
+    NULL, /* lookup_resource */
+
+    NULL /* ctx */
+};
diff --git a/modules/dav/fs/mod_dav_fs.c b/modules/dav/fs/mod_dav_fs.c
new file mode 100644
index 0000000..addfd7e
--- /dev/null
+++ b/modules/dav/fs/mod_dav_fs.c
@@ -0,0 +1,108 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "httpd.h"
+#include "http_config.h"
+#include "apr_strings.h"
+
+#include "mod_dav.h"
+#include "repos.h"
+
+/* per-server configuration */
+typedef struct {
+    const char *lockdb_path;
+
+} dav_fs_server_conf;
+
+extern module AP_MODULE_DECLARE_DATA dav_fs_module;
+
+const char *dav_get_lockdb_path(const request_rec *r)
+{
+    dav_fs_server_conf *conf;
+
+    conf = ap_get_module_config(r->server->module_config, &dav_fs_module);
+    return conf->lockdb_path;
+}
+
+static void *dav_fs_create_server_config(apr_pool_t *p, server_rec *s)
+{
+    return apr_pcalloc(p, sizeof(dav_fs_server_conf));
+}
+
+static void *dav_fs_merge_server_config(apr_pool_t *p,
+                                        void *base, void *overrides)
+{
+    dav_fs_server_conf *parent = base;
+    dav_fs_server_conf *child = overrides;
+    dav_fs_server_conf *newconf;
+
+    newconf = apr_pcalloc(p, sizeof(*newconf));
+
+    newconf->lockdb_path =
+        child->lockdb_path ? child->lockdb_path : parent->lockdb_path;
+
+    return newconf;
+}
+
+/*
+ * Command handler for the DAVLockDB directive, which is TAKE1
+ */
+static const char *dav_fs_cmd_davlockdb(cmd_parms *cmd, void *config,
+                                        const char *arg1)
+{
+    dav_fs_server_conf *conf;
+    conf = ap_get_module_config(cmd->server->module_config,
+                                &dav_fs_module);
+    conf->lockdb_path = ap_server_root_relative(cmd->pool, arg1);
+
+    if (!conf->lockdb_path) {
+        return apr_pstrcat(cmd->pool, "Invalid DAVLockDB path ",
+                           arg1, NULL);
+    }
+
+    return NULL;
+}
+
+static const command_rec dav_fs_cmds[] =
+{
+    /* per server */
+    AP_INIT_TAKE1("DAVLockDB", dav_fs_cmd_davlockdb, NULL, RSRC_CONF,
+                  "specify a lock database"),
+
+    { NULL }
+};
+
+static void register_hooks(apr_pool_t *p)
+{
+    dav_hook_gather_propsets(dav_fs_gather_propsets, NULL, NULL,
+                             APR_HOOK_MIDDLE);
+    dav_hook_find_liveprop(dav_fs_find_liveprop, NULL, NULL, APR_HOOK_MIDDLE);
+    dav_hook_insert_all_liveprops(dav_fs_insert_all_liveprops, NULL, NULL,
+                                  APR_HOOK_MIDDLE);
+
+    dav_fs_register(p);
+}
+
+AP_DECLARE_MODULE(dav_fs) =
+{
+    STANDARD20_MODULE_STUFF,
+    NULL,                        /* dir config creater */
+    NULL,                        /* dir merger --- default is to override */
+    dav_fs_create_server_config, /* server config */
+    dav_fs_merge_server_config,  /* merge server config */
+    dav_fs_cmds,                 /* command table */
+    register_hooks,              /* register hooks */
+};
diff --git a/modules/dav/fs/mod_dav_fs.dep b/modules/dav/fs/mod_dav_fs.dep
new file mode 100644
index 0000000..0d67f04
--- /dev/null
+++ b/modules/dav/fs/mod_dav_fs.dep
@@ -0,0 +1,203 @@
+# Microsoft Developer Studio Generated Dependency File, included by mod_dav_fs.mak
+
+.\dbm.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\http_config.h"\
+	"..\..\..\include\http_log.h"\
+	"..\..\..\include\http_main.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\mod_dav.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_cfgtree.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\repos.h"\
+	
+
+.\lock.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\http_config.h"\
+	"..\..\..\include\http_log.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\mod_dav.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_cfgtree.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_uuid.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\repos.h"\
+	
+
+.\mod_dav_fs.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\http_config.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\mod_dav.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_cfgtree.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\repos.h"\
+	
+
+.\repos.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\http_config.h"\
+	"..\..\..\include\http_log.h"\
+	"..\..\..\include\http_protocol.h"\
+	"..\..\..\include\http_request.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\mod_dav.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_cfgtree.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_dso.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_global_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_portable.h"\
+	"..\..\..\srclib\apr\include\apr_proc_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_shm.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\repos.h"\
+	
+
+..\..\..\build\win32\httpd.rc : \
+	"..\..\..\include\ap_release.h"\
+	
diff --git a/modules/dav/fs/mod_dav_fs.dsp b/modules/dav/fs/mod_dav_fs.dsp
new file mode 100644
index 0000000..fbfc1e4
--- /dev/null
+++ b/modules/dav/fs/mod_dav_fs.dsp
@@ -0,0 +1,135 @@
+# Microsoft Developer Studio Project File - Name="mod_dav_fs" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=mod_dav_fs - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "mod_dav_fs.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "mod_dav_fs.mak" CFG="mod_dav_fs - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "mod_dav_fs - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "mod_dav_fs - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "mod_dav_fs - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FD /c
+# ADD CPP /nologo /MD /W3 /O2 /Oy- /Zi /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /Fd"Release\mod_dav_fs_src" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /fo"Release/mod_dav_fs.res" /i "../../../include" /i "../../../srclib/apr/include" /d "NDEBUG" /d BIN_NAME="mod_dav_fs.so" /d LONG_NAME="dav_fs_module for Apache"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /out:".\Release\mod_dav_fs.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_fs.so
+# ADD LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Release\mod_dav_fs.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_fs.so /opt:ref
+# Begin Special Build Tool
+TargetPath=.\Release\mod_dav_fs.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+PostBuild_Cmds=if exist $(TargetPath).manifest mt.exe -manifest $(TargetPath).manifest -outputresource:$(TargetPath);2
+# End Special Build Tool
+
+!ELSEIF  "$(CFG)" == "mod_dav_fs - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MDd /W3 /EHsc /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FD /c
+# ADD CPP /nologo /MDd /W3 /EHsc /Zi /Od /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /Fd"Debug\mod_dav_fs_src" /FD /c
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /fo"Debug/mod_dav_fs.res" /i "../../../include" /i "../../../srclib/apr/include" /d "_DEBUG" /d BIN_NAME="mod_dav_fs.so" /d LONG_NAME="dav_fs_module for Apache"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Debug\mod_dav_fs.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_fs.so
+# ADD LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Debug\mod_dav_fs.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_fs.so
+# Begin Special Build Tool
+TargetPath=.\Debug\mod_dav_fs.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+PostBuild_Cmds=if exist $(TargetPath).manifest mt.exe -manifest $(TargetPath).manifest -outputresource:$(TargetPath);2
+# End Special Build Tool
+
+!ENDIF 
+
+# Begin Target
+
+# Name "mod_dav_fs - Win32 Release"
+# Name "mod_dav_fs - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\dbm.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\lock.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\mod_dav_fs.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\repos.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\repos.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\build\win32\httpd.rc
+# End Source File
+# End Target
+# End Project
diff --git a/modules/dav/fs/mod_dav_fs.mak b/modules/dav/fs/mod_dav_fs.mak
new file mode 100644
index 0000000..5baff67
--- /dev/null
+++ b/modules/dav/fs/mod_dav_fs.mak
@@ -0,0 +1,407 @@
+# Microsoft Developer Studio Generated NMAKE File, Based on mod_dav_fs.dsp
+!IF "$(CFG)" == ""
+CFG=mod_dav_fs - Win32 Release
+!MESSAGE No configuration specified. Defaulting to mod_dav_fs - Win32 Release.
+!ENDIF 
+
+!IF "$(CFG)" != "mod_dav_fs - Win32 Release" && "$(CFG)" != "mod_dav_fs - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "mod_dav_fs.mak" CFG="mod_dav_fs - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "mod_dav_fs - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "mod_dav_fs - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+
+!IF  "$(CFG)" == "mod_dav_fs - Win32 Release"
+
+OUTDIR=.\Release
+INTDIR=.\Release
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+# Begin Custom Macros
+OutDir=.\Release
+# End Custom Macros
+
+!IF "$(RECURSE)" == "0" 
+
+ALL : "$(OUTDIR)\mod_dav_fs.so" "$(DS_POSTBUILD_DEP)"
+
+!ELSE 
+
+ALL : "mod_dav - Win32 Release" "libhttpd - Win32 Release" "libaprutil - Win32 Release" "libapr - Win32 Release" "$(OUTDIR)\mod_dav_fs.so" "$(DS_POSTBUILD_DEP)"
+
+!ENDIF 
+
+!IF "$(RECURSE)" == "1" 
+CLEAN :"libapr - Win32 ReleaseCLEAN" "libaprutil - Win32 ReleaseCLEAN" "libhttpd - Win32 ReleaseCLEAN" "mod_dav - Win32 ReleaseCLEAN" 
+!ELSE 
+CLEAN :
+!ENDIF 
+	-@erase "$(INTDIR)\dbm.obj"
+	-@erase "$(INTDIR)\lock.obj"
+	-@erase "$(INTDIR)\mod_dav_fs.obj"
+	-@erase "$(INTDIR)\mod_dav_fs.res"
+	-@erase "$(INTDIR)\mod_dav_fs_src.idb"
+	-@erase "$(INTDIR)\mod_dav_fs_src.pdb"
+	-@erase "$(INTDIR)\repos.obj"
+	-@erase "$(OUTDIR)\mod_dav_fs.exp"
+	-@erase "$(OUTDIR)\mod_dav_fs.lib"
+	-@erase "$(OUTDIR)\mod_dav_fs.pdb"
+	-@erase "$(OUTDIR)\mod_dav_fs.so"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+CPP_PROJ=/nologo /MD /W3 /Zi /O2 /Oy- /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\mod_dav_fs_src" /FD /c 
+
+.c{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.c{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+MTL=midl.exe
+MTL_PROJ=/nologo /D "NDEBUG" /mktyplib203 /win32 
+RSC=rc.exe
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)\mod_dav_fs.res" /i "../../../include" /i "../../../srclib/apr/include" /d "NDEBUG" /d BIN_NAME="mod_dav_fs.so" /d LONG_NAME="dav_fs_module for Apache" 
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\mod_dav_fs.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+LINK32_FLAGS=kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /pdb:"$(OUTDIR)\mod_dav_fs.pdb" /debug /out:"$(OUTDIR)\mod_dav_fs.so" /implib:"$(OUTDIR)\mod_dav_fs.lib" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_fs.so /opt:ref 
+LINK32_OBJS= \
+	"$(INTDIR)\dbm.obj" \
+	"$(INTDIR)\lock.obj" \
+	"$(INTDIR)\mod_dav_fs.obj" \
+	"$(INTDIR)\repos.obj" \
+	"$(INTDIR)\mod_dav_fs.res" \
+	"..\..\..\srclib\apr\Release\libapr-1.lib" \
+	"..\..\..\srclib\apr-util\Release\libaprutil-1.lib" \
+	"..\..\..\Release\libhttpd.lib" \
+	"..\main\Release\mod_dav.lib"
+
+"$(OUTDIR)\mod_dav_fs.so" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+TargetPath=.\Release\mod_dav_fs.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+
+# Begin Custom Macros
+OutDir=.\Release
+# End Custom Macros
+
+"$(DS_POSTBUILD_DEP)" : "$(OUTDIR)\mod_dav_fs.so"
+   if exist .\Release\mod_dav_fs.so.manifest mt.exe -manifest .\Release\mod_dav_fs.so.manifest -outputresource:.\Release\mod_dav_fs.so;2
+	echo Helper for Post-build step > "$(DS_POSTBUILD_DEP)"
+
+!ELSEIF  "$(CFG)" == "mod_dav_fs - Win32 Debug"
+
+OUTDIR=.\Debug
+INTDIR=.\Debug
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+# Begin Custom Macros
+OutDir=.\Debug
+# End Custom Macros
+
+!IF "$(RECURSE)" == "0" 
+
+ALL : "$(OUTDIR)\mod_dav_fs.so" "$(DS_POSTBUILD_DEP)"
+
+!ELSE 
+
+ALL : "mod_dav - Win32 Debug" "libhttpd - Win32 Debug" "libaprutil - Win32 Debug" "libapr - Win32 Debug" "$(OUTDIR)\mod_dav_fs.so" "$(DS_POSTBUILD_DEP)"
+
+!ENDIF 
+
+!IF "$(RECURSE)" == "1" 
+CLEAN :"libapr - Win32 DebugCLEAN" "libaprutil - Win32 DebugCLEAN" "libhttpd - Win32 DebugCLEAN" "mod_dav - Win32 DebugCLEAN" 
+!ELSE 
+CLEAN :
+!ENDIF 
+	-@erase "$(INTDIR)\dbm.obj"
+	-@erase "$(INTDIR)\lock.obj"
+	-@erase "$(INTDIR)\mod_dav_fs.obj"
+	-@erase "$(INTDIR)\mod_dav_fs.res"
+	-@erase "$(INTDIR)\mod_dav_fs_src.idb"
+	-@erase "$(INTDIR)\mod_dav_fs_src.pdb"
+	-@erase "$(INTDIR)\repos.obj"
+	-@erase "$(OUTDIR)\mod_dav_fs.exp"
+	-@erase "$(OUTDIR)\mod_dav_fs.lib"
+	-@erase "$(OUTDIR)\mod_dav_fs.pdb"
+	-@erase "$(OUTDIR)\mod_dav_fs.so"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+CPP_PROJ=/nologo /MDd /W3 /Zi /Od /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\mod_dav_fs_src" /FD /EHsc /c 
+
+.c{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.c{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+MTL=midl.exe
+MTL_PROJ=/nologo /D "_DEBUG" /mktyplib203 /win32 
+RSC=rc.exe
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)\mod_dav_fs.res" /i "../../../include" /i "../../../srclib/apr/include" /d "_DEBUG" /d BIN_NAME="mod_dav_fs.so" /d LONG_NAME="dav_fs_module for Apache" 
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\mod_dav_fs.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+LINK32_FLAGS=kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /pdb:"$(OUTDIR)\mod_dav_fs.pdb" /debug /out:"$(OUTDIR)\mod_dav_fs.so" /implib:"$(OUTDIR)\mod_dav_fs.lib" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_fs.so 
+LINK32_OBJS= \
+	"$(INTDIR)\dbm.obj" \
+	"$(INTDIR)\lock.obj" \
+	"$(INTDIR)\mod_dav_fs.obj" \
+	"$(INTDIR)\repos.obj" \
+	"$(INTDIR)\mod_dav_fs.res" \
+	"..\..\..\srclib\apr\Debug\libapr-1.lib" \
+	"..\..\..\srclib\apr-util\Debug\libaprutil-1.lib" \
+	"..\..\..\Debug\libhttpd.lib" \
+	"..\main\Debug\mod_dav.lib"
+
+"$(OUTDIR)\mod_dav_fs.so" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+TargetPath=.\Debug\mod_dav_fs.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+
+# Begin Custom Macros
+OutDir=.\Debug
+# End Custom Macros
+
+"$(DS_POSTBUILD_DEP)" : "$(OUTDIR)\mod_dav_fs.so"
+   if exist .\Debug\mod_dav_fs.so.manifest mt.exe -manifest .\Debug\mod_dav_fs.so.manifest -outputresource:.\Debug\mod_dav_fs.so;2
+	echo Helper for Post-build step > "$(DS_POSTBUILD_DEP)"
+
+!ENDIF 
+
+
+!IF "$(NO_EXTERNAL_DEPS)" != "1"
+!IF EXISTS("mod_dav_fs.dep")
+!INCLUDE "mod_dav_fs.dep"
+!ELSE 
+!MESSAGE Warning: cannot find "mod_dav_fs.dep"
+!ENDIF 
+!ENDIF 
+
+
+!IF "$(CFG)" == "mod_dav_fs - Win32 Release" || "$(CFG)" == "mod_dav_fs - Win32 Debug"
+SOURCE=.\dbm.c
+
+"$(INTDIR)\dbm.obj" : $(SOURCE) "$(INTDIR)"
+
+
+SOURCE=.\lock.c
+
+"$(INTDIR)\lock.obj" : $(SOURCE) "$(INTDIR)"
+
+
+SOURCE=.\mod_dav_fs.c
+
+"$(INTDIR)\mod_dav_fs.obj" : $(SOURCE) "$(INTDIR)"
+
+
+SOURCE=.\repos.c
+
+"$(INTDIR)\repos.obj" : $(SOURCE) "$(INTDIR)"
+
+
+!IF  "$(CFG)" == "mod_dav_fs - Win32 Release"
+
+"libapr - Win32 Release" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Release" 
+   cd "..\..\modules\dav\fs"
+
+"libapr - Win32 ReleaseCLEAN" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Release" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\fs"
+
+!ELSEIF  "$(CFG)" == "mod_dav_fs - Win32 Debug"
+
+"libapr - Win32 Debug" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Debug" 
+   cd "..\..\modules\dav\fs"
+
+"libapr - Win32 DebugCLEAN" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Debug" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\fs"
+
+!ENDIF 
+
+!IF  "$(CFG)" == "mod_dav_fs - Win32 Release"
+
+"libaprutil - Win32 Release" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Release" 
+   cd "..\..\modules\dav\fs"
+
+"libaprutil - Win32 ReleaseCLEAN" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Release" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\fs"
+
+!ELSEIF  "$(CFG)" == "mod_dav_fs - Win32 Debug"
+
+"libaprutil - Win32 Debug" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Debug" 
+   cd "..\..\modules\dav\fs"
+
+"libaprutil - Win32 DebugCLEAN" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Debug" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\fs"
+
+!ENDIF 
+
+!IF  "$(CFG)" == "mod_dav_fs - Win32 Release"
+
+"libhttpd - Win32 Release" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Release" 
+   cd ".\modules\dav\fs"
+
+"libhttpd - Win32 ReleaseCLEAN" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Release" RECURSE=1 CLEAN 
+   cd ".\modules\dav\fs"
+
+!ELSEIF  "$(CFG)" == "mod_dav_fs - Win32 Debug"
+
+"libhttpd - Win32 Debug" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Debug" 
+   cd ".\modules\dav\fs"
+
+"libhttpd - Win32 DebugCLEAN" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Debug" RECURSE=1 CLEAN 
+   cd ".\modules\dav\fs"
+
+!ENDIF 
+
+!IF  "$(CFG)" == "mod_dav_fs - Win32 Release"
+
+"mod_dav - Win32 Release" : 
+   cd ".\..\main"
+   $(MAKE) /$(MAKEFLAGS) /F ".\mod_dav.mak" CFG="mod_dav - Win32 Release" 
+   cd "..\fs"
+
+"mod_dav - Win32 ReleaseCLEAN" : 
+   cd ".\..\main"
+   $(MAKE) /$(MAKEFLAGS) /F ".\mod_dav.mak" CFG="mod_dav - Win32 Release" RECURSE=1 CLEAN 
+   cd "..\fs"
+
+!ELSEIF  "$(CFG)" == "mod_dav_fs - Win32 Debug"
+
+"mod_dav - Win32 Debug" : 
+   cd ".\..\main"
+   $(MAKE) /$(MAKEFLAGS) /F ".\mod_dav.mak" CFG="mod_dav - Win32 Debug" 
+   cd "..\fs"
+
+"mod_dav - Win32 DebugCLEAN" : 
+   cd ".\..\main"
+   $(MAKE) /$(MAKEFLAGS) /F ".\mod_dav.mak" CFG="mod_dav - Win32 Debug" RECURSE=1 CLEAN 
+   cd "..\fs"
+
+!ENDIF 
+
+SOURCE=..\..\..\build\win32\httpd.rc
+
+!IF  "$(CFG)" == "mod_dav_fs - Win32 Release"
+
+
+"$(INTDIR)\mod_dav_fs.res" : $(SOURCE) "$(INTDIR)"
+	$(RSC) /l 0x409 /fo"$(INTDIR)\mod_dav_fs.res" /i "../../../include" /i "../../../srclib/apr/include" /i "../../../build\win32" /d "NDEBUG" /d BIN_NAME="mod_dav_fs.so" /d LONG_NAME="dav_fs_module for Apache" $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mod_dav_fs - Win32 Debug"
+
+
+"$(INTDIR)\mod_dav_fs.res" : $(SOURCE) "$(INTDIR)"
+	$(RSC) /l 0x409 /fo"$(INTDIR)\mod_dav_fs.res" /i "../../../include" /i "../../../srclib/apr/include" /i "../../../build\win32" /d "_DEBUG" /d BIN_NAME="mod_dav_fs.so" /d LONG_NAME="dav_fs_module for Apache" $(SOURCE)
+
+
+!ENDIF 
+
+
+!ENDIF 
+
diff --git a/modules/dav/fs/repos.c b/modules/dav/fs/repos.c
new file mode 100644
index 0000000..6a5ff76
--- /dev/null
+++ b/modules/dav/fs/repos.c
@@ -0,0 +1,2254 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+** DAV filesystem-based repository provider
+*/
+
+#include "apr.h"
+#include "apr_file_io.h"
+#include "apr_strings.h"
+#include "apr_buckets.h"
+
+#if APR_HAVE_UNISTD_H
+#include <unistd.h>             /* for getpid() */
+#endif
+
+#include "httpd.h"
+#include "http_log.h"
+#include "http_protocol.h"      /* for ap_set_* (in dav_fs_set_headers) */
+#include "http_request.h"       /* for ap_update_mtime() */
+
+#include "mod_dav.h"
+#include "repos.h"
+
+
+/* to assist in debugging mod_dav's GET handling */
+#define DEBUG_GET_HANDLER       0
+
+#define DAV_FS_COPY_BLOCKSIZE   16384   /* copy 16k at a time */
+
+/* context needed to identify a resource */
+struct dav_resource_private {
+    apr_pool_t *pool;        /* memory storage pool associated with request */
+    const char *pathname;   /* full pathname to resource */
+    apr_finfo_t finfo;       /* filesystem info */
+    request_rec *r;
+};
+
+/* private context for doing a filesystem walk */
+typedef struct {
+    /* the input walk parameters */
+    const dav_walk_params *params;
+
+    /* reused as we walk */
+    dav_walk_resource wres;
+
+    dav_resource res1;
+    dav_resource_private info1;
+    dav_buffer path1;
+    dav_buffer uri_buf;
+
+    /* MOVE/COPY need a secondary path */
+    dav_resource res2;
+    dav_resource_private info2;
+    dav_buffer path2;
+
+    dav_buffer locknull_buf;
+
+} dav_fs_walker_context;
+
+typedef struct {
+    int is_move;                /* is this a MOVE? */
+    dav_buffer work_buf;        /* handy buffer for copymove_file() */
+
+    /* CALLBACK: this is a secondary resource managed specially for us */
+    const dav_resource *res_dst;
+
+    /* copied from dav_walk_params (they are invariant across the walk) */
+    const dav_resource *root;
+    apr_pool_t *pool;
+
+} dav_fs_copymove_walk_ctx;
+
+/* an internal WALKTYPE to walk hidden files (the .DAV directory) */
+#define DAV_WALKTYPE_HIDDEN     0x4000
+
+/* an internal WALKTYPE to call collections (again) after their contents */
+#define DAV_WALKTYPE_POSTFIX    0x8000
+
+#define DAV_CALLTYPE_POSTFIX    1000    /* a private call type */
+
+
+/* pull this in from the other source file */
+extern const dav_hooks_locks dav_hooks_locks_fs;
+
+/* forward-declare the hook structures */
+static const dav_hooks_repository dav_hooks_repository_fs;
+static const dav_hooks_liveprop dav_hooks_liveprop_fs;
+
+/*
+** The namespace URIs that we use. This list and the enumeration must
+** stay in sync.
+*/
+static const char * const dav_fs_namespace_uris[] =
+{
+    "DAV:",
+    "http://apache.org/dav/props/",
+
+    NULL        /* sentinel */
+};
+enum {
+    DAV_FS_URI_DAV,            /* the DAV: namespace URI */
+    DAV_FS_URI_MYPROPS         /* the namespace URI for our custom props */
+};
+
+/*
+** Does this platform support an executable flag?
+**
+** ### need a way to portably abstract this query
+**
+** DAV_FINFO_MASK gives the appropriate mask to use for the stat call
+** used to get file attributes.
+*/
+#ifndef WIN32
+#define DAV_FS_HAS_EXECUTABLE
+#define DAV_FINFO_MASK (APR_FINFO_LINK | APR_FINFO_TYPE | APR_FINFO_INODE | \
+                        APR_FINFO_SIZE | APR_FINFO_CTIME | APR_FINFO_MTIME | \
+                        APR_FINFO_PROT)
+#else
+/* as above, but without APR_FINFO_PROT */
+#define DAV_FINFO_MASK (APR_FINFO_LINK | APR_FINFO_TYPE | APR_FINFO_INODE | \
+                        APR_FINFO_SIZE | APR_FINFO_CTIME | APR_FINFO_MTIME)
+#endif
+
+/*
+** The single property that we define (in the DAV_FS_URI_MYPROPS namespace)
+*/
+#define DAV_PROPID_FS_executable        1
+
+/*
+ * prefix for temporary files
+ */
+#define DAV_FS_TMP_PREFIX ".davfs.tmp"
+
+static const dav_liveprop_spec dav_fs_props[] =
+{
+    /* standard DAV properties */
+    {
+        DAV_FS_URI_DAV,
+        "creationdate",
+        DAV_PROPID_creationdate,
+        0
+    },
+    {
+        DAV_FS_URI_DAV,
+        "getcontentlength",
+        DAV_PROPID_getcontentlength,
+        0
+    },
+    {
+        DAV_FS_URI_DAV,
+        "getetag",
+        DAV_PROPID_getetag,
+        0
+    },
+    {
+        DAV_FS_URI_DAV,
+        "getlastmodified",
+        DAV_PROPID_getlastmodified,
+        0
+    },
+
+    /* our custom properties */
+    {
+        DAV_FS_URI_MYPROPS,
+        "executable",
+        DAV_PROPID_FS_executable,
+        0       /* handled special in dav_fs_is_writable */
+    },
+
+    { 0 }        /* sentinel */
+};
+
+static const dav_liveprop_group dav_fs_liveprop_group =
+{
+    dav_fs_props,
+    dav_fs_namespace_uris,
+    &dav_hooks_liveprop_fs
+};
+
+
+/* define the dav_stream structure for our use */
+struct dav_stream {
+    apr_pool_t *p;
+    apr_file_t *f;
+    const char *pathname;       /* we may need to remove it at close time */
+    char *temppath;
+    int unlink_on_error;
+};
+
+/* returns an appropriate HTTP status code given an APR status code for a
+ * failed I/O operation.  ### use something besides 500? */
+#define MAP_IO2HTTP(e) (APR_STATUS_IS_ENOSPC(e) ? HTTP_INSUFFICIENT_STORAGE : \
+                        APR_STATUS_IS_ENOENT(e) ? HTTP_CONFLICT : \
+                        HTTP_INTERNAL_SERVER_ERROR)
+
+/* forward declaration for internal treewalkers */
+static dav_error * dav_fs_walk(const dav_walk_params *params, int depth,
+                               dav_response **response);
+static dav_error * dav_fs_internal_walk(const dav_walk_params *params,
+                                        int depth, int is_move,
+                                        const dav_resource *root_dst,
+                                        dav_response **response);
+
+/* --------------------------------------------------------------------
+**
+** PRIVATE REPOSITORY FUNCTIONS
+*/
+static request_rec *dav_fs_get_request_rec(const dav_resource *resource)
+{
+    return resource->info->r;
+}
+
+apr_pool_t *dav_fs_pool(const dav_resource *resource)
+{
+    return resource->info->pool;
+}
+
+const char *dav_fs_pathname(const dav_resource *resource)
+{
+    return resource->info->pathname;
+}
+
+dav_error * dav_fs_dir_file_name(
+    const dav_resource *resource,
+    const char **dirpath_p,
+    const char **fname_p)
+{
+    dav_resource_private *ctx = resource->info;
+
+    if (resource->collection) {
+        *dirpath_p = ctx->pathname;
+        if (fname_p != NULL)
+            *fname_p = NULL;
+    }
+    else {
+        const char *testpath, *rootpath;
+        char *dirpath = ap_make_dirstr_parent(ctx->pool, ctx->pathname);
+        apr_size_t dirlen = strlen(dirpath);
+        apr_status_t rv = APR_SUCCESS;
+
+        testpath = dirpath;
+        if (dirlen > 0) {
+            rv = apr_filepath_root(&rootpath, &testpath, 0, ctx->pool);
+        }
+
+        /* remove trailing slash from dirpath, unless it's a root path
+         */
+        if ((rv == APR_SUCCESS && testpath && *testpath)
+            || rv == APR_ERELATIVE) {
+            if (dirpath[dirlen - 1] == '/') {
+                dirpath[dirlen - 1] = '\0';
+            }
+        }
+
+        /* ###: Looks like a response could be appropriate
+         *
+         * APR_SUCCESS     here tells us the dir is a root
+         * APR_ERELATIVE   told us we had no root (ok)
+         * APR_EINCOMPLETE an incomplete testpath told us
+         *                 there was no -file- name here!
+         * APR_EBADPATH    or other errors tell us this file
+         *                 path is undecipherable
+         */
+
+        if (rv == APR_SUCCESS || rv == APR_ERELATIVE) {
+            *dirpath_p = dirpath;
+            if (fname_p != NULL)
+                *fname_p = ctx->pathname + dirlen;
+        }
+        else {
+            return dav_new_error(ctx->pool, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
+                                 "An incomplete/bad path was found in "
+                                 "dav_fs_dir_file_name.");
+        }
+    }
+
+    return NULL;
+}
+
+/* Note: picked up from ap_gm_timestr_822() */
+/* NOTE: buf must be at least DAV_TIMEBUF_SIZE chars in size */
+static void dav_format_time(int style, apr_time_t sec, char *buf, apr_size_t buflen)
+{
+    apr_time_exp_t tms;
+
+    /* ### what to do if fails? */
+    (void) apr_time_exp_gmt(&tms, sec);
+
+    if (style == DAV_STYLE_ISO8601) {
+        /* ### should we use "-00:00" instead of "Z" ?? */
+
+        /* 20 chars plus null term */
+        apr_snprintf(buf, buflen, "%.4d-%.2d-%.2dT%.2d:%.2d:%.2dZ",
+                     tms.tm_year + 1900, tms.tm_mon + 1, tms.tm_mday,
+                     tms.tm_hour, tms.tm_min, tms.tm_sec);
+        return;
+    }
+
+    /* RFC 822 date format; as strftime '%a, %d %b %Y %T GMT' */
+
+    /* 29 chars plus null term */
+    apr_snprintf(buf, buflen, "%s, %.2d %s %d %.2d:%.2d:%.2d GMT",
+                 apr_day_snames[tms.tm_wday],
+                 tms.tm_mday, apr_month_snames[tms.tm_mon],
+                 tms.tm_year + 1900,
+                 tms.tm_hour, tms.tm_min, tms.tm_sec);
+}
+
+/* Copy or move src to dst; src_finfo is used to propagate permissions
+ * bits across if non-NULL; dst_finfo must be non-NULL iff dst already
+ * exists. */
+static dav_error * dav_fs_copymove_file(
+    int is_move,
+    apr_pool_t * p,
+    const char *src,
+    const char *dst,
+    const apr_finfo_t *src_finfo,
+    const apr_finfo_t *dst_finfo,
+    dav_buffer *pbuf)
+{
+    dav_buffer work_buf = { 0 };
+    apr_file_t *inf = NULL;
+    apr_file_t *outf = NULL;
+    apr_status_t status;
+    apr_fileperms_t perms;
+
+    if (pbuf == NULL)
+        pbuf = &work_buf;
+
+    /* Determine permissions to use for destination */
+    if (src_finfo && src_finfo->valid & APR_FINFO_PROT
+        && src_finfo->protection & APR_UEXECUTE) {
+        perms = src_finfo->protection;
+
+        if (dst_finfo != NULL) {
+            /* chmod it if it already exist */
+            if ((status = apr_file_perms_set(dst, perms)) != APR_SUCCESS) {
+                return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, status,
+                                     "Could not set permissions on destination");
+            }
+        }
+    }
+    else {
+        perms = APR_OS_DEFAULT;
+    }
+
+    dav_set_bufsize(p, pbuf, DAV_FS_COPY_BLOCKSIZE);
+
+    if ((status = apr_file_open(&inf, src, APR_READ | APR_BINARY,
+                                APR_OS_DEFAULT, p)) != APR_SUCCESS) {
+        /* ### use something besides 500? */
+        return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, status,
+                             "Could not open file for reading");
+    }
+
+    /* ### do we need to deal with the umask? */
+    status = apr_file_open(&outf, dst, APR_WRITE | APR_CREATE | APR_TRUNCATE
+                           | APR_BINARY, perms, p);
+    if (status != APR_SUCCESS) {
+        apr_file_close(inf);
+
+        return dav_new_error(p, MAP_IO2HTTP(status), 0, status,
+                             "Could not open file for writing");
+    }
+
+    while (1) {
+        apr_size_t len = DAV_FS_COPY_BLOCKSIZE;
+
+        status = apr_file_read(inf, pbuf->buf, &len);
+        if (status != APR_SUCCESS && status != APR_EOF) {
+            apr_status_t lcl_status;
+
+            apr_file_close(inf);
+            apr_file_close(outf);
+
+            if ((lcl_status = apr_file_remove(dst, p)) != APR_SUCCESS) {
+                /* ### ACK! Inconsistent state... */
+
+                /* ### use something besides 500? */
+                return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,
+                                     lcl_status,
+                                     "Could not delete output after read "
+                                     "failure. Server is now in an "
+                                     "inconsistent state.");
+            }
+
+            /* ### use something besides 500? */
+            return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, status,
+                                 "Could not read input file");
+        }
+
+        if (status == APR_EOF)
+            break;
+
+        /* write any bytes that were read */
+        status = apr_file_write_full(outf, pbuf->buf, len, NULL);
+        if (status != APR_SUCCESS) {
+            apr_status_t lcl_status;
+
+            apr_file_close(inf);
+            apr_file_close(outf);
+
+            if ((lcl_status = apr_file_remove(dst, p)) != APR_SUCCESS) {
+                /* ### ACK! Inconsistent state... */
+
+                /* ### use something besides 500? */
+                return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,
+                                     lcl_status,
+                                     "Could not delete output after write "
+                                     "failure. Server is now in an "
+                                     "inconsistent state.");
+            }
+
+            return dav_new_error(p, MAP_IO2HTTP(status), 0, status,
+                                 "Could not write output file");
+        }
+    }
+
+    apr_file_close(inf);
+    apr_file_close(outf);
+
+    if (is_move && (status = apr_file_remove(src, p)) != APR_SUCCESS) {
+        dav_error *err;
+        apr_status_t lcl_status;
+
+        if (APR_STATUS_IS_ENOENT(status)) {
+            /*
+             * Something is wrong here but the result is what we wanted.
+             * We definitely should not remove the destination file.
+             */
+            err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, status,
+                                 apr_psprintf(p, "Could not remove source "
+                                              "file %s after move to %s. The "
+                                              "server may be in an "
+                                              "inconsistent state.", src, dst));
+            return err;
+        }
+        else if ((lcl_status = apr_file_remove(dst, p)) != APR_SUCCESS) {
+            /* ### ACK. this creates an inconsistency. do more!? */
+
+            /* ### use something besides 500? */
+            return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, lcl_status,
+                                 "Could not remove source or destination "
+                                 "file. Server is now in an inconsistent "
+                                 "state.");
+        }
+
+        /* ### use something besides 500? */
+        err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, status,
+                            "Could not remove source file after move. "
+                            "Destination was removed to ensure consistency.");
+        return err;
+    }
+
+    return NULL;
+}
+
+/* copy/move a file from within a state dir to another state dir */
+/* ### need more buffers to replace the pool argument */
+static dav_error * dav_fs_copymove_state(
+    int is_move,
+    apr_pool_t * p,
+    const char *src_dir, const char *src_file,
+    const char *dst_dir, const char *dst_file,
+    dav_buffer *pbuf)
+{
+    apr_finfo_t src_finfo;        /* finfo for source file */
+    apr_finfo_t dst_state_finfo;        /* finfo for STATE directory */
+    apr_status_t rv;
+    const char *src;
+    const char *dst;
+
+    /* build the propset pathname for the source file */
+    src = apr_pstrcat(p, src_dir, "/" DAV_FS_STATE_DIR "/", src_file, NULL);
+
+    /* the source file doesn't exist */
+    rv = apr_stat(&src_finfo, src, APR_FINFO_NORM, p);
+    if (rv != APR_SUCCESS && rv != APR_INCOMPLETE) {
+        return NULL;
+    }
+
+    /* build the pathname for the destination state dir */
+    dst = apr_pstrcat(p, dst_dir, "/" DAV_FS_STATE_DIR, NULL);
+
+    /* ### do we need to deal with the umask? */
+
+    /* ensure that it exists */
+    rv = apr_dir_make(dst, APR_OS_DEFAULT, p);
+    if (rv != APR_SUCCESS) {
+        if (!APR_STATUS_IS_EEXIST(rv)) {
+            /* ### use something besides 500? */
+            return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
+                                 "Could not create internal state directory");
+        }
+    }
+
+    /* get info about the state directory */
+    rv = apr_stat(&dst_state_finfo, dst, APR_FINFO_NORM, p);
+    if (rv != APR_SUCCESS && rv != APR_INCOMPLETE) {
+        /* Ack! Where'd it go? */
+        /* ### use something besides 500? */
+        return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
+                             "State directory disappeared");
+    }
+
+    /* The mkdir() may have failed because a *file* exists there already */
+    if (dst_state_finfo.filetype != APR_DIR) {
+        /* ### try to recover by deleting this file? (and mkdir again) */
+        /* ### use something besides 500? */
+        return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                             "State directory is actually a file");
+    }
+
+    /* append the target file to the state directory pathname */
+    dst = apr_pstrcat(p, dst, "/", dst_file, NULL);
+
+    /* copy/move the file now */
+    if (is_move) {
+        /* try simple rename first */
+        rv = apr_file_rename(src, dst, p);
+        if (APR_STATUS_IS_EXDEV(rv)) {
+            return dav_fs_copymove_file(is_move, p, src, dst, NULL, NULL, pbuf);
+        }
+        if (rv != APR_SUCCESS) {
+            /* ### use something besides 500? */
+            return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
+                                 "Could not move state file.");
+        }
+    }
+    else
+    {
+        /* gotta copy (and delete) */
+        return dav_fs_copymove_file(is_move, p, src, dst, NULL, NULL, pbuf);
+    }
+
+    return NULL;
+}
+
+static dav_error *dav_fs_copymoveset(int is_move, apr_pool_t *p,
+                                     const dav_resource *src,
+                                     const dav_resource *dst,
+                                     dav_buffer *pbuf)
+{
+    const char *src_dir;
+    const char *src_file;
+    const char *src_state1;
+    const char *src_state2;
+    const char *dst_dir;
+    const char *dst_file;
+    const char *dst_state1;
+    const char *dst_state2;
+    dav_error *err;
+
+    /* Get directory and filename for resources */
+    /* ### should test these result values... */
+    (void) dav_fs_dir_file_name(src, &src_dir, &src_file);
+    (void) dav_fs_dir_file_name(dst, &dst_dir, &dst_file);
+
+    /* Get the corresponding state files for each resource */
+    dav_dbm_get_statefiles(p, src_file, &src_state1, &src_state2);
+    dav_dbm_get_statefiles(p, dst_file, &dst_state1, &dst_state2);
+#if DAV_DEBUG
+    if ((src_state2 != NULL && dst_state2 == NULL) ||
+        (src_state2 == NULL && dst_state2 != NULL)) {
+        return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                             "DESIGN ERROR: dav_dbm_get_statefiles() "
+                             "returned inconsistent results.");
+    }
+#endif
+
+    err = dav_fs_copymove_state(is_move, p,
+                                src_dir, src_state1,
+                                dst_dir, dst_state1,
+                                pbuf);
+
+    if (err == NULL && src_state2 != NULL) {
+        err = dav_fs_copymove_state(is_move, p,
+                                    src_dir, src_state2,
+                                    dst_dir, dst_state2,
+                                    pbuf);
+
+        if (err != NULL) {
+            /* ### CRAP. inconsistency. */
+            /* ### should perform some cleanup at the target if we still
+               ### have the original files */
+
+            /* Change the error to reflect the bad server state. */
+            err->status = HTTP_INTERNAL_SERVER_ERROR;
+            err->desc =
+                "Could not fully copy/move the properties. "
+                "The server is now in an inconsistent state.";
+        }
+    }
+
+    return err;
+}
+
+static dav_error *dav_fs_deleteset(apr_pool_t *p, const dav_resource *resource)
+{
+    const char *dirpath;
+    const char *fname;
+    const char *state1;
+    const char *state2;
+    const char *pathname;
+    apr_status_t status;
+
+    /* Get directory, filename, and state-file names for the resource */
+    /* ### should test this result value... */
+    (void) dav_fs_dir_file_name(resource, &dirpath, &fname);
+    dav_dbm_get_statefiles(p, fname, &state1, &state2);
+
+    /* build the propset pathname for the file */
+    pathname = apr_pstrcat(p,
+                          dirpath,
+                          "/" DAV_FS_STATE_DIR "/",
+                          state1,
+                          NULL);
+
+    /* note: we may get ENOENT if the state dir is not present */
+    if ((status = apr_file_remove(pathname, p)) != APR_SUCCESS
+        && !APR_STATUS_IS_ENOENT(status)) {
+        return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, status,
+                             "Could not remove properties.");
+    }
+
+    if (state2 != NULL) {
+        /* build the propset pathname for the file */
+        pathname = apr_pstrcat(p,
+                              dirpath,
+                              "/" DAV_FS_STATE_DIR "/",
+                              state2,
+                              NULL);
+
+        if ((status = apr_file_remove(pathname, p)) != APR_SUCCESS
+            && !APR_STATUS_IS_ENOENT(status)) {
+            /* ### CRAP. only removed half. */
+            return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, status,
+                                 "Could not fully remove properties. "
+                                 "The server is now in an inconsistent "
+                                 "state.");
+        }
+    }
+
+    return NULL;
+}
+
+/* --------------------------------------------------------------------
+**
+** REPOSITORY HOOK FUNCTIONS
+*/
+
+static dav_error * dav_fs_get_resource(
+    request_rec *r,
+    const char *root_dir,
+    const char *label,
+    int use_checked_in,
+    dav_resource **result_resource)
+{
+    dav_resource_private *ctx;
+    dav_resource *resource;
+    char *s;
+    char *filename;
+    apr_size_t len;
+
+    /* ### optimize this into a single allocation! */
+
+    /* Create private resource context descriptor */
+    ctx = apr_pcalloc(r->pool, sizeof(*ctx));
+    ctx->finfo = r->finfo;
+    ctx->r = r;
+
+    /* ### this should go away */
+    ctx->pool = r->pool;
+
+    /* Preserve case on OSes which fold canonical filenames */
+#if 0
+    /* ### not available in Apache 2.0 yet */
+    filename = r->case_preserved_filename;
+#else
+    filename = r->filename;
+#endif
+
+    /*
+    ** If there is anything in the path_info, then this indicates that the
+    ** entire path was not used to specify the file/dir. We want to append
+    ** it onto the filename so that we get a "valid" pathname for null
+    ** resources.
+    */
+    s = apr_pstrcat(r->pool, filename, r->path_info, NULL);
+
+    /* make sure the pathname does not have a trailing "/" */
+    len = strlen(s);
+    if (len > 1 && s[len - 1] == '/') {
+        s[len - 1] = '\0';
+    }
+    ctx->pathname = s;
+
+    /* Create resource descriptor */
+    resource = apr_pcalloc(r->pool, sizeof(*resource));
+    resource->type = DAV_RESOURCE_TYPE_REGULAR;
+    resource->info = ctx;
+    resource->hooks = &dav_hooks_repository_fs;
+    resource->pool = r->pool;
+
+    /* make sure the URI does not have a trailing "/" */
+    len = strlen(r->uri);
+    if (len > 1 && r->uri[len - 1] == '/') {
+        s = apr_pstrmemdup(r->pool, r->uri, len-1);
+        resource->uri = s;
+    }
+    else {
+        resource->uri = r->uri;
+    }
+
+    if (r->finfo.filetype != APR_NOFILE) {
+        resource->exists = 1;
+        resource->collection = r->finfo.filetype == APR_DIR;
+
+        /* unused info in the URL will indicate a null resource */
+
+        if (r->path_info != NULL && *r->path_info != '\0') {
+            if (resource->collection) {
+                /* only a trailing "/" is allowed */
+                if (*r->path_info != '/' || r->path_info[1] != '\0') {
+
+                    /*
+                    ** This URL/filename represents a locknull resource or
+                    ** possibly a destination of a MOVE/COPY
+                    */
+                    resource->exists = 0;
+                    resource->collection = 0;
+                }
+            }
+            else
+            {
+                /*
+                ** The base of the path refers to a file -- nothing should
+                ** be in path_info. The resource is simply an error: it
+                ** can't be a null or a locknull resource.
+                */
+                return dav_new_error(r->pool, HTTP_BAD_REQUEST, 0, 0,
+                                     "The URL contains extraneous path "
+                                     "components. The resource could not "
+                                     "be identified.");
+            }
+
+            /* retain proper integrity across the structures */
+            if (!resource->exists) {
+                ctx->finfo.filetype = APR_NOFILE;
+            }
+        }
+    }
+
+    *result_resource = resource;
+    return NULL;
+}
+
+static dav_error * dav_fs_get_parent_resource(const dav_resource *resource,
+                                              dav_resource **result_parent)
+{
+    dav_resource_private *ctx = resource->info;
+    dav_resource_private *parent_ctx;
+    dav_resource *parent_resource;
+    apr_status_t rv;
+    char *dirpath;
+    const char *testroot;
+    const char *testpath;
+
+    /* If we're at the root of the URL space, then there is no parent. */
+    if (strcmp(resource->uri, "/") == 0) {
+        *result_parent = NULL;
+        return NULL;
+    }
+
+    /* If given resource is root, then there is no parent.
+     * Unless we can retrieve the filepath root, this is
+     * intendend to fail.  If we split the root and
+     * no path info remains, then we also fail.
+     */
+    testpath = ctx->pathname;
+    rv = apr_filepath_root(&testroot, &testpath, 0, ctx->pool);
+    if ((rv != APR_SUCCESS && rv != APR_ERELATIVE)
+        || !testpath || !*testpath) {
+        *result_parent = NULL;
+        return NULL;
+    }
+
+    /* ### optimize this into a single allocation! */
+
+    /* Create private resource context descriptor */
+    parent_ctx = apr_pcalloc(ctx->pool, sizeof(*parent_ctx));
+
+    /* ### this should go away */
+    parent_ctx->pool = ctx->pool;
+
+    dirpath = ap_make_dirstr_parent(ctx->pool, ctx->pathname);
+    if (strlen(dirpath) > 1 && dirpath[strlen(dirpath) - 1] == '/')
+        dirpath[strlen(dirpath) - 1] = '\0';
+    parent_ctx->pathname = dirpath;
+
+    parent_resource = apr_pcalloc(ctx->pool, sizeof(*parent_resource));
+    parent_resource->info = parent_ctx;
+    parent_resource->collection = 1;
+    parent_resource->hooks = &dav_hooks_repository_fs;
+    parent_resource->pool = resource->pool;
+
+    if (resource->uri != NULL) {
+        char *uri = ap_make_dirstr_parent(ctx->pool, resource->uri);
+        if (strlen(uri) > 1 && uri[strlen(uri) - 1] == '/')
+            uri[strlen(uri) - 1] = '\0';
+        parent_resource->uri = uri;
+    }
+
+    rv = apr_stat(&parent_ctx->finfo, parent_ctx->pathname,
+                  APR_FINFO_NORM, ctx->pool);
+    if (rv == APR_SUCCESS || rv == APR_INCOMPLETE) {
+        parent_resource->exists = 1;
+    }
+
+    *result_parent = parent_resource;
+    return NULL;
+}
+
+static int dav_fs_is_same_resource(
+    const dav_resource *res1,
+    const dav_resource *res2)
+{
+    dav_resource_private *ctx1 = res1->info;
+    dav_resource_private *ctx2 = res2->info;
+
+    if (res1->hooks != res2->hooks)
+        return 0;
+
+    if ((ctx1->finfo.filetype != APR_NOFILE) && (ctx2->finfo.filetype != APR_NOFILE)
+        && (ctx1->finfo.valid & ctx2->finfo.valid & APR_FINFO_INODE)) {
+        return ctx1->finfo.inode == ctx2->finfo.inode;
+    }
+    else {
+        return strcmp(ctx1->pathname, ctx2->pathname) == 0;
+    }
+}
+
+static int dav_fs_is_parent_resource(
+    const dav_resource *res1,
+    const dav_resource *res2)
+{
+    dav_resource_private *ctx1 = res1->info;
+    dav_resource_private *ctx2 = res2->info;
+    apr_size_t len1 = strlen(ctx1->pathname);
+    apr_size_t len2;
+
+    if (res1->hooks != res2->hooks)
+        return 0;
+
+    /* it is safe to use ctx2 now */
+    len2 = strlen(ctx2->pathname);
+
+    return (len2 > len1
+            && memcmp(ctx1->pathname, ctx2->pathname, len1) == 0
+            && ctx2->pathname[len1] == '/');
+}
+
+static apr_status_t tmpfile_cleanup(void *data)
+{
+    dav_stream *ds = data;
+    if (ds->temppath) {
+        apr_file_remove(ds->temppath, ds->p);
+    }
+    return APR_SUCCESS;
+}
+
+/* custom mktemp that creates the file with APR_OS_DEFAULT permissions */
+static apr_status_t dav_fs_mktemp(apr_file_t **fp, char *templ, apr_pool_t *p)
+{
+    apr_status_t rv;
+    int num = ((getpid() << 7) + (apr_uintptr_t)templ % (1 << 16) ) %
+               ( 1 << 23 ) ;
+    char *numstr = templ + strlen(templ) - 6;
+
+    ap_assert(numstr >= templ);
+
+    do {
+        num = (num + 1) % ( 1 << 23 );
+        apr_snprintf(numstr, 7, "%06x", num);
+        rv = apr_file_open(fp, templ,
+                           APR_WRITE | APR_CREATE | APR_BINARY | APR_EXCL,
+                           APR_OS_DEFAULT, p);
+    } while (APR_STATUS_IS_EEXIST(rv));
+
+    return rv;
+}
+
+static dav_error * dav_fs_open_stream(const dav_resource *resource,
+                                      dav_stream_mode mode,
+                                      dav_stream **stream)
+{
+    apr_pool_t *p = resource->info->pool;
+    dav_stream *ds = apr_pcalloc(p, sizeof(*ds));
+    apr_int32_t flags;
+    apr_status_t rv;
+
+    switch (mode) {
+    default:
+        flags = APR_READ | APR_BINARY;
+        break;
+
+    case DAV_MODE_WRITE_TRUNC:
+        flags = APR_WRITE | APR_CREATE | APR_TRUNCATE | APR_BINARY;
+        break;
+    case DAV_MODE_WRITE_SEEKABLE:
+        flags = APR_WRITE | APR_CREATE | APR_BINARY;
+        break;
+    }
+
+    ds->p = p;
+    ds->pathname = resource->info->pathname;
+    ds->temppath = NULL;
+    ds->unlink_on_error = 0;
+
+    if (mode == DAV_MODE_WRITE_TRUNC) {
+        ds->temppath = apr_pstrcat(p, ap_make_dirstr_parent(p, ds->pathname),
+                                   DAV_FS_TMP_PREFIX "XXXXXX", NULL);
+        rv = dav_fs_mktemp(&ds->f, ds->temppath, ds->p);
+        apr_pool_cleanup_register(p, ds, tmpfile_cleanup,
+                                  apr_pool_cleanup_null);
+    }
+    else if (mode == DAV_MODE_WRITE_SEEKABLE) {
+        rv = apr_file_open(&ds->f, ds->pathname, flags | APR_FOPEN_EXCL,
+                           APR_OS_DEFAULT, ds->p);
+        if (rv == APR_SUCCESS) {
+            /* we have created a new file */
+            ds->unlink_on_error = 1;
+        }
+        else if (APR_STATUS_IS_EEXIST(rv)) {
+            rv = apr_file_open(&ds->f, ds->pathname, flags, APR_OS_DEFAULT,
+                               ds->p);
+        }
+    }
+    else {
+        rv = apr_file_open(&ds->f, ds->pathname, flags, APR_OS_DEFAULT, ds->p);
+    }
+
+    if (rv != APR_SUCCESS) {
+        return dav_new_error(p, MAP_IO2HTTP(rv), 0, rv,
+                             "An error occurred while opening a resource.");
+    }
+
+    /* (APR registers cleanups for the fd with the pool) */
+
+    *stream = ds;
+    return NULL;
+}
+
+static dav_error * dav_fs_close_stream(dav_stream *stream, int commit)
+{
+    apr_status_t rv;
+
+    apr_file_close(stream->f);
+
+    if (!commit) {
+        if (stream->temppath) {
+            apr_pool_cleanup_run(stream->p, stream, tmpfile_cleanup);
+        }
+        else if (stream->unlink_on_error) {
+            if ((rv = apr_file_remove(stream->pathname, stream->p))
+                != APR_SUCCESS) {
+                /* ### use a better description? */
+                return dav_new_error(stream->p, HTTP_INTERNAL_SERVER_ERROR, 0,
+                                     rv,
+                                     "There was a problem removing (rolling "
+                                     "back) the resource "
+                                     "when it was being closed.");
+            }
+        }
+    }
+    else if (stream->temppath) {
+        rv = apr_file_rename(stream->temppath, stream->pathname, stream->p);
+        if (rv) {
+            return dav_new_error(stream->p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
+                                 "There was a problem writing the file "
+                                 "atomically after writes.");
+        }
+        apr_pool_cleanup_kill(stream->p, stream, tmpfile_cleanup);
+    }
+
+    return NULL;
+}
+
+static dav_error * dav_fs_write_stream(dav_stream *stream,
+                                       const void *buf, apr_size_t bufsize)
+{
+    apr_status_t status;
+
+    status = apr_file_write_full(stream->f, buf, bufsize, NULL);
+    if (APR_STATUS_IS_ENOSPC(status)) {
+        return dav_new_error(stream->p, HTTP_INSUFFICIENT_STORAGE, 0, status,
+                             "There is not enough storage to write to "
+                             "this resource.");
+    }
+    else if (status != APR_SUCCESS) {
+        /* ### use something besides 500? */
+        return dav_new_error(stream->p, HTTP_INTERNAL_SERVER_ERROR, 0, status,
+                             "An error occurred while writing to a "
+                             "resource.");
+    }
+    return NULL;
+}
+
+static dav_error * dav_fs_seek_stream(dav_stream *stream, apr_off_t abs_pos)
+{
+    apr_status_t status;
+
+    if ((status = apr_file_seek(stream->f, APR_SET, &abs_pos))
+        != APR_SUCCESS) {
+        /* ### should check whether apr_file_seek set abs_pos was set to the
+         * correct position? */
+        /* ### use something besides 500? */
+        return dav_new_error(stream->p, HTTP_INTERNAL_SERVER_ERROR, 0, status,
+                             "Could not seek to specified position in the "
+                             "resource.");
+    }
+    return NULL;
+}
+
+
+#if DEBUG_GET_HANDLER
+
+/* only define set_headers() and deliver() for debug purposes */
+
+
+static dav_error * dav_fs_set_headers(request_rec *r,
+                                      const dav_resource *resource)
+{
+    /* ### this function isn't really used since we have a get_pathname */
+    if (!resource->exists)
+        return NULL;
+
+    /* make sure the proper mtime is in the request record */
+    ap_update_mtime(r, resource->info->finfo.mtime);
+
+    /* ### note that these use r->filename rather than <resource> */
+    ap_set_last_modified(r);
+    ap_set_etag(r);
+
+    /* we accept byte-ranges */
+    ap_set_accept_ranges(r);
+
+    /* set up the Content-Length header */
+    ap_set_content_length(r, resource->info->finfo.size);
+
+    /* ### how to set the content type? */
+    /* ### until this is resolved, the Content-Type header is busted */
+
+    return NULL;
+}
+
+static dav_error * dav_fs_deliver(const dav_resource *resource,
+                                  ap_filter_t *output)
+{
+    apr_pool_t *pool = resource->pool;
+    apr_bucket_brigade *bb;
+    apr_file_t *fd;
+    apr_status_t status;
+    apr_bucket *bkt;
+
+    /* Check resource type */
+    if (resource->type != DAV_RESOURCE_TYPE_REGULAR
+        && resource->type != DAV_RESOURCE_TYPE_VERSION
+        && resource->type != DAV_RESOURCE_TYPE_WORKING) {
+        return dav_new_error(pool, HTTP_CONFLICT, 0, 0,
+                             "Cannot GET this type of resource.");
+    }
+    if (resource->collection) {
+        return dav_new_error(pool, HTTP_CONFLICT, 0, 0,
+                             "There is no default response to GET for a "
+                             "collection.");
+    }
+
+    if ((status = apr_file_open(&fd, resource->info->pathname,
+                                APR_READ | APR_BINARY, 0,
+                                pool)) != APR_SUCCESS) {
+        return dav_new_error(pool, HTTP_FORBIDDEN, 0, status,
+                             "File permissions deny server access.");
+    }
+
+    bb = apr_brigade_create(pool, output->c->bucket_alloc);
+
+    apr_brigade_insert_file(bb, fd, 0, resource->info->finfo.size, pool);
+
+    bkt = apr_bucket_eos_create(output->c->bucket_alloc);
+    APR_BRIGADE_INSERT_TAIL(bb, bkt);
+
+    if ((status = ap_pass_brigade(output, bb)) != APR_SUCCESS) {
+        return dav_new_error(pool, AP_FILTER_ERROR, 0, status,
+                             "Could not write contents to filter.");
+    }
+
+    return NULL;
+}
+
+#endif /* DEBUG_GET_HANDLER */
+
+
+static dav_error * dav_fs_create_collection(dav_resource *resource)
+{
+    dav_resource_private *ctx = resource->info;
+    apr_status_t status;
+
+    status = apr_dir_make(ctx->pathname, APR_OS_DEFAULT, ctx->pool);
+    if (APR_STATUS_IS_ENOSPC(status)) {
+        return dav_new_error(ctx->pool, HTTP_INSUFFICIENT_STORAGE, 0, status,
+                             "There is not enough storage to create "
+                             "this collection.");
+    }
+    else if (APR_STATUS_IS_ENOENT(status)) {
+        return dav_new_error(ctx->pool, HTTP_CONFLICT, 0, status,
+                             "Cannot create collection; intermediate "
+                             "collection does not exist.");
+    }
+    else if (status != APR_SUCCESS) {
+        /* ### refine this error message? */
+        return dav_new_error(ctx->pool, HTTP_FORBIDDEN, 0, status,
+                             "Unable to create collection.");
+    }
+
+    /* update resource state to show it exists as a collection */
+    resource->exists = 1;
+    resource->collection = 1;
+
+    return NULL;
+}
+
+static dav_error * dav_fs_copymove_walker(dav_walk_resource *wres,
+                                          int calltype)
+{
+    apr_status_t status;
+    dav_fs_copymove_walk_ctx *ctx = wres->walk_ctx;
+    dav_resource_private *srcinfo = wres->resource->info;
+    dav_resource_private *dstinfo = ctx->res_dst->info;
+    dav_error *err = NULL;
+
+    if (wres->resource->collection) {
+        if (calltype == DAV_CALLTYPE_POSTFIX) {
+            /* Postfix call for MOVE. delete the source dir.
+             * Note: when copying, we do not enable the postfix-traversal.
+             */
+            /* ### we are ignoring any error here; what should we do? */
+            (void) apr_dir_remove(srcinfo->pathname, ctx->pool);
+        }
+        else {
+            /* copy/move of a collection. Create the new, target collection */
+            if ((status = apr_dir_make(dstinfo->pathname, APR_OS_DEFAULT,
+                                       ctx->pool)) != APR_SUCCESS) {
+                /* ### assume it was a permissions problem */
+                /* ### need a description here */
+                err = dav_new_error(ctx->pool, HTTP_FORBIDDEN, 0, status, NULL);
+            }
+        }
+    }
+    else {
+        err = dav_fs_copymove_file(ctx->is_move, ctx->pool,
+                                   srcinfo->pathname, dstinfo->pathname,
+                                   &srcinfo->finfo,
+                                   ctx->res_dst->exists ? &dstinfo->finfo : NULL,
+                                   &ctx->work_buf);
+        /* ### push a higher-level description? */
+    }
+
+    /*
+    ** If we have a "not so bad" error, then it might need to go into a
+    ** multistatus response.
+    **
+    ** For a MOVE, it will always go into the multistatus. It could be
+    ** that everything has been moved *except* for the root. Using a
+    ** multistatus (with no errors for the other resources) will signify
+    ** this condition.
+    **
+    ** For a COPY, we are traversing in a prefix fashion. If the root fails,
+    ** then we can just bail out now.
+    */
+    if (err != NULL
+        && !ap_is_HTTP_SERVER_ERROR(err->status)
+        && (ctx->is_move
+            || !dav_fs_is_same_resource(wres->resource, ctx->root))) {
+        /* ### use errno to generate DAV:responsedescription? */
+        dav_add_response(wres, err->status, NULL);
+
+        /* the error is in the multistatus now. do not stop the traversal. */
+        return NULL;
+    }
+
+    return err;
+}
+
+static dav_error *dav_fs_copymove_resource(
+    int is_move,
+    const dav_resource *src,
+    const dav_resource *dst,
+    int depth,
+    dav_response **response)
+{
+    dav_error *err = NULL;
+    dav_buffer work_buf = { 0 };
+
+    *response = NULL;
+
+    /* if a collection, recursively copy/move it and its children,
+     * including the state dirs
+     */
+    if (src->collection) {
+        dav_walk_params params = { 0 };
+        dav_response *multi_status;
+
+        params.walk_type = DAV_WALKTYPE_NORMAL | DAV_WALKTYPE_HIDDEN;
+        params.func = dav_fs_copymove_walker;
+        params.pool = src->info->pool;
+        params.root = src;
+
+        /* params.walk_ctx is managed by dav_fs_internal_walk() */
+
+        /* postfix is needed for MOVE to delete source dirs */
+        if (is_move)
+            params.walk_type |= DAV_WALKTYPE_POSTFIX;
+
+        /* note that we return the error OR the multistatus. never both */
+
+        if ((err = dav_fs_internal_walk(&params, depth, is_move, dst,
+                                        &multi_status)) != NULL) {
+            /* on a "real" error, then just punt. nothing else to do. */
+            return err;
+        }
+
+        if ((*response = multi_status) != NULL) {
+            /* some multistatus responses exist. wrap them in a 207 */
+            return dav_new_error(src->info->pool, HTTP_MULTI_STATUS, 0, 0,
+                                 "Error(s) occurred on some resources during "
+                                 "the COPY/MOVE process.");
+        }
+
+        return NULL;
+    }
+
+    /* not a collection */
+    if ((err = dav_fs_copymove_file(is_move, src->info->pool,
+                                    src->info->pathname, dst->info->pathname,
+                                    &src->info->finfo,
+                                    dst->exists ? &dst->info->finfo : NULL,
+                                    &work_buf)) != NULL) {
+        /* ### push a higher-level description? */
+        return err;
+    }
+
+    /* copy/move properties as well */
+    return dav_fs_copymoveset(is_move, src->info->pool, src, dst, &work_buf);
+}
+
+static dav_error * dav_fs_copy_resource(
+    const dav_resource *src,
+    dav_resource *dst,
+    int depth,
+    dav_response **response)
+{
+    dav_error *err;
+
+#if DAV_DEBUG
+    if (src->hooks != dst->hooks) {
+        /*
+        ** ### strictly speaking, this is a design error; we should not
+        ** ### have reached this point.
+        */
+        return dav_new_error(src->info->pool, HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                             "DESIGN ERROR: a mix of repositories "
+                             "was passed to copy_resource.");
+    }
+#endif
+
+    if ((err = dav_fs_copymove_resource(0, src, dst, depth,
+                                        response)) == NULL) {
+
+        /* update state of destination resource to show it exists */
+        dst->exists = 1;
+        dst->collection = src->collection;
+    }
+
+    return err;
+}
+
+static dav_error * dav_fs_move_resource(
+    dav_resource *src,
+    dav_resource *dst,
+    dav_response **response)
+{
+    dav_resource_private *srcinfo = src->info;
+    dav_resource_private *dstinfo = dst->info;
+    dav_error *err;
+    apr_status_t rv;
+
+#if DAV_DEBUG
+    if (src->hooks != dst->hooks) {
+        /*
+        ** ### strictly speaking, this is a design error; we should not
+        ** ### have reached this point.
+        */
+        return dav_new_error(src->info->pool, HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                             "DESIGN ERROR: a mix of repositories "
+                             "was passed to move_resource.");
+    }
+#endif
+
+
+    /* try rename first */
+    rv = apr_file_rename(srcinfo->pathname, dstinfo->pathname, srcinfo->pool);
+
+    /* if we can't simply rename, then do it the hard way... */
+    if (APR_STATUS_IS_EXDEV(rv)) {
+        if ((err = dav_fs_copymove_resource(1, src, dst, DAV_INFINITY,
+                                            response)) == NULL) {
+            /* update resource states */
+            dst->exists = 1;
+            dst->collection = src->collection;
+            src->exists = 0;
+            src->collection = 0;
+        }
+
+        return err;
+    }
+
+    /* no multistatus response */
+    *response = NULL;
+
+    if (rv != APR_SUCCESS) {
+        /* ### should have a better error than this. */
+        return dav_new_error(srcinfo->pool, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
+                             "Could not rename resource.");
+    }
+
+    /* Rename did work. Update resource states and move properties as well */
+    dst->exists = 1;
+    dst->collection = src->collection;
+    src->exists = 0;
+    src->collection = 0;
+
+    if ((err = dav_fs_copymoveset(1, src->info->pool,
+                                  src, dst, NULL)) == NULL) {
+        /* no error. we're done. go ahead and return now. */
+        return NULL;
+    }
+
+    /* error occurred during properties move; try to put resource back */
+    if (apr_file_rename(dstinfo->pathname, srcinfo->pathname,
+                       srcinfo->pool) != APR_SUCCESS) {
+        /* couldn't put it back! */
+        return dav_push_error(srcinfo->pool,
+                              HTTP_INTERNAL_SERVER_ERROR, 0,
+                              "The resource was moved, but a failure "
+                              "occurred during the move of its "
+                              "properties. The resource could not be "
+                              "restored to its original location. The "
+                              "server is now in an inconsistent state.",
+                              err);
+    }
+
+    /* update resource states again */
+    src->exists = 1;
+    src->collection = dst->collection;
+    dst->exists = 0;
+    dst->collection = 0;
+
+    /* resource moved back, but properties may be inconsistent */
+    return dav_push_error(srcinfo->pool,
+                          HTTP_INTERNAL_SERVER_ERROR, 0,
+                          "The resource was moved, but a failure "
+                          "occurred during the move of its properties. "
+                          "The resource was moved back to its original "
+                          "location, but its properties may have been "
+                          "partially moved. The server may be in an "
+                          "inconsistent state.",
+                          err);
+}
+
+static dav_error * dav_fs_delete_walker(dav_walk_resource *wres, int calltype)
+{
+    dav_resource_private *info = wres->resource->info;
+
+    /* do not attempt to remove a null resource,
+     * or a collection with children
+     */
+    if (wres->resource->exists &&
+        (!wres->resource->collection || calltype == DAV_CALLTYPE_POSTFIX)) {
+        /* try to remove the resource */
+        apr_status_t result;
+
+        result = wres->resource->collection
+            ? apr_dir_remove(info->pathname, wres->pool)
+            : apr_file_remove(info->pathname, wres->pool);
+
+        /*
+        ** If an error occurred, then add it to multistatus response.
+        ** Note that we add it for the root resource, too. It is quite
+        ** possible to delete the whole darn tree, yet fail on the root.
+        **
+        ** (also: remember we are deleting via a postfix traversal)
+        */
+        if (result != APR_SUCCESS) {
+            /* ### assume there is a permissions problem */
+
+            /* ### use errno to generate DAV:responsedescription? */
+            dav_add_response(wres, HTTP_FORBIDDEN, NULL);
+        }
+    }
+
+    return NULL;
+}
+
+static dav_error * dav_fs_remove_resource(dav_resource *resource,
+                                          dav_response **response)
+{
+    apr_status_t status;
+    dav_resource_private *info = resource->info;
+
+    *response = NULL;
+
+    /* if a collection, recursively remove it and its children,
+     * including the state dirs
+     */
+    if (resource->collection) {
+        dav_walk_params params = { 0 };
+        dav_error *err = NULL;
+        dav_response *multi_status;
+
+        params.walk_type = (DAV_WALKTYPE_NORMAL
+                            | DAV_WALKTYPE_HIDDEN
+                            | DAV_WALKTYPE_POSTFIX);
+        params.func = dav_fs_delete_walker;
+        params.pool = info->pool;
+        params.root = resource;
+
+        if ((err = dav_fs_walk(&params, DAV_INFINITY,
+                               &multi_status)) != NULL) {
+            /* on a "real" error, then just punt. nothing else to do. */
+            return err;
+        }
+
+        if ((*response = multi_status) != NULL) {
+            /* some multistatus responses exist. wrap them in a 207 */
+            return dav_new_error(info->pool, HTTP_MULTI_STATUS, 0, 0,
+                                 "Error(s) occurred on some resources during "
+                                 "the deletion process.");
+        }
+
+        /* no errors... update resource state */
+        resource->exists = 0;
+        resource->collection = 0;
+
+        return NULL;
+    }
+
+    /* not a collection; remove the file and its properties */
+    if ((status = apr_file_remove(info->pathname, info->pool)) != APR_SUCCESS) {
+        /* ### put a description in here */
+        return dav_new_error(info->pool, HTTP_FORBIDDEN, 0, status, NULL);
+    }
+
+    /* update resource state */
+    resource->exists = 0;
+    resource->collection = 0;
+
+    /* remove properties and return its result */
+    return dav_fs_deleteset(info->pool, resource);
+}
+
+/* ### move this to dav_util? */
+/* Walk recursively down through directories, *
+ * including lock-null resources as we go.    */
+static dav_error * dav_fs_walker(dav_fs_walker_context *fsctx, int depth)
+{
+    const dav_walk_params *params = fsctx->params;
+    apr_pool_t *pool = params->pool;
+    apr_status_t status;
+    dav_error *err = NULL;
+    int isdir = fsctx->res1.collection;
+    apr_finfo_t dirent;
+    apr_dir_t *dirp;
+
+    /* ensure the context is prepared properly, then call the func */
+    err = (*params->func)(&fsctx->wres,
+                          isdir
+                          ? DAV_CALLTYPE_COLLECTION
+                          : DAV_CALLTYPE_MEMBER);
+    if (err != NULL) {
+        return err;
+    }
+
+    if (depth == 0 || !isdir) {
+        return NULL;
+    }
+
+    /* put a trailing slash onto the directory, in preparation for appending
+     * files to it as we discovery them within the directory */
+    dav_check_bufsize(pool, &fsctx->path1, DAV_BUFFER_PAD);
+    fsctx->path1.buf[fsctx->path1.cur_len++] = '/';
+    fsctx->path1.buf[fsctx->path1.cur_len] = '\0';        /* in pad area */
+
+    /* if a secondary path is present, then do that, too */
+    if (fsctx->path2.buf != NULL) {
+        dav_check_bufsize(pool, &fsctx->path2, DAV_BUFFER_PAD);
+        fsctx->path2.buf[fsctx->path2.cur_len++] = '/';
+        fsctx->path2.buf[fsctx->path2.cur_len] = '\0';        /* in pad area */
+    }
+
+    /* Note: the URI should ALREADY have a trailing "/" */
+
+    /* for this first pass of files, all resources exist */
+    fsctx->res1.exists = 1;
+
+    /* a file is the default; we'll adjust if we hit a directory */
+    fsctx->res1.collection = 0;
+    fsctx->res2.collection = 0;
+
+    /* open and scan the directory */
+    if ((status = apr_dir_open(&dirp, fsctx->path1.buf, pool)) != APR_SUCCESS) {
+        /* ### need a better error */
+        return dav_new_error(pool, HTTP_NOT_FOUND, 0, status, NULL);
+    }
+    while ((apr_dir_read(&dirent, APR_FINFO_DIRENT, dirp)) == APR_SUCCESS) {
+        apr_size_t len;
+
+        len = strlen(dirent.name);
+
+        /* avoid recursing into our current, parent, or state directories */
+        if (dirent.name[0] == '.'
+              && (len == 1 || (dirent.name[1] == '.' && len == 2))) {
+            continue;
+        }
+
+        if (params->walk_type & DAV_WALKTYPE_AUTH) {
+            /* ### need to authorize each file */
+            /* ### example: .htaccess is normally configured to fail auth */
+
+            /* stuff in the state directory and temp files are never authorized! */
+            if (!strcmp(dirent.name, DAV_FS_STATE_DIR) ||
+                !strncmp(dirent.name, DAV_FS_TMP_PREFIX,
+                         strlen(DAV_FS_TMP_PREFIX))) {
+                continue;
+            }
+        }
+        /* skip the state dir and temp files unless a HIDDEN is performed */
+        if (!(params->walk_type & DAV_WALKTYPE_HIDDEN)
+            && (!strcmp(dirent.name, DAV_FS_STATE_DIR) ||
+                !strncmp(dirent.name, DAV_FS_TMP_PREFIX,
+                         strlen(DAV_FS_TMP_PREFIX)))) {
+            continue;
+        }
+
+        /* append this file onto the path buffer (copy null term) */
+        dav_buffer_place_mem(pool, &fsctx->path1, dirent.name, len + 1, 0);
+
+        status = apr_stat(&fsctx->info1.finfo, fsctx->path1.buf,
+                          DAV_FINFO_MASK, pool);
+        if (status != APR_SUCCESS && status != APR_INCOMPLETE) {
+            /* woah! where'd it go? */
+            /* ### should have a better error here */
+            err = dav_new_error(pool, HTTP_NOT_FOUND, 0, status, NULL);
+            break;
+        }
+
+        /* copy the file to the URI, too. NOTE: we will pad an extra byte
+           for the trailing slash later. */
+        dav_buffer_place_mem(pool, &fsctx->uri_buf, dirent.name, len + 1, 1);
+
+        /* if there is a secondary path, then do that, too */
+        if (fsctx->path2.buf != NULL) {
+            dav_buffer_place_mem(pool, &fsctx->path2, dirent.name, len + 1, 0);
+        }
+
+        /* set up the (internal) pathnames for the two resources */
+        fsctx->info1.pathname = fsctx->path1.buf;
+        fsctx->info2.pathname = fsctx->path2.buf;
+
+        /* set up the URI for the current resource */
+        fsctx->res1.uri = fsctx->uri_buf.buf;
+
+        /* ### for now, only process regular files (e.g. skip symlinks) */
+        if (fsctx->info1.finfo.filetype == APR_REG) {
+            /* call the function for the specified dir + file */
+            if ((err = (*params->func)(&fsctx->wres,
+                                       DAV_CALLTYPE_MEMBER)) != NULL) {
+                /* ### maybe add a higher-level description? */
+                break;
+            }
+        }
+        else if (fsctx->info1.finfo.filetype == APR_DIR) {
+            apr_size_t save_path_len = fsctx->path1.cur_len;
+            apr_size_t save_uri_len = fsctx->uri_buf.cur_len;
+            apr_size_t save_path2_len = fsctx->path2.cur_len;
+
+            /* adjust length to incorporate the subdir name */
+            fsctx->path1.cur_len += len;
+            fsctx->path2.cur_len += len;
+
+            /* adjust URI length to incorporate subdir and a slash */
+            fsctx->uri_buf.cur_len += len + 1;
+            fsctx->uri_buf.buf[fsctx->uri_buf.cur_len - 1] = '/';
+            fsctx->uri_buf.buf[fsctx->uri_buf.cur_len] = '\0';
+
+            /* switch over to a collection */
+            fsctx->res1.collection = 1;
+            fsctx->res2.collection = 1;
+
+            /* recurse on the subdir */
+            /* ### don't always want to quit on error from single child */
+            if ((err = dav_fs_walker(fsctx, depth - 1)) != NULL) {
+                /* ### maybe add a higher-level description? */
+                break;
+            }
+
+            /* put the various information back */
+            fsctx->path1.cur_len = save_path_len;
+            fsctx->path2.cur_len = save_path2_len;
+            fsctx->uri_buf.cur_len = save_uri_len;
+
+            fsctx->res1.collection = 0;
+            fsctx->res2.collection = 0;
+
+            /* assert: res1.exists == 1 */
+        }
+    }
+
+    /* ### check the return value of this? */
+    apr_dir_close(dirp);
+
+    if (err != NULL)
+        return err;
+
+    if (params->walk_type & DAV_WALKTYPE_LOCKNULL) {
+        apr_size_t offset = 0;
+
+        /* null terminate the directory name */
+        fsctx->path1.buf[fsctx->path1.cur_len - 1] = '\0';
+
+        /* Include any lock null resources found in this collection */
+        fsctx->res1.collection = 1;
+        if ((err = dav_fs_get_locknull_members(&fsctx->res1,
+                                               &fsctx->locknull_buf)) != NULL) {
+            /* ### maybe add a higher-level description? */
+            return err;
+        }
+
+        /* put a slash back on the end of the directory */
+        fsctx->path1.buf[fsctx->path1.cur_len - 1] = '/';
+
+        /* these are all non-existant (files) */
+        fsctx->res1.exists = 0;
+        fsctx->res1.collection = 0;
+        memset(&fsctx->info1.finfo, 0, sizeof(fsctx->info1.finfo));
+
+        while (offset < fsctx->locknull_buf.cur_len) {
+            apr_size_t len = strlen(fsctx->locknull_buf.buf + offset);
+            dav_lock *locks = NULL;
+
+            /*
+            ** Append the locknull file to the paths and the URI. Note that
+            ** we don't have to pad the URI for a slash since a locknull
+            ** resource is not a collection.
+            */
+            dav_buffer_place_mem(pool, &fsctx->path1,
+                                 fsctx->locknull_buf.buf + offset, len + 1, 0);
+            dav_buffer_place_mem(pool, &fsctx->uri_buf,
+                                 fsctx->locknull_buf.buf + offset, len + 1, 0);
+            if (fsctx->path2.buf != NULL) {
+                dav_buffer_place_mem(pool, &fsctx->path2,
+                                     fsctx->locknull_buf.buf + offset,
+                                     len + 1, 0);
+            }
+
+            /* set up the (internal) pathnames for the two resources */
+            fsctx->info1.pathname = fsctx->path1.buf;
+            fsctx->info2.pathname = fsctx->path2.buf;
+
+            /* set up the URI for the current resource */
+            fsctx->res1.uri = fsctx->uri_buf.buf;
+
+            /*
+            ** To prevent a PROPFIND showing an expired locknull
+            ** resource, query the lock database to force removal
+            ** of both the lock entry and .locknull, if necessary..
+            ** Sure, the query in PROPFIND would do this.. after
+            ** the locknull resource was already included in the
+            ** return.
+            **
+            ** NOTE: we assume the caller has opened the lock database
+            **       if they have provided DAV_WALKTYPE_LOCKNULL.
+            */
+            /* ### we should also look into opening it read-only and
+               ### eliding timed-out items from the walk, yet leaving
+               ### them in the locknull database until somebody opens
+               ### the thing writable.
+               */
+            /* ### probably ought to use has_locks. note the problem
+               ### mentioned above, though... we would traverse this as
+               ### a locknull, but then a PROPFIND would load the lock
+               ### info, causing a timeout and the locks would not be
+               ### reported. Therefore, a null resource would be returned
+               ### in the PROPFIND.
+               ###
+               ### alternative: just load unresolved locks. any direct
+               ### locks will be timed out (correct). any indirect will
+               ### not (correct; consider if a parent timed out -- the
+               ### timeout routines do not walk and remove indirects;
+               ### even the resolve func would probably fail when it
+               ### tried to find a timed-out direct lock).
+            */
+            if ((err = dav_lock_query(params->lockdb, &fsctx->res1,
+                                      &locks)) != NULL) {
+                /* ### maybe add a higher-level description? */
+                return err;
+            }
+
+            /* call the function for the specified dir + file */
+            if (locks != NULL &&
+                (err = (*params->func)(&fsctx->wres,
+                                       DAV_CALLTYPE_LOCKNULL)) != NULL) {
+                /* ### maybe add a higher-level description? */
+                return err;
+            }
+
+            offset += len + 1;
+        }
+
+        /* reset the exists flag */
+        fsctx->res1.exists = 1;
+    }
+
+    if (params->walk_type & DAV_WALKTYPE_POSTFIX) {
+        /* replace the dirs' trailing slashes with null terms */
+        fsctx->path1.buf[--fsctx->path1.cur_len] = '\0';
+        fsctx->uri_buf.buf[--fsctx->uri_buf.cur_len] = '\0';
+        if (fsctx->path2.buf != NULL) {
+            fsctx->path2.buf[--fsctx->path2.cur_len] = '\0';
+        }
+
+        /* this is a collection which exists */
+        fsctx->res1.collection = 1;
+
+        return (*params->func)(&fsctx->wres, DAV_CALLTYPE_POSTFIX);
+    }
+
+    return NULL;
+}
+
+static dav_error * dav_fs_internal_walk(const dav_walk_params *params,
+                                        int depth, int is_move,
+                                        const dav_resource *root_dst,
+                                        dav_response **response)
+{
+    dav_fs_walker_context fsctx = { 0 };
+    dav_error *err;
+    dav_fs_copymove_walk_ctx cm_ctx = { 0 };
+
+#if DAV_DEBUG
+    if ((params->walk_type & DAV_WALKTYPE_LOCKNULL) != 0
+        && params->lockdb == NULL) {
+        return dav_new_error(params->pool, HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                             "DESIGN ERROR: walker called to walk locknull "
+                             "resources, but a lockdb was not provided.");
+    }
+#endif
+
+    fsctx.params = params;
+    fsctx.wres.walk_ctx = params->walk_ctx;
+    fsctx.wres.pool = params->pool;
+
+    /* ### zero out versioned, working, baselined? */
+
+    fsctx.res1 = *params->root;
+    fsctx.res1.pool = params->pool;
+
+    fsctx.res1.info = &fsctx.info1;
+    fsctx.info1 = *params->root->info;
+
+    /* the pathname is stored in the path1 buffer */
+    dav_buffer_init(params->pool, &fsctx.path1, fsctx.info1.pathname);
+    fsctx.info1.pathname = fsctx.path1.buf;
+
+    if (root_dst != NULL) {
+        /* internal call from the COPY/MOVE code. set it up. */
+
+        fsctx.wres.walk_ctx = &cm_ctx;
+        cm_ctx.is_move = is_move;
+        cm_ctx.res_dst = &fsctx.res2;
+        cm_ctx.root = params->root;
+        cm_ctx.pool = params->pool;
+
+        fsctx.res2 = *root_dst;
+        fsctx.res2.exists = 0;
+        fsctx.res2.collection = 0;
+        fsctx.res2.uri = NULL;          /* we don't track this */
+        fsctx.res2.pool = params->pool;
+
+        fsctx.res2.info = &fsctx.info2;
+        fsctx.info2 = *root_dst->info;
+
+        /* res2 does not exist -- clear its finfo structure */
+        memset(&fsctx.info2.finfo, 0, sizeof(fsctx.info2.finfo));
+
+        /* the pathname is stored in the path2 buffer */
+        dav_buffer_init(params->pool, &fsctx.path2, fsctx.info2.pathname);
+        fsctx.info2.pathname = fsctx.path2.buf;
+    }
+
+    /* prep the URI buffer */
+    dav_buffer_init(params->pool, &fsctx.uri_buf, params->root->uri);
+
+    /* if we have a directory, then ensure the URI has a trailing "/" */
+    if (fsctx.res1.collection
+        && fsctx.uri_buf.buf[fsctx.uri_buf.cur_len - 1] != '/') {
+
+        /* this will fall into the pad area */
+        fsctx.uri_buf.buf[fsctx.uri_buf.cur_len++] = '/';
+        fsctx.uri_buf.buf[fsctx.uri_buf.cur_len] = '\0';
+    }
+
+    /* the current resource's URI is stored in the uri_buf buffer */
+    fsctx.res1.uri = fsctx.uri_buf.buf;
+
+    /* point the callback's resource at our structure */
+    fsctx.wres.resource = &fsctx.res1;
+
+    /* always return the error, and any/all multistatus responses */
+    err = dav_fs_walker(&fsctx, depth);
+    *response = fsctx.wres.response;
+    return err;
+}
+
+static dav_error * dav_fs_walk(const dav_walk_params *params, int depth,
+                               dav_response **response)
+{
+    /* always return the error, and any/all multistatus responses */
+    return dav_fs_internal_walk(params, depth, 0, NULL, response);
+}
+
+/* dav_fs_etag:  Stolen from ap_make_etag.  Creates a strong etag
+ *    for file path.
+ * ### do we need to return weak tags sometimes?
+ */
+static const char *dav_fs_getetag(const dav_resource *resource)
+{
+    dav_resource_private *ctx = resource->info;
+    /* XXX: This should really honor the FileETag setting */
+
+    if (!resource->exists)
+        return apr_pstrdup(ctx->pool, "");
+
+    if (ctx->finfo.filetype != APR_NOFILE) {
+        return apr_psprintf(ctx->pool, "\"%" APR_UINT64_T_HEX_FMT "-%"
+                            APR_UINT64_T_HEX_FMT "\"",
+                            (apr_uint64_t) ctx->finfo.size,
+                            (apr_uint64_t) ctx->finfo.mtime);
+    }
+
+    return apr_psprintf(ctx->pool, "\"%" APR_UINT64_T_HEX_FMT "\"",
+                       (apr_uint64_t) ctx->finfo.mtime);
+}
+
+static const dav_hooks_repository dav_hooks_repository_fs =
+{
+    DEBUG_GET_HANDLER,   /* normally: special GET handling not required */
+    dav_fs_get_resource,
+    dav_fs_get_parent_resource,
+    dav_fs_is_same_resource,
+    dav_fs_is_parent_resource,
+    dav_fs_open_stream,
+    dav_fs_close_stream,
+    dav_fs_write_stream,
+    dav_fs_seek_stream,
+#if DEBUG_GET_HANDLER
+    dav_fs_set_headers,
+    dav_fs_deliver,
+#else
+    NULL,
+    NULL,
+#endif
+    dav_fs_create_collection,
+    dav_fs_copy_resource,
+    dav_fs_move_resource,
+    dav_fs_remove_resource,
+    dav_fs_walk,
+    dav_fs_getetag,
+    NULL,
+    dav_fs_get_request_rec,
+    dav_fs_pathname
+};
+
+static dav_prop_insert dav_fs_insert_prop(const dav_resource *resource,
+                                          int propid, dav_prop_insert what,
+                                          apr_text_header *phdr)
+{
+    const char *value;
+    const char *s;
+    apr_pool_t *p = resource->info->pool;
+    const dav_liveprop_spec *info;
+    int global_ns;
+
+    /* an HTTP-date can be 29 chars plus a null term */
+    /* a 64-bit size can be 20 chars plus a null term */
+    char buf[DAV_TIMEBUF_SIZE];
+
+    /*
+    ** None of FS provider properties are defined if the resource does not
+    ** exist. Just bail for this case.
+    **
+    ** Even though we state that the FS properties are not defined, the
+    ** client cannot store dead values -- we deny that thru the is_writable
+    ** hook function.
+    */
+    if (!resource->exists)
+        return DAV_PROP_INSERT_NOTDEF;
+
+    switch (propid) {
+    case DAV_PROPID_creationdate:
+        /*
+        ** Closest thing to a creation date. since we don't actually
+        ** perform the operations that would modify ctime (after we
+        ** create the file), then we should be pretty safe here.
+        */
+        dav_format_time(DAV_STYLE_ISO8601,
+                        resource->info->finfo.ctime,
+                        buf, sizeof(buf));
+        value = buf;
+        break;
+
+    case DAV_PROPID_getcontentlength:
+        /* our property, but not defined on collection resources */
+        if (resource->collection)
+            return DAV_PROP_INSERT_NOTDEF;
+
+        apr_snprintf(buf, sizeof(buf), "%" APR_OFF_T_FMT, resource->info->finfo.size);
+        value = buf;
+        break;
+
+    case DAV_PROPID_getetag:
+        value = dav_fs_getetag(resource);
+        break;
+
+    case DAV_PROPID_getlastmodified:
+        dav_format_time(DAV_STYLE_RFC822,
+                        resource->info->finfo.mtime,
+                        buf, sizeof(buf));
+        value = buf;
+        break;
+
+    case DAV_PROPID_FS_executable:
+        /* our property, but not defined on collection resources */
+        if (resource->collection)
+            return DAV_PROP_INSERT_NOTDEF;
+
+        /* our property, but not defined on this platform */
+        if (!(resource->info->finfo.valid & APR_FINFO_UPROT))
+            return DAV_PROP_INSERT_NOTDEF;
+
+        /* the files are "ours" so we only need to check owner exec privs */
+        if (resource->info->finfo.protection & APR_UEXECUTE)
+            value = "T";
+        else
+            value = "F";
+        break;
+
+    default:
+        /* ### what the heck was this property? */
+        return DAV_PROP_INSERT_NOTDEF;
+    }
+
+    /* assert: value != NULL */
+
+    /* get the information and global NS index for the property */
+    global_ns = dav_get_liveprop_info(propid, &dav_fs_liveprop_group, &info);
+
+    /* assert: info != NULL && info->name != NULL */
+
+    /* DBG3("FS: inserting lp%d:%s  (local %d)", ns, scan->name, scan->ns); */
+
+    if (what == DAV_PROP_INSERT_VALUE) {
+        s = apr_psprintf(p, "<lp%d:%s>%s</lp%d:%s>" DEBUG_CR,
+                         global_ns, info->name, value, global_ns, info->name);
+    }
+    else if (what == DAV_PROP_INSERT_NAME) {
+        s = apr_psprintf(p, "<lp%d:%s/>" DEBUG_CR, global_ns, info->name);
+    }
+    else {
+        /* assert: what == DAV_PROP_INSERT_SUPPORTED */
+        s = apr_psprintf(p,
+                         "<D:supported-live-property D:name=\"%s\" "
+                         "D:namespace=\"%s\"/>" DEBUG_CR,
+                         info->name, dav_fs_namespace_uris[info->ns]);
+    }
+    apr_text_append(p, phdr, s);
+
+    /* we inserted what was asked for */
+    return what;
+}
+
+static int dav_fs_is_writable(const dav_resource *resource, int propid)
+{
+    const dav_liveprop_spec *info;
+
+#ifdef DAV_FS_HAS_EXECUTABLE
+    /* if we have the executable property, and this isn't a collection,
+       then the property is writable. */
+    if (propid == DAV_PROPID_FS_executable && !resource->collection)
+        return 1;
+#endif
+
+    (void) dav_get_liveprop_info(propid, &dav_fs_liveprop_group, &info);
+    return info->is_writable;
+}
+
+static dav_error *dav_fs_patch_validate(const dav_resource *resource,
+                                        const apr_xml_elem *elem,
+                                        int operation,
+                                        void **context,
+                                        int *defer_to_dead)
+{
+    const apr_text *cdata;
+    const apr_text *f_cdata;
+    char value;
+    dav_elem_private *priv = elem->priv;
+
+    if (priv->propid != DAV_PROPID_FS_executable) {
+        *defer_to_dead = 1;
+        return NULL;
+    }
+
+    if (operation == DAV_PROP_OP_DELETE) {
+        return dav_new_error(resource->info->pool, HTTP_CONFLICT, 0, 0,
+                             "The 'executable' property cannot be removed.");
+    }
+
+    cdata = elem->first_cdata.first;
+
+    /* ### hmm. this isn't actually looking at all the possible text items */
+    f_cdata = elem->first_child == NULL
+        ? NULL
+        : elem->first_child->following_cdata.first;
+
+    /* DBG3("name=%s  cdata=%s  f_cdata=%s",elem->name,cdata ? cdata->text : "[null]",f_cdata ? f_cdata->text : "[null]"); */
+
+    if (cdata == NULL) {
+        if (f_cdata == NULL) {
+            return dav_new_error(resource->info->pool, HTTP_CONFLICT, 0, 0,
+                                 "The 'executable' property expects a single "
+                                 "character, valued 'T' or 'F'. There was no "
+                                 "value submitted.");
+        }
+        cdata = f_cdata;
+    }
+    else if (f_cdata != NULL)
+        goto too_long;
+
+    if (cdata->next != NULL || strlen(cdata->text) != 1)
+        goto too_long;
+
+    value = cdata->text[0];
+    if (value != 'T' && value != 'F') {
+        return dav_new_error(resource->info->pool, HTTP_CONFLICT, 0, 0,
+                             "The 'executable' property expects a single "
+                             "character, valued 'T' or 'F'. The value "
+                             "submitted is invalid.");
+    }
+
+    *context = (void *)((long)(value == 'T'));
+
+    return NULL;
+
+  too_long:
+    return dav_new_error(resource->info->pool, HTTP_CONFLICT, 0, 0,
+                         "The 'executable' property expects a single "
+                         "character, valued 'T' or 'F'. The value submitted "
+                         "has too many characters.");
+
+}
+
+static dav_error *dav_fs_patch_exec(const dav_resource *resource,
+                                    const apr_xml_elem *elem,
+                                    int operation,
+                                    void *context,
+                                    dav_liveprop_rollback **rollback_ctx)
+{
+    long value = context != NULL;
+    apr_fileperms_t perms = resource->info->finfo.protection;
+    apr_status_t status;
+    long old_value = (perms & APR_UEXECUTE) != 0;
+
+    /* assert: prop == executable. operation == SET. */
+
+    /* don't do anything if there is no change. no rollback info either. */
+    /* DBG2("new value=%d  (old=%d)", value, old_value); */
+    if (value == old_value)
+        return NULL;
+
+    perms &= ~APR_UEXECUTE;
+    if (value)
+        perms |= APR_UEXECUTE;
+
+    if ((status = apr_file_perms_set(resource->info->pathname, perms))
+        != APR_SUCCESS) {
+        return dav_new_error(resource->info->pool,
+                             HTTP_INTERNAL_SERVER_ERROR, 0, status,
+                             "Could not set the executable flag of the "
+                             "target resource.");
+    }
+
+    /* update the resource and set up the rollback context */
+    resource->info->finfo.protection = perms;
+    *rollback_ctx = (dav_liveprop_rollback *)old_value;
+
+    return NULL;
+}
+
+static void dav_fs_patch_commit(const dav_resource *resource,
+                                int operation,
+                                void *context,
+                                dav_liveprop_rollback *rollback_ctx)
+{
+    /* nothing to do */
+}
+
+static dav_error *dav_fs_patch_rollback(const dav_resource *resource,
+                                        int operation,
+                                        void *context,
+                                        dav_liveprop_rollback *rollback_ctx)
+{
+    apr_fileperms_t perms = resource->info->finfo.protection & ~APR_UEXECUTE;
+    apr_status_t status;
+    int value = rollback_ctx != NULL;
+
+    /* assert: prop == executable. operation == SET. */
+
+    /* restore the executable bit */
+    if (value)
+        perms |= APR_UEXECUTE;
+
+    if ((status = apr_file_perms_set(resource->info->pathname, perms))
+        != APR_SUCCESS) {
+        return dav_new_error(resource->info->pool,
+                             HTTP_INTERNAL_SERVER_ERROR, 0, status,
+                             "After a failure occurred, the resource's "
+                             "executable flag could not be restored.");
+    }
+
+    /* restore the resource's state */
+    resource->info->finfo.protection = perms;
+
+    return NULL;
+}
+
+
+static const dav_hooks_liveprop dav_hooks_liveprop_fs =
+{
+    dav_fs_insert_prop,
+    dav_fs_is_writable,
+    dav_fs_namespace_uris,
+    dav_fs_patch_validate,
+    dav_fs_patch_exec,
+    dav_fs_patch_commit,
+    dav_fs_patch_rollback
+};
+
+static const dav_provider dav_fs_provider =
+{
+    &dav_hooks_repository_fs,
+    &dav_hooks_db_dbm,
+    &dav_hooks_locks_fs,
+    NULL,               /* vsn */
+    NULL,               /* binding */
+    NULL,               /* search */
+
+    NULL                /* ctx */
+};
+
+void dav_fs_gather_propsets(apr_array_header_t *uris)
+{
+#ifdef DAV_FS_HAS_EXECUTABLE
+    *(const char **)apr_array_push(uris) =
+        "<http://apache.org/dav/propset/fs/1>";
+#endif
+}
+
+int dav_fs_find_liveprop(const dav_resource *resource,
+                         const char *ns_uri, const char *name,
+                         const dav_hooks_liveprop **hooks)
+{
+    /* don't try to find any liveprops if this isn't "our" resource */
+    if (resource->hooks != &dav_hooks_repository_fs)
+        return 0;
+    return dav_do_find_liveprop(ns_uri, name, &dav_fs_liveprop_group, hooks);
+}
+
+void dav_fs_insert_all_liveprops(request_rec *r, const dav_resource *resource,
+                                 dav_prop_insert what, apr_text_header *phdr)
+{
+    /* don't insert any liveprops if this isn't "our" resource */
+    if (resource->hooks != &dav_hooks_repository_fs)
+        return;
+
+    if (!resource->exists) {
+        /* a lock-null resource */
+        /*
+        ** ### technically, we should insert empty properties. dunno offhand
+        ** ### what part of the spec said this, but it was essentially thus:
+        ** ### "the properties should be defined, but may have no value".
+        */
+        return;
+    }
+
+    (void) dav_fs_insert_prop(resource, DAV_PROPID_creationdate,
+                              what, phdr);
+    (void) dav_fs_insert_prop(resource, DAV_PROPID_getcontentlength,
+                              what, phdr);
+    (void) dav_fs_insert_prop(resource, DAV_PROPID_getlastmodified,
+                              what, phdr);
+    (void) dav_fs_insert_prop(resource, DAV_PROPID_getetag,
+                              what, phdr);
+
+#ifdef DAV_FS_HAS_EXECUTABLE
+    /* Only insert this property if it is defined for this platform. */
+    (void) dav_fs_insert_prop(resource, DAV_PROPID_FS_executable,
+                              what, phdr);
+#endif
+
+    /* ### we know the others aren't defined as liveprops */
+}
+
+void dav_fs_register(apr_pool_t *p)
+{
+    /* register the namespace URIs */
+    dav_register_liveprop_group(p, &dav_fs_liveprop_group);
+
+    /* register the repository provider */
+    dav_register_provider(p, "filesystem", &dav_fs_provider);
+}
diff --git a/modules/dav/fs/repos.h b/modules/dav/fs/repos.h
new file mode 100644
index 0000000..b164611
--- /dev/null
+++ b/modules/dav/fs/repos.h
@@ -0,0 +1,84 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file  repos.h
+ * @brief Declarations for the filesystem repository implementation
+ *
+ * @addtogroup MOD_DAV
+ * @{
+ */
+
+#ifndef _DAV_FS_REPOS_H_
+#define _DAV_FS_REPOS_H_
+
+/* the subdirectory to hold all DAV-related information for a directory */
+#define DAV_FS_STATE_DIR                ".DAV"
+#define DAV_FS_STATE_FILE_FOR_DIR       ".state_for_dir"
+#define DAV_FS_LOCK_NULL_FILE           ".locknull"
+
+
+/* ensure that our state subdirectory is present */
+void dav_fs_ensure_state_dir(apr_pool_t *p, const char *dirname);
+
+/* return the storage pool associated with a resource */
+apr_pool_t *dav_fs_pool(const dav_resource *resource);
+
+/* return the full pathname for a resource */
+const char *dav_fs_pathname(const dav_resource *resource);
+
+/* return the directory and filename for a resource */
+dav_error * dav_fs_dir_file_name(const dav_resource *resource,
+                                 const char **dirpath,
+                                 const char **fname);
+
+/* return the list of locknull members in this resource's directory */
+dav_error * dav_fs_get_locknull_members(const dav_resource *resource,
+                                        dav_buffer *pbuf);
+
+
+/* DBM functions used by the repository and locking providers */
+extern const dav_hooks_db dav_hooks_db_dbm;
+
+dav_error * dav_dbm_open_direct(apr_pool_t *p, const char *pathname, int ro,
+                                dav_db **pdb);
+void dav_dbm_get_statefiles(apr_pool_t *p, const char *fname,
+                            const char **state1, const char **state2);
+dav_error * dav_dbm_delete(dav_db *db, apr_datum_t key);
+dav_error * dav_dbm_store(dav_db *db, apr_datum_t key, apr_datum_t value);
+dav_error * dav_dbm_fetch(dav_db *db, apr_datum_t key, apr_datum_t *pvalue);
+void dav_dbm_freedatum(dav_db *db, apr_datum_t data);
+int dav_dbm_exists(dav_db *db, apr_datum_t key);
+void dav_dbm_close(dav_db *db);
+
+/* where is the lock database located? */
+const char *dav_get_lockdb_path(const request_rec *r);
+
+const dav_hooks_locks *dav_fs_get_lock_hooks(request_rec *r);
+const dav_hooks_propdb *dav_fs_get_propdb_hooks(request_rec *r);
+
+void dav_fs_gather_propsets(apr_array_header_t *uris);
+int dav_fs_find_liveprop(const dav_resource *resource,
+                         const char *ns_uri, const char *name,
+                         const dav_hooks_liveprop **hooks);
+void dav_fs_insert_all_liveprops(request_rec *r, const dav_resource *resource,
+                                 dav_prop_insert what, apr_text_header *phdr);
+
+void dav_fs_register(apr_pool_t *p);
+
+#endif /* _DAV_FS_REPOS_H_ */
+/** @} */
+
diff --git a/modules/dav/lock/Makefile.in b/modules/dav/lock/Makefile.in
new file mode 100644
index 0000000..7c5c149
--- /dev/null
+++ b/modules/dav/lock/Makefile.in
@@ -0,0 +1,3 @@
+# a modules Makefile has no explicit targets -- they will be defined by
+# whatever modules are enabled. just grab special.mk to deal with this.
+include $(top_srcdir)/build/special.mk
diff --git a/modules/dav/lock/NWGNUmakefile b/modules/dav/lock/NWGNUmakefile
new file mode 100644
index 0000000..b515d27
--- /dev/null
+++ b/modules/dav/lock/NWGNUmakefile
@@ -0,0 +1,259 @@
+#
+# Declare the sub-directories to be built here
+#
+
+SUBDIRS = \
+	$(EOLIST)
+
+#
+# Get the 'head' of the build environment.  This includes default targets and
+# paths to tools
+#
+
+include $(AP_WORK)/build/NWGNUhead.inc
+
+#
+# build this level's files
+
+#
+# Make sure all needed macro's are defined
+#
+
+#
+# These directories will be at the beginning of the include list, followed by
+# INCDIRS
+#
+XINCDIRS	+= \
+			$(APR)/include \
+			$(APRUTIL)/include \
+			$(AP_WORK)/include \
+			$(AP_WORK)/server/mpm/netware \
+			$(AP_WORK)/modules/dav/main \
+			$(NWOS) \
+			$(EOLIST)
+
+#
+# These flags will come after CFLAGS
+#
+XCFLAGS		+= \
+			$(EOLIST)
+
+#
+# These defines will come after DEFINES
+#
+XDEFINES	+= \
+			$(EOLIST)
+
+#
+# These flags will be added to the link.opt file
+#
+XLFLAGS		+= \
+			$(EOLIST)
+
+#
+# These values will be appended to the correct variables based on the value of
+# RELEASE
+#
+ifeq "$(RELEASE)" "debug"
+XINCDIRS	+= \
+			$(EOLIST)
+
+XCFLAGS		+= \
+			$(EOLIST)
+
+XDEFINES	+= \
+			$(EOLIST)
+
+XLFLAGS		+= \
+			$(EOLIST)
+endif
+
+ifeq "$(RELEASE)" "noopt"
+XINCDIRS	+= \
+			$(EOLIST)
+
+XCFLAGS		+= \
+			$(EOLIST)
+
+XDEFINES	+= \
+			$(EOLIST)
+
+XLFLAGS		+= \
+			$(EOLIST)
+endif
+
+ifeq "$(RELEASE)" "release"
+XINCDIRS	+= \
+			$(EOLIST)
+
+XCFLAGS		+= \
+			$(EOLIST)
+
+XDEFINES	+= \
+			$(EOLIST)
+
+XLFLAGS		+= \
+			$(EOLIST)
+endif
+
+#
+# These are used by the link target if an NLM is being generated
+# This is used by the link 'name' directive to name the nlm.  If left blank
+# TARGET_nlm (see below) will be used.
+#
+NLM_NAME	= moddavlk
+
+#
+# This is used by the link '-desc ' directive.
+# If left blank, NLM_NAME will be used.
+#
+NLM_DESCRIPTION	= Apache $(VERSION_STR) DAV Database Lock Sub-Module
+
+#
+# This is used by the '-threadname' directive.  If left blank,
+# NLM_NAME Thread will be used.
+#
+NLM_THREAD_NAME	= $(NLM_NAME) Thread
+
+#
+# If this is specified, it will override VERSION value in
+# $(AP_WORK)/build/NWGNUenvironment.inc
+#
+NLM_VERSION	=
+
+#
+# If this is specified, it will override the default of 64K
+#
+NLM_STACK_SIZE	= 65536
+
+
+#
+# If this is specified it will be used by the link '-entry' directive
+#
+NLM_ENTRY_SYM	=
+
+#
+# If this is specified it will be used by the link '-exit' directive
+#
+NLM_EXIT_SYM	=
+
+#
+# If this is specified it will be used by the link '-check' directive
+#
+NLM_CHECK_SYM	=
+
+#
+# If this is specified it will be used by the link '-flags' directive
+#
+NLM_FLAGS	=
+
+#
+# Declare all target files (you must add your files here)
+#
+
+#
+# If there is an NLM target, put it here
+#
+TARGET_nlm = \
+	$(OBJDIR)/$(NLM_NAME).nlm \
+	$(EOLIST)
+
+#
+# If there is an LIB target, put it here
+#
+TARGET_lib = \
+	$(EOLIST)
+
+#
+# These are the OBJ files needed to create the NLM target above.
+# Paths must all use the '/' character
+#
+FILES_nlm_objs = \
+	$(OBJDIR)/mod_dav_lock.o \
+	$(OBJDIR)/locks.o \
+	$(EOLIST)
+
+#
+# These are the LIB files needed to create the NLM target above.
+# These will be added as a library command in the link.opt file.
+#
+FILES_nlm_libs = \
+	$(PRELUDE) \
+	$(EOLIST)
+
+#
+# These are the modules that the above NLM target depends on to load.
+# These will be added as a module command in the link.opt file.
+#
+FILES_nlm_modules = \
+	Apache2 \
+	Libc \
+	mod_dav \
+	$(EOLIST)
+
+#
+# If the nlm has a msg file, put it's path here
+#
+FILE_nlm_msg =
+
+#
+# If the nlm has a hlp file put it's path here
+#
+FILE_nlm_hlp =
+
+#
+# If this is specified, it will override $(NWOS)\copyright.txt.
+#
+FILE_nlm_copyright =
+
+#
+# Any additional imports go here
+#
+FILES_nlm_Ximports = \
+	@libc.imp \
+	@aprlib.imp \
+	@httpd.imp \
+	@../main/dav.imp \
+	$(EOLIST)
+
+#
+# Any symbols exported to here
+#
+FILES_nlm_exports = \
+	dav_lock_module \
+	$(EOLIST)
+
+#
+# These are the OBJ files needed to create the LIB target above.
+# Paths must all use the '/' character
+#
+FILES_lib_objs = \
+	$(EOLIST)
+
+#
+# implement targets and dependancies (leave this section alone)
+#
+
+libs :: $(OBJDIR) $(TARGET_lib)
+
+nlms :: libs $(TARGET_nlm)
+
+#
+# Updated this target to create necessary directories and copy files to the
+# correct place.  (See $(AP_WORK)/build/NWGNUhead.inc for examples)
+#
+install :: nlms FORCE
+	$(call COPY,$(OBJDIR)/*.nlm, $(INSTALLBASE)/modules/)
+
+#
+# Any specialized rules here
+#
+
+#
+# Include the 'tail' makefile that has targets that depend on variables defined
+# in this makefile
+#
+
+include $(APBUILD)/NWGNUtail.inc
+
+
diff --git a/modules/dav/lock/config6.m4 b/modules/dav/lock/config6.m4
new file mode 100644
index 0000000..02a05e5
--- /dev/null
+++ b/modules/dav/lock/config6.m4
@@ -0,0 +1,17 @@
+dnl modules enabled in this directory by default
+
+APACHE_MODPATH_INIT(dav/lock)
+
+dav_lock_objects="mod_dav_lock.lo locks.lo"
+
+case "$host" in
+  *os2*)
+    # OS/2 DLLs must resolve all symbols at build time
+    # and we need some from main DAV module
+    dav_lock_objects="$dav_lock_objects ../main/mod_dav.la"
+    ;;
+esac
+
+APACHE_MODULE(dav_lock, DAV provider for generic locking, $dav_lock_objects, ,,,dav)
+
+APACHE_MODPATH_FINISH
diff --git a/modules/dav/lock/locks.c b/modules/dav/lock/locks.c
new file mode 100644
index 0000000..17b9ee6
--- /dev/null
+++ b/modules/dav/lock/locks.c
@@ -0,0 +1,1211 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Generic DAV lock implementation that a DAV provider can use.
+ */
+
+#include "apr.h"
+#include "apr_strings.h"
+#include "apr_file_io.h"
+#include "apr_uuid.h"
+
+#define APR_WANT_MEMFUNC
+#include "apr_want.h"
+
+#include "httpd.h"
+#include "http_log.h"
+
+#include "mod_dav.h"
+
+#include "locks.h"
+
+
+/* ---------------------------------------------------------------
+ *
+ * Lock database primitives
+ *
+ */
+
+/*
+ * LOCK DATABASES
+ *
+ * Lockdiscovery information is stored in the single lock database specified
+ * by the DAVGenericLockDB directive.  Information about this db is stored in
+ * the per-dir configuration.
+ *
+ * KEY
+ *
+ * The database is keyed by a key_type unsigned char (DAV_TYPE_FNAME)
+ * followed by full path.
+ *
+ * VALUE
+ *
+ * The value consists of a list of elements.
+ *    DIRECT LOCK:     [char      (DAV_LOCK_DIRECT),
+ *                      char      (dav_lock_scope),
+ *                      char      (dav_lock_type),
+ *                      int        depth,
+ *                      time_t     expires,
+ *                      apr_uuid_t locktoken,
+ *                      char[]     owner,
+ *                      char[]     auth_user]
+ *
+ *    INDIRECT LOCK:   [char      (DAV_LOCK_INDIRECT),
+ *                      apr_uuid_t locktoken,
+ *                      time_t     expires,
+ *                      int        key_size,
+ *                      char[]     key]
+ *       The key is to the collection lock that resulted in this indirect lock
+ */
+
+#define DAV_TRUE                    1
+#define DAV_FALSE                   0
+
+#define DAV_CREATE_LIST            23
+#define DAV_APPEND_LIST            24
+
+/* Stored lock_discovery prefix */
+#define DAV_LOCK_DIRECT             1
+#define DAV_LOCK_INDIRECT           2
+
+#define DAV_TYPE_FNAME             11
+
+/* Use the opaquelock scheme for locktokens */
+struct dav_locktoken {
+    apr_uuid_t uuid;
+};
+#define dav_compare_locktoken(plt1, plt2) \
+                memcmp(&(plt1)->uuid, &(plt2)->uuid, sizeof((plt1)->uuid))
+
+
+/* #################################################################
+ * ### keep these structures (internal) or move fully to dav_lock?
+ */
+
+/*
+ * We need to reliably size the fixed-length portion of
+ * dav_lock_discovery; best to separate it into another
+ * struct for a convenient sizeof, unless we pack lock_discovery.
+ */
+typedef struct dav_lock_discovery_fixed
+{
+    char scope;
+    char type;
+    int depth;
+    time_t timeout;
+} dav_lock_discovery_fixed;
+
+typedef struct dav_lock_discovery
+{
+    struct dav_lock_discovery_fixed f;
+
+    dav_locktoken *locktoken;
+    const char *owner;     /* owner field from activelock */
+    const char *auth_user; /* authenticated user who created the lock */
+    struct dav_lock_discovery *next;
+} dav_lock_discovery;
+
+/* Indirect locks represent locks inherited from containing collections.
+ * They reference the lock token for the collection the lock is
+ * inherited from. A lock provider may also define a key to the
+ * inherited lock, for fast datbase lookup. The key is opaque outside
+ * the lock provider.
+ */
+typedef struct dav_lock_indirect
+{
+    dav_locktoken *locktoken;
+    apr_datum_t key;
+    struct dav_lock_indirect *next;
+    time_t timeout;
+} dav_lock_indirect;
+
+/* ################################################################# */
+
+/*
+ * Stored direct lock info - full lock_discovery length:
+ * prefix + Fixed length + lock token + 2 strings + 2 nulls (one for each
+ * string)
+ */
+#define dav_size_direct(a)  (1 + sizeof(dav_lock_discovery_fixed) \
+                               + sizeof(apr_uuid_t) \
+                               + ((a)->owner ? strlen((a)->owner) : 0) \
+                               + ((a)->auth_user ? strlen((a)->auth_user) : 0) \
+                               + 2)
+
+/* Stored indirect lock info - lock token and apr_datum_t */
+#define dav_size_indirect(a) (1 + sizeof(apr_uuid_t) \
+                                + sizeof(time_t) \
+                                + sizeof(int) + (a)->key.dsize)
+
+/*
+ * The lockdb structure.
+ *
+ * The <db> field may be NULL, meaning one of two things:
+ * 1) That we have not actually opened the underlying database (yet). The
+ *    <opened> field should be false.
+ * 2) We opened it readonly and it wasn't present.
+ *
+ * The delayed opening (determined by <opened>) makes creating a lockdb
+ * quick, while deferring the underlying I/O until it is actually required.
+ *
+ * We export the notion of a lockdb, but hide the details of it. Most
+ * implementations will use a database of some kind, but it is certainly
+ * possible that alternatives could be used.
+ */
+struct dav_lockdb_private
+{
+    request_rec *r; /* for accessing the uuid state */
+    apr_pool_t *pool; /* a pool to use */
+    const char *lockdb_path; /* where is the lock database? */
+
+    int opened; /* we opened the database */
+    apr_dbm_t *db; /* if non-NULL, the lock database */
+};
+
+typedef struct
+{
+    dav_lockdb pub;
+    dav_lockdb_private priv;
+} dav_lockdb_combined;
+
+/*
+ * The private part of the lock structure.
+ */
+struct dav_lock_private
+{
+    apr_datum_t key;        /* key into the lock database */
+};
+typedef struct
+{
+    dav_lock pub;
+    dav_lock_private priv;
+    dav_locktoken token;
+} dav_lock_combined;
+
+/*
+ * This must be forward-declared so the open_lockdb function can use it.
+ */
+extern const dav_hooks_locks dav_hooks_locks_generic;
+
+static dav_error * dav_generic_dbm_new_error(apr_dbm_t *db, apr_pool_t *p,
+                                             apr_status_t status)
+{
+    int errcode;
+    const char *errstr;
+    dav_error *err;
+    char errbuf[200];
+
+    if (status == APR_SUCCESS) {
+        return NULL;
+    }
+
+    /* There might not be a <db> if we had problems creating it. */
+    if (db == NULL) {
+        errcode = 1;
+        errstr = "Could not open property database.";
+    }
+    else {
+        (void) apr_dbm_geterror(db, &errcode, errbuf, sizeof(errbuf));
+        errstr = apr_pstrdup(p, errbuf);
+    }
+
+    err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, errcode, status, errstr);
+    return err;
+}
+
+/* internal function for creating locks */
+static dav_lock *dav_generic_alloc_lock(dav_lockdb *lockdb, apr_datum_t key,
+                                        const dav_locktoken *locktoken)
+{
+    dav_lock_combined *comb;
+
+    comb = apr_pcalloc(lockdb->info->pool, sizeof(*comb));
+    comb->pub.rectype = DAV_LOCKREC_DIRECT;
+    comb->pub.info = &comb->priv;
+    comb->priv.key = key;
+
+    if (locktoken == NULL) {
+        comb->pub.locktoken = &comb->token;
+        apr_uuid_get(&comb->token.uuid);
+    }
+    else {
+        comb->pub.locktoken = locktoken;
+    }
+
+    return &comb->pub;
+}
+
+/*
+ * dav_generic_parse_locktoken
+ *
+ * Parse an opaquelocktoken URI into a locktoken.
+ */
+static dav_error * dav_generic_parse_locktoken(apr_pool_t *p,
+                                               const char *char_token,
+                                               dav_locktoken **locktoken_p)
+{
+    dav_locktoken *locktoken;
+
+    if (ap_strstr_c(char_token, "opaquelocktoken:") != char_token) {
+        return dav_new_error(p,
+                             HTTP_BAD_REQUEST, DAV_ERR_LOCK_UNK_STATE_TOKEN, 0,
+                             "The lock token uses an unknown State-token "
+                             "format and could not be parsed.");
+    }
+    char_token += 16;
+
+    locktoken = apr_pcalloc(p, sizeof(*locktoken));
+    if (apr_uuid_parse(&locktoken->uuid, char_token)) {
+        return dav_new_error(p, HTTP_BAD_REQUEST, DAV_ERR_LOCK_PARSE_TOKEN, 0,
+                             "The opaquelocktoken has an incorrect format "
+                             "and could not be parsed.");
+    }
+
+    *locktoken_p = locktoken;
+    return NULL;
+}
+
+/*
+ * dav_generic_format_locktoken
+ *
+ * Generate the URI for a locktoken
+ */
+static const char *dav_generic_format_locktoken(apr_pool_t *p,
+                                                const dav_locktoken *locktoken)
+{
+    char buf[APR_UUID_FORMATTED_LENGTH + 1];
+
+    apr_uuid_format(buf, &locktoken->uuid);
+    return apr_pstrcat(p, "opaquelocktoken:", buf, NULL);
+}
+
+/*
+ * dav_generic_compare_locktoken
+ *
+ * Determine whether two locktokens are the same
+ */
+static int dav_generic_compare_locktoken(const dav_locktoken *lt1,
+                                         const dav_locktoken *lt2)
+{
+    return dav_compare_locktoken(lt1, lt2);
+}
+
+/*
+ * dav_generic_really_open_lockdb:
+ *
+ * If the database hasn't been opened yet, then open the thing.
+ */
+static dav_error * dav_generic_really_open_lockdb(dav_lockdb *lockdb)
+{
+    dav_error *err;
+    apr_status_t status;
+
+    if (lockdb->info->opened) {
+        return NULL;
+    }
+
+    status = apr_dbm_open(&lockdb->info->db, lockdb->info->lockdb_path,
+                          lockdb->ro ? APR_DBM_READONLY : APR_DBM_RWCREATE,
+                          APR_OS_DEFAULT, lockdb->info->pool);
+
+    if (status) {
+        err = dav_generic_dbm_new_error(lockdb->info->db, lockdb->info->pool,
+                                        status);
+        return dav_push_error(lockdb->info->pool,
+                              HTTP_INTERNAL_SERVER_ERROR,
+                              DAV_ERR_LOCK_OPENDB,
+                              "Could not open the lock database.",
+                              err);
+    }
+
+    /* all right. it is opened now. */
+    lockdb->info->opened = 1;
+
+    return NULL;
+}
+
+/*
+ * dav_generic_open_lockdb:
+ *
+ * "open" the lock database, as specified in the global server configuration.
+ * If force is TRUE, then the database is opened now, rather than lazily.
+ *
+ * Note that only one can be open read/write.
+ */
+static dav_error * dav_generic_open_lockdb(request_rec *r, int ro, int force,
+                                           dav_lockdb **lockdb)
+{
+    dav_lockdb_combined *comb;
+
+    comb = apr_pcalloc(r->pool, sizeof(*comb));
+    comb->pub.hooks = &dav_hooks_locks_generic;
+    comb->pub.ro = ro;
+    comb->pub.info = &comb->priv;
+    comb->priv.r = r;
+    comb->priv.pool = r->pool;
+
+    comb->priv.lockdb_path = dav_generic_get_lockdb_path(r);
+    if (comb->priv.lockdb_path == NULL) {
+        return dav_new_error(r->pool, HTTP_INTERNAL_SERVER_ERROR,
+                             DAV_ERR_LOCK_NO_DB, 0,
+                             "A lock database was not specified with the "
+                             "DAVGenericLockDB directive. One must be "
+                             "specified to use the locking functionality.");
+    }
+
+    /* done initializing. return it. */
+    *lockdb = &comb->pub;
+
+    if (force) {
+        /* ### add a higher-level comment? */
+        return dav_generic_really_open_lockdb(*lockdb);
+    }
+
+    return NULL;
+}
+
+/*
+ * dav_generic_close_lockdb:
+ *
+ * Close it. Duh.
+ */
+static void dav_generic_close_lockdb(dav_lockdb *lockdb)
+{
+    if (lockdb->info->db != NULL) {
+        apr_dbm_close(lockdb->info->db);
+    }
+    lockdb->info->opened = 0;
+}
+
+/*
+ * dav_generic_build_key
+ *
+ * Given a pathname, build a DAV_TYPE_FNAME lock database key.
+ */
+static apr_datum_t dav_generic_build_key(apr_pool_t *p,
+                                         const dav_resource *resource)
+{
+    apr_datum_t key;
+    const char *pathname = resource->uri;
+
+    /* ### does this allocation have a proper lifetime? need to check */
+    /* ### can we use a buffer for this? */
+
+    /* size is TYPE + pathname + null */
+    key.dsize = strlen(pathname) + 2;
+    key.dptr = apr_palloc(p, key.dsize);
+    *key.dptr = DAV_TYPE_FNAME;
+    memcpy(key.dptr + 1, pathname, key.dsize - 1);
+    if (key.dptr[key.dsize - 2] == '/')
+        key.dptr[--key.dsize - 1] = '\0';
+    return key;
+}
+
+/*
+ * dav_generic_lock_expired:  return 1 (true) if the given timeout is in the
+ *    past or present (the lock has expired), or 0 (false) if in the future
+ *    (the lock has not yet expired).
+ */
+static int dav_generic_lock_expired(time_t expires)
+{
+    return expires != DAV_TIMEOUT_INFINITE && time(NULL) >= expires;
+}
+
+/*
+ * dav_generic_save_lock_record:  Saves the lock information specified in the
+ *    direct and indirect lock lists about path into the lock database.
+ *    If direct and indirect == NULL, the key is removed.
+ */
+static dav_error * dav_generic_save_lock_record(dav_lockdb *lockdb,
+                                                apr_datum_t key,
+                                                dav_lock_discovery *direct,
+                                                dav_lock_indirect *indirect)
+{
+    dav_error *err;
+    apr_status_t status;
+    apr_datum_t val = { 0 };
+    char *ptr;
+    dav_lock_discovery *dp = direct;
+    dav_lock_indirect *ip = indirect;
+
+#if DAV_DEBUG
+    if (lockdb->ro) {
+        return dav_new_error(lockdb->info->pool,
+                             HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                             "INTERNAL DESIGN ERROR: the lockdb was opened "
+                             "readonly, but an attempt to save locks was "
+                             "performed.");
+    }
+#endif
+
+    if ((err = dav_generic_really_open_lockdb(lockdb)) != NULL) {
+        /* ### add a higher-level error? */
+        return err;
+    }
+
+    /* If nothing to save, delete key */
+    if (dp == NULL && ip == NULL) {
+        /* don't fail if the key is not present */
+        /* ### but what about other errors? */
+        apr_dbm_delete(lockdb->info->db, key);
+        return NULL;
+    }
+
+    while (dp) {
+        val.dsize += dav_size_direct(dp);
+        dp = dp->next;
+    }
+    while (ip) {
+        val.dsize += dav_size_indirect(ip);
+        ip = ip->next;
+    }
+
+    /* ### can this be apr_palloc() ? */
+    /* ### hmmm.... investigate the use of a buffer here */
+    ptr = val.dptr = apr_pcalloc(lockdb->info->pool, val.dsize);
+    dp  = direct;
+    ip  = indirect;
+
+    while (dp) {
+        /* Direct lock - lock_discovery struct follows */
+        *ptr++ = DAV_LOCK_DIRECT;
+        memcpy(ptr, dp, sizeof(dp->f));        /* Fixed portion of struct */
+        ptr += sizeof(dp->f);
+        memcpy(ptr, dp->locktoken, sizeof(*dp->locktoken));
+        ptr += sizeof(*dp->locktoken);
+        if (dp->owner == NULL) {
+            *ptr++ = '\0';
+        }
+        else {
+            memcpy(ptr, dp->owner, strlen(dp->owner) + 1);
+            ptr += strlen(dp->owner) + 1;
+        }
+        if (dp->auth_user == NULL) {
+            *ptr++ = '\0';
+        }
+        else {
+            memcpy(ptr, dp->auth_user, strlen(dp->auth_user) + 1);
+            ptr += strlen(dp->auth_user) + 1;
+        }
+
+        dp = dp->next;
+    }
+
+    while (ip) {
+        /* Indirect lock prefix */
+        *ptr++ = DAV_LOCK_INDIRECT;
+
+        memcpy(ptr, ip->locktoken, sizeof(*ip->locktoken));
+        ptr += sizeof(*ip->locktoken);
+
+        memcpy(ptr, &ip->timeout, sizeof(ip->timeout));
+        ptr += sizeof(ip->timeout);
+
+        memcpy(ptr, &ip->key.dsize, sizeof(ip->key.dsize));
+        ptr += sizeof(ip->key.dsize);
+
+        memcpy(ptr, ip->key.dptr, ip->key.dsize);
+        ptr += ip->key.dsize;
+
+        ip = ip->next;
+    }
+
+    if ((status = apr_dbm_store(lockdb->info->db, key, val)) != APR_SUCCESS) {
+        /* ### more details? add an error_id? */
+        err = dav_generic_dbm_new_error(lockdb->info->db, lockdb->info->pool,
+                                        status);
+        return dav_push_error(lockdb->info->pool,
+                              HTTP_INTERNAL_SERVER_ERROR,
+                              DAV_ERR_LOCK_SAVE_LOCK,
+                              "Could not save lock information.",
+                              err);
+    }
+
+    return NULL;
+}
+
+/*
+ * dav_load_lock_record:  Reads lock information about key from lock db;
+ *    creates linked lists of the direct and indirect locks.
+ *
+ *    If add_method = DAV_APPEND_LIST, the result will be appended to the
+ *    head of the direct and indirect lists supplied.
+ *
+ *    Passive lock removal:  If lock has timed out, it will not be returned.
+ *    ### How much "logging" does RFC 2518 require?
+ */
+static dav_error * dav_generic_load_lock_record(dav_lockdb *lockdb,
+                                                apr_datum_t key,
+                                                int add_method,
+                                                dav_lock_discovery **direct,
+                                                dav_lock_indirect **indirect)
+{
+    apr_pool_t *p = lockdb->info->pool;
+    dav_error *err;
+    apr_status_t status;
+    apr_size_t offset = 0;
+    int need_save = DAV_FALSE;
+    apr_datum_t val = { 0 };
+    dav_lock_discovery *dp;
+    dav_lock_indirect *ip;
+
+    if (add_method != DAV_APPEND_LIST) {
+        *direct = NULL;
+        *indirect = NULL;
+    }
+
+    if ((err = dav_generic_really_open_lockdb(lockdb)) != NULL) {
+        /* ### add a higher-level error? */
+        return err;
+    }
+
+    /*
+     * If we opened readonly and the db wasn't there, then there are no
+     * locks for this resource. Just exit.
+     */
+    if (lockdb->info->db == NULL) {
+        return NULL;
+    }
+
+    if ((status = apr_dbm_fetch(lockdb->info->db, key, &val)) != APR_SUCCESS) {
+        return dav_generic_dbm_new_error(lockdb->info->db, p, status);
+    }
+
+    if (!val.dsize) {
+        return NULL;
+    }
+
+    while (offset < val.dsize) {
+        switch (*(val.dptr + offset++)) {
+        case DAV_LOCK_DIRECT:
+            /* Create and fill a dav_lock_discovery structure */
+
+            dp = apr_pcalloc(p, sizeof(*dp));
+
+            /* Copy the dav_lock_discovery_fixed portion */
+            memcpy(dp, val.dptr + offset, sizeof(dp->f));
+            offset += sizeof(dp->f);
+
+            /* Copy the lock token. */
+            dp->locktoken = apr_pmemdup(p, val.dptr + offset, sizeof(*dp->locktoken));
+            offset += sizeof(*dp->locktoken);
+
+            /* Do we have an owner field? */
+            if (*(val.dptr + offset) == '\0') {
+                ++offset;
+            }
+            else {
+                apr_size_t len = strlen(val.dptr + offset);
+                dp->owner = apr_pstrmemdup(p, val.dptr + offset, len);
+                offset += len + 1;
+            }
+
+            if (*(val.dptr + offset) == '\0') {
+                ++offset;
+            }
+            else {
+                apr_size_t len = strlen(val.dptr + offset);
+                dp->auth_user = apr_pstrmemdup(p, val.dptr + offset, len);
+                offset += len + 1;
+            }
+
+            if (!dav_generic_lock_expired(dp->f.timeout)) {
+                dp->next = *direct;
+                *direct = dp;
+            }
+            else {
+                need_save = DAV_TRUE;
+            }
+            break;
+
+        case DAV_LOCK_INDIRECT:
+            /* Create and fill a dav_lock_indirect structure */
+
+            ip = apr_pcalloc(p, sizeof(*ip));
+            ip->locktoken = apr_pmemdup(p, val.dptr + offset, sizeof(*ip->locktoken));
+            offset += sizeof(*ip->locktoken);
+            memcpy(&ip->timeout, val.dptr + offset, sizeof(ip->timeout));
+            offset += sizeof(ip->timeout);
+            /* length of datum */
+            ip->key.dsize = *((int *) (val.dptr + offset));
+            offset += sizeof(ip->key.dsize);
+            ip->key.dptr = apr_pmemdup(p, val.dptr + offset, ip->key.dsize);
+            offset += ip->key.dsize;
+
+            if (!dav_generic_lock_expired(ip->timeout)) {
+                ip->next = *indirect;
+                *indirect = ip;
+            }
+            else {
+                need_save = DAV_TRUE;
+            }
+
+            break;
+
+        default:
+            apr_dbm_freedatum(lockdb->info->db, val);
+
+            /* ### should use a computed_desc and insert corrupt token data */
+            --offset;
+            return dav_new_error(p,
+                                 HTTP_INTERNAL_SERVER_ERROR,
+                                 DAV_ERR_LOCK_CORRUPT_DB, 0,
+                                 apr_psprintf(p,
+                                             "The lock database was found to "
+                                             "be corrupt. offset %"
+                                             APR_SIZE_T_FMT ", c=%02x",
+                                             offset, val.dptr[offset]));
+        }
+    }
+
+    apr_dbm_freedatum(lockdb->info->db, val);
+
+    /* Clean up this record if we found expired locks */
+    /*
+     * ### shouldn't do this if we've been opened READONLY. elide the
+     * ### timed-out locks from the response, but don't save that info back
+     */
+    if (need_save == DAV_TRUE) {
+        return dav_generic_save_lock_record(lockdb, key, *direct, *indirect);
+    }
+
+    return NULL;
+}
+
+/* resolve <indirect>, returning <*direct> */
+static dav_error * dav_generic_resolve(dav_lockdb *lockdb,
+                                       dav_lock_indirect *indirect,
+                                       dav_lock_discovery **direct,
+                                       dav_lock_discovery **ref_dp,
+                                       dav_lock_indirect **ref_ip)
+{
+    dav_error *err;
+    dav_lock_discovery *dir;
+    dav_lock_indirect *ind;
+
+    if ((err = dav_generic_load_lock_record(lockdb, indirect->key,
+                                       DAV_CREATE_LIST,
+                                       &dir, &ind)) != NULL) {
+        /* ### insert a higher-level description? */
+        return err;
+    }
+    if (ref_dp != NULL) {
+        *ref_dp = dir;
+        *ref_ip = ind;
+    }
+
+    for (; dir != NULL; dir = dir->next) {
+        if (!dav_compare_locktoken(indirect->locktoken, dir->locktoken)) {
+            *direct = dir;
+            return NULL;
+        }
+    }
+
+    /* No match found (but we should have found one!) */
+
+    /* ### use a different description and/or error ID? */
+    return dav_new_error(lockdb->info->pool,
+                         HTTP_INTERNAL_SERVER_ERROR,
+                         DAV_ERR_LOCK_CORRUPT_DB, 0,
+                         "The lock database was found to be corrupt. "
+                         "An indirect lock's direct lock could not "
+                         "be found.");
+}
+
+/* ---------------------------------------------------------------
+ *
+ * Property-related lock functions
+ *
+ */
+
+/*
+ * dav_generic_get_supportedlock:  Returns a static string for all
+ *    supportedlock properties. I think we save more returning a static string
+ *    than constructing it every time, though it might look cleaner.
+ */
+static const char *dav_generic_get_supportedlock(const dav_resource *resource)
+{
+    static const char supported[] = DEBUG_CR
+        "<D:lockentry>" DEBUG_CR
+        "<D:lockscope><D:exclusive/></D:lockscope>" DEBUG_CR
+        "<D:locktype><D:write/></D:locktype>" DEBUG_CR
+        "</D:lockentry>" DEBUG_CR
+        "<D:lockentry>" DEBUG_CR
+        "<D:lockscope><D:shared/></D:lockscope>" DEBUG_CR
+        "<D:locktype><D:write/></D:locktype>" DEBUG_CR
+        "</D:lockentry>" DEBUG_CR;
+
+    return supported;
+}
+
+/* ---------------------------------------------------------------
+ *
+ * General lock functions
+ *
+ */
+
+static dav_error * dav_generic_remove_locknull_state(dav_lockdb *lockdb,
+                                                 const dav_resource *resource)
+{
+    /* We don't need to do anything. */
+    return NULL;
+}
+
+static dav_error * dav_generic_create_lock(dav_lockdb *lockdb,
+                                      const dav_resource *resource,
+                                      dav_lock **lock)
+{
+    apr_datum_t key;
+
+    key = dav_generic_build_key(lockdb->info->pool, resource);
+
+    *lock = dav_generic_alloc_lock(lockdb, key, NULL);
+
+    (*lock)->is_locknull = !resource->exists;
+
+    return NULL;
+}
+
+static dav_error * dav_generic_get_locks(dav_lockdb *lockdb,
+                                         const dav_resource *resource,
+                                         int calltype,
+                                         dav_lock **locks)
+{
+    apr_pool_t *p = lockdb->info->pool;
+    apr_datum_t key;
+    dav_error *err;
+    dav_lock *lock = NULL;
+    dav_lock *newlock;
+    dav_lock_discovery *dp;
+    dav_lock_indirect *ip;
+
+#if DAV_DEBUG
+    if (calltype == DAV_GETLOCKS_COMPLETE) {
+        return dav_new_error(lockdb->info->pool,
+                             HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                             "INTERNAL DESIGN ERROR: DAV_GETLOCKS_COMPLETE "
+                             "is not yet supported");
+    }
+#endif
+
+    key = dav_generic_build_key(p, resource);
+    if ((err = dav_generic_load_lock_record(lockdb, key, DAV_CREATE_LIST,
+                                            &dp, &ip)) != NULL) {
+        /* ### push a higher-level desc? */
+        return err;
+    }
+
+    /* copy all direct locks to the result list */
+    for (; dp != NULL; dp = dp->next) {
+        newlock = dav_generic_alloc_lock(lockdb, key, dp->locktoken);
+        newlock->is_locknull = !resource->exists;
+        newlock->scope = dp->f.scope;
+        newlock->type = dp->f.type;
+        newlock->depth = dp->f.depth;
+        newlock->timeout = dp->f.timeout;
+        newlock->owner = dp->owner;
+        newlock->auth_user = dp->auth_user;
+
+        /* hook into the result list */
+        newlock->next = lock;
+        lock = newlock;
+    }
+
+    /* copy all the indirect locks to the result list. resolve as needed. */
+    for (; ip != NULL; ip = ip->next) {
+        newlock = dav_generic_alloc_lock(lockdb, ip->key, ip->locktoken);
+        newlock->is_locknull = !resource->exists;
+
+        if (calltype == DAV_GETLOCKS_RESOLVED) {
+            err = dav_generic_resolve(lockdb, ip, &dp, NULL, NULL);
+            if (err != NULL) {
+                /* ### push a higher-level desc? */
+                return err;
+            }
+
+            newlock->scope = dp->f.scope;
+            newlock->type = dp->f.type;
+            newlock->depth = dp->f.depth;
+            newlock->timeout = dp->f.timeout;
+            newlock->owner = dp->owner;
+            newlock->auth_user = dp->auth_user;
+        }
+        else {
+            /* DAV_GETLOCKS_PARTIAL */
+            newlock->rectype = DAV_LOCKREC_INDIRECT_PARTIAL;
+        }
+
+        /* hook into the result list */
+        newlock->next = lock;
+        lock = newlock;
+    }
+
+    *locks = lock;
+    return NULL;
+}
+
+static dav_error * dav_generic_find_lock(dav_lockdb *lockdb,
+                                         const dav_resource *resource,
+                                         const dav_locktoken *locktoken,
+                                         int partial_ok,
+                                         dav_lock **lock)
+{
+    dav_error *err;
+    apr_datum_t key;
+    dav_lock_discovery *dp;
+    dav_lock_indirect *ip;
+
+    *lock = NULL;
+
+    key = dav_generic_build_key(lockdb->info->pool, resource);
+    if ((err = dav_generic_load_lock_record(lockdb, key, DAV_CREATE_LIST,
+                                       &dp, &ip)) != NULL) {
+        /* ### push a higher-level desc? */
+        return err;
+    }
+
+    for (; dp != NULL; dp = dp->next) {
+        if (!dav_compare_locktoken(locktoken, dp->locktoken)) {
+            *lock = dav_generic_alloc_lock(lockdb, key, locktoken);
+            (*lock)->is_locknull = !resource->exists;
+            (*lock)->scope = dp->f.scope;
+            (*lock)->type = dp->f.type;
+            (*lock)->depth = dp->f.depth;
+            (*lock)->timeout = dp->f.timeout;
+            (*lock)->owner = dp->owner;
+            (*lock)->auth_user = dp->auth_user;
+            return NULL;
+        }
+    }
+
+    for (; ip != NULL; ip = ip->next) {
+        if (!dav_compare_locktoken(locktoken, ip->locktoken)) {
+            *lock = dav_generic_alloc_lock(lockdb, ip->key, locktoken);
+            (*lock)->is_locknull = !resource->exists;
+
+            /* ### nobody uses the resolving right now! */
+            if (partial_ok) {
+                (*lock)->rectype = DAV_LOCKREC_INDIRECT_PARTIAL;
+            }
+            else {
+                (*lock)->rectype = DAV_LOCKREC_INDIRECT;
+                if ((err = dav_generic_resolve(lockdb, ip, &dp,
+                                          NULL, NULL)) != NULL) {
+                    /* ### push a higher-level desc? */
+                    return err;
+                }
+                (*lock)->scope = dp->f.scope;
+                (*lock)->type = dp->f.type;
+                (*lock)->depth = dp->f.depth;
+                (*lock)->timeout = dp->f.timeout;
+                (*lock)->owner = dp->owner;
+                (*lock)->auth_user = dp->auth_user;
+            }
+            return NULL;
+        }
+    }
+
+    return NULL;
+}
+
+static dav_error * dav_generic_has_locks(dav_lockdb *lockdb,
+                                         const dav_resource *resource,
+                                         int *locks_present)
+{
+    dav_error *err;
+    apr_datum_t key;
+
+    *locks_present = 0;
+
+    if ((err = dav_generic_really_open_lockdb(lockdb)) != NULL) {
+        /* ### insert a higher-level error description */
+        return err;
+    }
+
+    /*
+     * If we opened readonly and the db wasn't there, then there are no
+     * locks for this resource. Just exit.
+     */
+    if (lockdb->info->db == NULL)
+        return NULL;
+
+    key = dav_generic_build_key(lockdb->info->pool, resource);
+
+    *locks_present = apr_dbm_exists(lockdb->info->db, key);
+
+    return NULL;
+}
+
+static dav_error * dav_generic_append_locks(dav_lockdb *lockdb,
+                                            const dav_resource *resource,
+                                            int make_indirect,
+                                            const dav_lock *lock)
+{
+    apr_pool_t *p = lockdb->info->pool;
+    dav_error *err;
+    dav_lock_indirect *ip;
+    dav_lock_discovery *dp;
+    apr_datum_t key;
+
+    key = dav_generic_build_key(lockdb->info->pool, resource);
+
+    err = dav_generic_load_lock_record(lockdb, key, 0, &dp, &ip);
+    if (err != NULL) {
+        /* ### maybe add in a higher-level description */
+        return err;
+    }
+
+    /*
+     * ### when we store the lock more directly, we need to update
+     * ### lock->rectype and lock->is_locknull
+     */
+
+    if (make_indirect) {
+        for (; lock != NULL; lock = lock->next) {
+
+            /* ### this works for any <lock> rectype */
+            dav_lock_indirect *newi = apr_pcalloc(p, sizeof(*newi));
+
+            /* ### shut off the const warning for now */
+            newi->locktoken = (dav_locktoken *)lock->locktoken;
+            newi->timeout   = lock->timeout;
+            newi->key       = lock->info->key;
+            newi->next      = ip;
+            ip              = newi;
+        }
+    }
+    else {
+        for (; lock != NULL; lock = lock->next) {
+            /* create and link in the right kind of lock */
+
+            if (lock->rectype == DAV_LOCKREC_DIRECT) {
+                dav_lock_discovery *newd = apr_pcalloc(p, sizeof(*newd));
+
+                newd->f.scope = lock->scope;
+                newd->f.type = lock->type;
+                newd->f.depth = lock->depth;
+                newd->f.timeout = lock->timeout;
+                /* ### shut off the const warning for now */
+                newd->locktoken = (dav_locktoken *)lock->locktoken;
+                newd->owner = lock->owner;
+                newd->auth_user = lock->auth_user;
+                newd->next = dp;
+                dp = newd;
+            }
+            else {
+                /* DAV_LOCKREC_INDIRECT(_PARTIAL) */
+
+                dav_lock_indirect *newi = apr_pcalloc(p, sizeof(*newi));
+
+                /* ### shut off the const warning for now */
+                newi->locktoken = (dav_locktoken *)lock->locktoken;
+                newi->key       = lock->info->key;
+                newi->next      = ip;
+                ip              = newi;
+            }
+        }
+    }
+
+    if ((err = dav_generic_save_lock_record(lockdb, key, dp, ip)) != NULL) {
+        /* ### maybe add a higher-level description */
+        return err;
+    }
+
+    return NULL;
+}
+
+static dav_error * dav_generic_remove_lock(dav_lockdb *lockdb,
+                                           const dav_resource *resource,
+                                           const dav_locktoken *locktoken)
+{
+    dav_error *err;
+    dav_lock_discovery *dh = NULL;
+    dav_lock_indirect *ih = NULL;
+    apr_datum_t key;
+
+    key = dav_generic_build_key(lockdb->info->pool, resource);
+
+    if (locktoken != NULL) {
+        dav_lock_discovery *dp;
+        dav_lock_discovery *dprev = NULL;
+        dav_lock_indirect *ip;
+        dav_lock_indirect *iprev = NULL;
+
+        if ((err = dav_generic_load_lock_record(lockdb, key, DAV_CREATE_LIST,
+                                           &dh, &ih)) != NULL) {
+            /* ### maybe add a higher-level description */
+            return err;
+        }
+
+        for (dp = dh; dp != NULL; dp = dp->next) {
+            if (dav_compare_locktoken(locktoken, dp->locktoken) == 0) {
+                if (dprev)
+                    dprev->next = dp->next;
+                else
+                    dh = dh->next;
+            }
+            dprev = dp;
+        }
+
+        for (ip = ih; ip != NULL; ip = ip->next) {
+            if (dav_compare_locktoken(locktoken, ip->locktoken) == 0) {
+                if (iprev)
+                    iprev->next = ip->next;
+                else
+                    ih = ih->next;
+            }
+            iprev = ip;
+        }
+
+    }
+
+    /* save the modified locks, or remove all locks (dh=ih=NULL). */
+    if ((err = dav_generic_save_lock_record(lockdb, key, dh, ih)) != NULL) {
+        /* ### maybe add a higher-level description */
+        return err;
+    }
+
+    return NULL;
+}
+
+static int dav_generic_do_refresh(dav_lock_discovery *dp,
+                                  const dav_locktoken_list *ltl,
+                                  time_t new_time)
+{
+    int dirty = 0;
+
+    for (; ltl != NULL; ltl = ltl->next) {
+        if (dav_compare_locktoken(dp->locktoken, ltl->locktoken) == 0)
+        {
+            dp->f.timeout = new_time;
+            dirty = 1;
+            break;
+        }
+    }
+
+    return dirty;
+}
+
+static dav_error * dav_generic_refresh_locks(dav_lockdb *lockdb,
+                                             const dav_resource *resource,
+                                             const dav_locktoken_list *ltl,
+                                             time_t new_time,
+                                             dav_lock **locks)
+{
+    dav_error *err;
+    apr_datum_t key;
+    dav_lock_discovery *dp;
+    dav_lock_discovery *dp_scan;
+    dav_lock_indirect *ip;
+    int dirty = 0;
+    dav_lock *newlock;
+
+    *locks = NULL;
+
+    key = dav_generic_build_key(lockdb->info->pool, resource);
+    if ((err = dav_generic_load_lock_record(lockdb, key, DAV_CREATE_LIST,
+                                            &dp, &ip)) != NULL) {
+        /* ### maybe add in a higher-level description */
+        return err;
+    }
+
+    /* ### we should be refreshing direct AND (resolved) indirect locks! */
+
+    /* refresh all of the direct locks on this resource */
+    for (dp_scan = dp; dp_scan != NULL; dp_scan = dp_scan->next) {
+        if (dav_generic_do_refresh(dp_scan, ltl, new_time)) {
+            /* the lock was refreshed. return the lock. */
+            newlock = dav_generic_alloc_lock(lockdb, key, dp_scan->locktoken);
+            newlock->is_locknull = !resource->exists;
+            newlock->scope = dp_scan->f.scope;
+            newlock->type = dp_scan->f.type;
+            newlock->depth = dp_scan->f.depth;
+            newlock->timeout = dp_scan->f.timeout;
+            newlock->owner = dp_scan->owner;
+            newlock->auth_user = dp_scan->auth_user;
+
+            newlock->next = *locks;
+            *locks = newlock;
+
+            dirty = 1;
+        }
+    }
+
+    /* if we refreshed any locks, then save them back. */
+    if (dirty
+        && (err = dav_generic_save_lock_record(lockdb, key, dp, ip)) != NULL) {
+        /* ### maybe add in a higher-level description */
+        return err;
+    }
+
+    /* for each indirect lock, find its direct lock and refresh it. */
+    for (; ip != NULL; ip = ip->next) {
+        dav_lock_discovery *ref_dp;
+        dav_lock_indirect *ref_ip;
+
+        if ((err = dav_generic_resolve(lockdb, ip, &dp_scan,
+                                       &ref_dp, &ref_ip)) != NULL) {
+            /* ### push a higher-level desc? */
+            return err;
+        }
+        if (dav_generic_do_refresh(dp_scan, ltl, new_time)) {
+            /* the lock was refreshed. return the lock. */
+            newlock = dav_generic_alloc_lock(lockdb, ip->key, dp->locktoken);
+            newlock->is_locknull = !resource->exists;
+            newlock->scope = dp->f.scope;
+            newlock->type = dp->f.type;
+            newlock->depth = dp->f.depth;
+            newlock->timeout = dp->f.timeout;
+            newlock->owner = dp->owner;
+            newlock->auth_user = dp_scan->auth_user;
+
+            newlock->next = *locks;
+            *locks = newlock;
+
+            /* save the (resolved) direct lock back */
+            if ((err = dav_generic_save_lock_record(lockdb, ip->key, ref_dp,
+                                                    ref_ip)) != NULL) {
+                /* ### push a higher-level desc? */
+                return err;
+            }
+        }
+    }
+
+    return NULL;
+}
+
+
+const dav_hooks_locks dav_hooks_locks_generic =
+{
+    dav_generic_get_supportedlock,
+    dav_generic_parse_locktoken,
+    dav_generic_format_locktoken,
+    dav_generic_compare_locktoken,
+    dav_generic_open_lockdb,
+    dav_generic_close_lockdb,
+    dav_generic_remove_locknull_state,
+    dav_generic_create_lock,
+    dav_generic_get_locks,
+    dav_generic_find_lock,
+    dav_generic_has_locks,
+    dav_generic_append_locks,
+    dav_generic_remove_lock,
+    dav_generic_refresh_locks,
+    NULL, /* lookup_resource */
+
+    NULL /* ctx */
+};
diff --git a/modules/dav/lock/locks.h b/modules/dav/lock/locks.h
new file mode 100644
index 0000000..8a78a53
--- /dev/null
+++ b/modules/dav/lock/locks.h
@@ -0,0 +1,33 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file  locks.h
+ * @brief Declarations for the generic lock implementation
+ *
+ * @addtogroup MOD_DAV
+ * @{
+ */
+
+#ifndef _DAV_LOCK_LOCKS_H_
+#define _DAV_LOCK_LOCKS_H_
+
+/* where is the lock database located? */
+const char *dav_generic_get_lockdb_path(const request_rec *r);
+
+#endif /* _DAV_LOCK_LOCKS_H_ */
+/** @} */
+
diff --git a/modules/dav/lock/mod_dav_lock.c b/modules/dav/lock/mod_dav_lock.c
new file mode 100644
index 0000000..56a3202
--- /dev/null
+++ b/modules/dav/lock/mod_dav_lock.c
@@ -0,0 +1,104 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "httpd.h"
+#include "http_config.h"
+#include "apr_strings.h"
+#include "ap_provider.h"
+
+#include "mod_dav.h"
+#include "locks.h"
+
+/* per-dir configuration */
+typedef struct {
+    const char *lockdb_path;
+} dav_lock_dir_conf;
+
+extern const dav_hooks_locks dav_hooks_locks_generic;
+
+extern module AP_MODULE_DECLARE_DATA dav_lock_module;
+
+const char *dav_generic_get_lockdb_path(const request_rec *r)
+{
+    dav_lock_dir_conf *conf;
+
+    conf = ap_get_module_config(r->per_dir_config, &dav_lock_module);
+    return conf->lockdb_path;
+}
+
+static void *dav_lock_create_dir_config(apr_pool_t *p, char *dir)
+{
+    return apr_pcalloc(p, sizeof(dav_lock_dir_conf));
+}
+
+static void *dav_lock_merge_dir_config(apr_pool_t *p,
+                                       void *base, void *overrides)
+{
+    dav_lock_dir_conf *parent = base;
+    dav_lock_dir_conf *child = overrides;
+    dav_lock_dir_conf *newconf;
+
+    newconf = apr_pcalloc(p, sizeof(*newconf));
+
+    newconf->lockdb_path =
+        child->lockdb_path ? child->lockdb_path : parent->lockdb_path;
+
+    return newconf;
+}
+
+/*
+ * Command handler for the DAVGenericLockDB directive, which is TAKE1
+ */
+static const char *dav_lock_cmd_davlockdb(cmd_parms *cmd, void *config,
+                                        const char *arg1)
+{
+    dav_lock_dir_conf *conf = config;
+
+    conf->lockdb_path = ap_server_root_relative(cmd->pool, arg1);
+
+    if (!conf->lockdb_path) {
+        return apr_pstrcat(cmd->pool, "Invalid DAVGenericLockDB path ",
+                           arg1, NULL);
+    }
+
+    return NULL;
+}
+
+static const command_rec dav_lock_cmds[] =
+{
+    /* per server */
+    AP_INIT_TAKE1("DAVGenericLockDB", dav_lock_cmd_davlockdb, NULL, ACCESS_CONF,
+                  "specify a lock database"),
+
+    { NULL }
+};
+
+static void register_hooks(apr_pool_t *p)
+{
+    ap_register_provider(p, "dav-lock", "generic", "0",
+                         &dav_hooks_locks_generic);
+}
+
+AP_DECLARE_MODULE(dav_lock) =
+{
+    STANDARD20_MODULE_STUFF,
+    dav_lock_create_dir_config,     /* dir config creater */
+    dav_lock_merge_dir_config,      /* dir merger --- default is to override */
+    NULL,                           /* server config */
+    NULL,                           /* merge server config */
+    dav_lock_cmds,                  /* command table */
+    register_hooks,                 /* register hooks */
+};
diff --git a/modules/dav/lock/mod_dav_lock.dep b/modules/dav/lock/mod_dav_lock.dep
new file mode 100644
index 0000000..e21d71b
--- /dev/null
+++ b/modules/dav/lock/mod_dav_lock.dep
@@ -0,0 +1,100 @@
+# Microsoft Developer Studio Generated Dependency File, included by mod_dav_lock.mak
+
+.\locks.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\http_config.h"\
+	"..\..\..\include\http_log.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\mod_dav.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_cfgtree.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_uuid.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\locks.h"\
+	
+
+.\mod_dav_lock.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_provider.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\http_config.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\mod_dav.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_cfgtree.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\locks.h"\
+	
+
+..\..\..\build\win32\httpd.rc : \
+	"..\..\..\include\ap_release.h"\
+	
diff --git a/modules/dav/lock/mod_dav_lock.dsp b/modules/dav/lock/mod_dav_lock.dsp
new file mode 100644
index 0000000..e1c1a24
--- /dev/null
+++ b/modules/dav/lock/mod_dav_lock.dsp
@@ -0,0 +1,127 @@
+# Microsoft Developer Studio Project File - Name="mod_dav_lock" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=mod_dav_lock - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "mod_dav_lock.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "mod_dav_lock.mak" CFG="mod_dav_lock - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "mod_dav_lock - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "mod_dav_lock - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "mod_dav_lock - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FD /c
+# ADD CPP /nologo /MD /W3 /O2 /Oy- /Zi /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /Fd"Release\mod_dav_lock_src" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /fo"Release/mod_dav_lock.res" /i "../../../include" /i "../../../srclib/apr/include" /d "NDEBUG" /d BIN_NAME="mod_dav_lock.so" /d LONG_NAME="dav_lock_module for Apache"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /out:".\Release\mod_dav_lock.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_lock.so
+# ADD LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Release\mod_dav_lock.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_lock.so /opt:ref
+# Begin Special Build Tool
+TargetPath=.\Release\mod_dav_lock.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+PostBuild_Cmds=if exist $(TargetPath).manifest mt.exe -manifest $(TargetPath).manifest -outputresource:$(TargetPath);2
+# End Special Build Tool
+
+!ELSEIF  "$(CFG)" == "mod_dav_lock - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MDd /W3 /EHsc /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FD /c
+# ADD CPP /nologo /MDd /W3 /EHsc /Zi /Od /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /Fd"Debug\mod_dav_lock_src" /FD /c
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /fo"Debug/mod_dav_lock.res" /i "../../../include" /i "../../../srclib/apr/include" /d "_DEBUG" /d BIN_NAME="mod_dav_lock.so" /d LONG_NAME="dav_lock_module for Apache"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Debug\mod_dav_lock.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_lock.so
+# ADD LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Debug\mod_dav_lock.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_lock.so
+# Begin Special Build Tool
+TargetPath=.\Debug\mod_dav_lock.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+PostBuild_Cmds=if exist $(TargetPath).manifest mt.exe -manifest $(TargetPath).manifest -outputresource:$(TargetPath);2
+# End Special Build Tool
+
+!ENDIF 
+
+# Begin Target
+
+# Name "mod_dav_lock - Win32 Release"
+# Name "mod_dav_lock - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\locks.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\mod_dav_lock.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\locks.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\build\win32\httpd.rc
+# End Source File
+# End Target
+# End Project
diff --git a/modules/dav/lock/mod_dav_lock.mak b/modules/dav/lock/mod_dav_lock.mak
new file mode 100644
index 0000000..0ae2b6a
--- /dev/null
+++ b/modules/dav/lock/mod_dav_lock.mak
@@ -0,0 +1,389 @@
+# Microsoft Developer Studio Generated NMAKE File, Based on mod_dav_lock.dsp
+!IF "$(CFG)" == ""
+CFG=mod_dav_lock - Win32 Release
+!MESSAGE No configuration specified. Defaulting to mod_dav_lock - Win32 Release.
+!ENDIF 
+
+!IF "$(CFG)" != "mod_dav_lock - Win32 Release" && "$(CFG)" != "mod_dav_lock - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "mod_dav_lock.mak" CFG="mod_dav_lock - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "mod_dav_lock - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "mod_dav_lock - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+
+!IF  "$(CFG)" == "mod_dav_lock - Win32 Release"
+
+OUTDIR=.\Release
+INTDIR=.\Release
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+# Begin Custom Macros
+OutDir=.\Release
+# End Custom Macros
+
+!IF "$(RECURSE)" == "0" 
+
+ALL : "$(OUTDIR)\mod_dav_lock.so" "$(DS_POSTBUILD_DEP)"
+
+!ELSE 
+
+ALL : "mod_dav - Win32 Release" "libhttpd - Win32 Release" "libaprutil - Win32 Release" "libapr - Win32 Release" "$(OUTDIR)\mod_dav_lock.so" "$(DS_POSTBUILD_DEP)"
+
+!ENDIF 
+
+!IF "$(RECURSE)" == "1" 
+CLEAN :"libapr - Win32 ReleaseCLEAN" "libaprutil - Win32 ReleaseCLEAN" "libhttpd - Win32 ReleaseCLEAN" "mod_dav - Win32 ReleaseCLEAN" 
+!ELSE 
+CLEAN :
+!ENDIF 
+	-@erase "$(INTDIR)\locks.obj"
+	-@erase "$(INTDIR)\mod_dav_lock.obj"
+	-@erase "$(INTDIR)\mod_dav_lock.res"
+	-@erase "$(INTDIR)\mod_dav_lock_src.idb"
+	-@erase "$(INTDIR)\mod_dav_lock_src.pdb"
+	-@erase "$(OUTDIR)\mod_dav_lock.exp"
+	-@erase "$(OUTDIR)\mod_dav_lock.lib"
+	-@erase "$(OUTDIR)\mod_dav_lock.pdb"
+	-@erase "$(OUTDIR)\mod_dav_lock.so"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+CPP_PROJ=/nologo /MD /W3 /Zi /O2 /Oy- /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\mod_dav_lock_src" /FD /c 
+
+.c{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.c{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+MTL=midl.exe
+MTL_PROJ=/nologo /D "NDEBUG" /mktyplib203 /win32 
+RSC=rc.exe
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)\mod_dav_lock.res" /i "../../../include" /i "../../../srclib/apr/include" /d "NDEBUG" /d BIN_NAME="mod_dav_lock.so" /d LONG_NAME="dav_lock_module for Apache" 
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\mod_dav_lock.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+LINK32_FLAGS=kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /pdb:"$(OUTDIR)\mod_dav_lock.pdb" /debug /out:"$(OUTDIR)\mod_dav_lock.so" /implib:"$(OUTDIR)\mod_dav_lock.lib" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_lock.so /opt:ref 
+LINK32_OBJS= \
+	"$(INTDIR)\locks.obj" \
+	"$(INTDIR)\mod_dav_lock.obj" \
+	"$(INTDIR)\mod_dav_lock.res" \
+	"..\..\..\srclib\apr\Release\libapr-1.lib" \
+	"..\..\..\srclib\apr-util\Release\libaprutil-1.lib" \
+	"..\..\..\Release\libhttpd.lib" \
+	"..\main\Release\mod_dav.lib"
+
+"$(OUTDIR)\mod_dav_lock.so" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+TargetPath=.\Release\mod_dav_lock.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+
+# Begin Custom Macros
+OutDir=.\Release
+# End Custom Macros
+
+"$(DS_POSTBUILD_DEP)" : "$(OUTDIR)\mod_dav_lock.so"
+   if exist .\Release\mod_dav_lock.so.manifest mt.exe -manifest .\Release\mod_dav_lock.so.manifest -outputresource:.\Release\mod_dav_lock.so;2
+	echo Helper for Post-build step > "$(DS_POSTBUILD_DEP)"
+
+!ELSEIF  "$(CFG)" == "mod_dav_lock - Win32 Debug"
+
+OUTDIR=.\Debug
+INTDIR=.\Debug
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+# Begin Custom Macros
+OutDir=.\Debug
+# End Custom Macros
+
+!IF "$(RECURSE)" == "0" 
+
+ALL : "$(OUTDIR)\mod_dav_lock.so" "$(DS_POSTBUILD_DEP)"
+
+!ELSE 
+
+ALL : "mod_dav - Win32 Debug" "libhttpd - Win32 Debug" "libaprutil - Win32 Debug" "libapr - Win32 Debug" "$(OUTDIR)\mod_dav_lock.so" "$(DS_POSTBUILD_DEP)"
+
+!ENDIF 
+
+!IF "$(RECURSE)" == "1" 
+CLEAN :"libapr - Win32 DebugCLEAN" "libaprutil - Win32 DebugCLEAN" "libhttpd - Win32 DebugCLEAN" "mod_dav - Win32 DebugCLEAN" 
+!ELSE 
+CLEAN :
+!ENDIF 
+	-@erase "$(INTDIR)\locks.obj"
+	-@erase "$(INTDIR)\mod_dav_lock.obj"
+	-@erase "$(INTDIR)\mod_dav_lock.res"
+	-@erase "$(INTDIR)\mod_dav_lock_src.idb"
+	-@erase "$(INTDIR)\mod_dav_lock_src.pdb"
+	-@erase "$(OUTDIR)\mod_dav_lock.exp"
+	-@erase "$(OUTDIR)\mod_dav_lock.lib"
+	-@erase "$(OUTDIR)\mod_dav_lock.pdb"
+	-@erase "$(OUTDIR)\mod_dav_lock.so"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+CPP_PROJ=/nologo /MDd /W3 /Zi /Od /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\mod_dav_lock_src" /FD /EHsc /c 
+
+.c{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.c{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+MTL=midl.exe
+MTL_PROJ=/nologo /D "_DEBUG" /mktyplib203 /win32 
+RSC=rc.exe
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)\mod_dav_lock.res" /i "../../../include" /i "../../../srclib/apr/include" /d "_DEBUG" /d BIN_NAME="mod_dav_lock.so" /d LONG_NAME="dav_lock_module for Apache" 
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\mod_dav_lock.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+LINK32_FLAGS=kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /pdb:"$(OUTDIR)\mod_dav_lock.pdb" /debug /out:"$(OUTDIR)\mod_dav_lock.so" /implib:"$(OUTDIR)\mod_dav_lock.lib" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav_lock.so 
+LINK32_OBJS= \
+	"$(INTDIR)\locks.obj" \
+	"$(INTDIR)\mod_dav_lock.obj" \
+	"$(INTDIR)\mod_dav_lock.res" \
+	"..\..\..\srclib\apr\Debug\libapr-1.lib" \
+	"..\..\..\srclib\apr-util\Debug\libaprutil-1.lib" \
+	"..\..\..\Debug\libhttpd.lib" \
+	"..\main\Debug\mod_dav.lib"
+
+"$(OUTDIR)\mod_dav_lock.so" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+TargetPath=.\Debug\mod_dav_lock.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+
+# Begin Custom Macros
+OutDir=.\Debug
+# End Custom Macros
+
+"$(DS_POSTBUILD_DEP)" : "$(OUTDIR)\mod_dav_lock.so"
+   if exist .\Debug\mod_dav_lock.so.manifest mt.exe -manifest .\Debug\mod_dav_lock.so.manifest -outputresource:.\Debug\mod_dav_lock.so;2
+	echo Helper for Post-build step > "$(DS_POSTBUILD_DEP)"
+
+!ENDIF 
+
+
+!IF "$(NO_EXTERNAL_DEPS)" != "1"
+!IF EXISTS("mod_dav_lock.dep")
+!INCLUDE "mod_dav_lock.dep"
+!ELSE 
+!MESSAGE Warning: cannot find "mod_dav_lock.dep"
+!ENDIF 
+!ENDIF 
+
+
+!IF "$(CFG)" == "mod_dav_lock - Win32 Release" || "$(CFG)" == "mod_dav_lock - Win32 Debug"
+SOURCE=.\locks.c
+
+"$(INTDIR)\locks.obj" : $(SOURCE) "$(INTDIR)"
+
+
+SOURCE=.\mod_dav_lock.c
+
+"$(INTDIR)\mod_dav_lock.obj" : $(SOURCE) "$(INTDIR)"
+
+
+!IF  "$(CFG)" == "mod_dav_lock - Win32 Release"
+
+"libapr - Win32 Release" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Release" 
+   cd "..\..\modules\dav\lock"
+
+"libapr - Win32 ReleaseCLEAN" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Release" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\lock"
+
+!ELSEIF  "$(CFG)" == "mod_dav_lock - Win32 Debug"
+
+"libapr - Win32 Debug" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Debug" 
+   cd "..\..\modules\dav\lock"
+
+"libapr - Win32 DebugCLEAN" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Debug" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\lock"
+
+!ENDIF 
+
+!IF  "$(CFG)" == "mod_dav_lock - Win32 Release"
+
+"libaprutil - Win32 Release" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Release" 
+   cd "..\..\modules\dav\lock"
+
+"libaprutil - Win32 ReleaseCLEAN" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Release" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\lock"
+
+!ELSEIF  "$(CFG)" == "mod_dav_lock - Win32 Debug"
+
+"libaprutil - Win32 Debug" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Debug" 
+   cd "..\..\modules\dav\lock"
+
+"libaprutil - Win32 DebugCLEAN" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Debug" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\lock"
+
+!ENDIF 
+
+!IF  "$(CFG)" == "mod_dav_lock - Win32 Release"
+
+"libhttpd - Win32 Release" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Release" 
+   cd ".\modules\dav\lock"
+
+"libhttpd - Win32 ReleaseCLEAN" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Release" RECURSE=1 CLEAN 
+   cd ".\modules\dav\lock"
+
+!ELSEIF  "$(CFG)" == "mod_dav_lock - Win32 Debug"
+
+"libhttpd - Win32 Debug" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Debug" 
+   cd ".\modules\dav\lock"
+
+"libhttpd - Win32 DebugCLEAN" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Debug" RECURSE=1 CLEAN 
+   cd ".\modules\dav\lock"
+
+!ENDIF 
+
+!IF  "$(CFG)" == "mod_dav_lock - Win32 Release"
+
+"mod_dav - Win32 Release" : 
+   cd ".\..\main"
+   $(MAKE) /$(MAKEFLAGS) /F ".\mod_dav.mak" CFG="mod_dav - Win32 Release" 
+   cd "..\lock"
+
+"mod_dav - Win32 ReleaseCLEAN" : 
+   cd ".\..\main"
+   $(MAKE) /$(MAKEFLAGS) /F ".\mod_dav.mak" CFG="mod_dav - Win32 Release" RECURSE=1 CLEAN 
+   cd "..\lock"
+
+!ELSEIF  "$(CFG)" == "mod_dav_lock - Win32 Debug"
+
+"mod_dav - Win32 Debug" : 
+   cd ".\..\main"
+   $(MAKE) /$(MAKEFLAGS) /F ".\mod_dav.mak" CFG="mod_dav - Win32 Debug" 
+   cd "..\lock"
+
+"mod_dav - Win32 DebugCLEAN" : 
+   cd ".\..\main"
+   $(MAKE) /$(MAKEFLAGS) /F ".\mod_dav.mak" CFG="mod_dav - Win32 Debug" RECURSE=1 CLEAN 
+   cd "..\lock"
+
+!ENDIF 
+
+SOURCE=..\..\..\build\win32\httpd.rc
+
+!IF  "$(CFG)" == "mod_dav_lock - Win32 Release"
+
+
+"$(INTDIR)\mod_dav_lock.res" : $(SOURCE) "$(INTDIR)"
+	$(RSC) /l 0x409 /fo"$(INTDIR)\mod_dav_lock.res" /i "../../../include" /i "../../../srclib/apr/include" /i "../../../build\win32" /d "NDEBUG" /d BIN_NAME="mod_dav_lock.so" /d LONG_NAME="dav_lock_module for Apache" $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mod_dav_lock - Win32 Debug"
+
+
+"$(INTDIR)\mod_dav_lock.res" : $(SOURCE) "$(INTDIR)"
+	$(RSC) /l 0x409 /fo"$(INTDIR)\mod_dav_lock.res" /i "../../../include" /i "../../../srclib/apr/include" /i "../../../build\win32" /d "_DEBUG" /d BIN_NAME="mod_dav_lock.so" /d LONG_NAME="dav_lock_module for Apache" $(SOURCE)
+
+
+!ENDIF 
+
+
+!ENDIF 
+
diff --git a/modules/dav/main/Makefile.in b/modules/dav/main/Makefile.in
new file mode 100644
index 0000000..7c5c149
--- /dev/null
+++ b/modules/dav/main/Makefile.in
@@ -0,0 +1,3 @@
+# a modules Makefile has no explicit targets -- they will be defined by
+# whatever modules are enabled. just grab special.mk to deal with this.
+include $(top_srcdir)/build/special.mk
diff --git a/modules/dav/main/NWGNUmakefile b/modules/dav/main/NWGNUmakefile
new file mode 100644
index 0000000..bc94a22
--- /dev/null
+++ b/modules/dav/main/NWGNUmakefile
@@ -0,0 +1,268 @@
+#
+# Declare the sub-directories to be built here
+#
+
+SUBDIRS = \
+	$(EOLIST)
+
+#
+# Get the 'head' of the build environment.  This includes default targets and
+# paths to tools
+#
+
+include $(AP_WORK)/build/NWGNUhead.inc
+
+#
+# build this level's files
+#
+# Make sure all needed macro's are defined
+#
+
+#
+# These directories will be at the beginning of the include list, followed by
+# INCDIRS
+#
+XINCDIRS	+= \
+			$(APR)/include \
+			$(APRUTIL)/include \
+			$(AP_WORK)/include \
+			$(AP_WORK)/server/mpm/netware \
+			$(NWOS) \
+			$(EOLIST)
+
+#
+# These flags will come after CFLAGS
+#
+XCFLAGS		+= \
+			$(EOLIST)
+
+#
+# These defines will come after DEFINES
+#
+XDEFINES	+= \
+			$(EOLIST)
+
+#
+# These flags will be added to the link.opt file
+#
+XLFLAGS		+= \
+			$(EOLIST)
+
+#
+# These values will be appended to the correct variables based on the value of
+# RELEASE
+#
+ifeq "$(RELEASE)" "debug"
+XINCDIRS	+= \
+			$(EOLIST)
+
+XCFLAGS		+= \
+			$(EOLIST)
+
+XDEFINES	+= \
+			$(EOLIST)
+
+XLFLAGS		+= \
+			$(EOLIST)
+endif
+
+ifeq "$(RELEASE)" "noopt"
+XINCDIRS	+= \
+			$(EOLIST)
+
+XCFLAGS		+= \
+			$(EOLIST)
+
+XDEFINES	+= \
+			$(EOLIST)
+
+XLFLAGS		+= \
+			$(EOLIST)
+endif
+
+ifeq "$(RELEASE)" "release"
+XINCDIRS	+= \
+			$(EOLIST)
+
+XCFLAGS		+= \
+			$(EOLIST)
+
+XDEFINES	+= \
+			$(EOLIST)
+
+XLFLAGS		+= \
+			$(EOLIST)
+endif
+
+#
+# These are used by the link target if an NLM is being generated
+# This is used by the link 'name' directive to name the nlm.  If left blank
+# TARGET_nlm (see below) will be used.
+#
+NLM_NAME	= mod_dav
+
+#
+# This is used by the link '-desc ' directive.
+# If left blank, NLM_NAME will be used.
+#
+NLM_DESCRIPTION	= Apache $(VERSION_STR) DAV module
+
+#
+# This is used by the '-threadname' directive.  If left blank,
+# NLM_NAME Thread will be used.
+#
+NLM_THREAD_NAME	= $(NLM_NAME) Thread
+
+#
+# If this is specified, it will override VERSION value in
+# $(AP_WORK)/build/NWGNUenvironment.inc
+#
+NLM_VERSION	=
+
+#
+# If this is specified, it will override the default of 64K
+#
+NLM_STACK_SIZE	= 65536
+
+
+#
+# If this is specified it will be used by the link '-entry' directive
+#
+NLM_ENTRY_SYM	=
+
+#
+# If this is specified it will be used by the link '-exit' directive
+#
+NLM_EXIT_SYM	=
+
+#
+# If this is specified it will be used by the link '-check' directive
+#
+NLM_CHECK_SYM	=
+
+#
+# If this is specified it will be used by the link '-flags' directive
+#
+NLM_FLAGS	=
+
+#
+# If this is specified it will be linked in with the XDCData option in the def
+# file instead of the default of $(NWOS)/apache.xdc.  XDCData can be disabled
+# by setting APACHE_UNIPROC in the environment
+#
+XDCDATA		=
+
+#
+# Declare all target files (you must add your files here)
+#
+
+#
+# If there is an NLM target, put it here
+#
+TARGET_nlm = \
+	$(OBJDIR)/$(NLM_NAME).nlm \
+	$(EOLIST)
+
+#
+# If there is an LIB target, put it here
+#
+TARGET_lib = \
+	$(EOLIST)
+
+#
+# These are the OBJ files needed to create the NLM target above.
+# Paths must all use the '/' character
+#
+FILES_nlm_objs = \
+	$(OBJDIR)/mod_dav.o \
+	$(OBJDIR)/liveprop.o \
+	$(OBJDIR)/props.o \
+	$(OBJDIR)/providers.o \
+	$(OBJDIR)/std_liveprop.o \
+	$(OBJDIR)/util.o \
+	$(OBJDIR)/util_lock.o \
+	$(EOLIST)
+
+#
+# These are the LIB files needed to create the NLM target above.
+# These will be added as a library command in the link.opt file.
+#
+FILES_nlm_libs = \
+	$(PRELUDE) \
+	$(EOLIST)
+
+#
+# These are the modules that the above NLM target depends on to load.
+# These will be added as a module command in the link.opt file.
+#
+FILES_nlm_modules = \
+	Apache2 \
+	Libc \
+	$(EOLIST)
+
+#
+# If the nlm has a msg file, put it's path here
+#
+FILE_nlm_msg =
+
+#
+# If the nlm has a hlp file put it's path here
+#
+FILE_nlm_hlp =
+
+#
+# If this is specified, it will override $(NWOS)\copyright.txt.
+#
+FILE_nlm_copyright =
+
+#
+# Any additional imports go here
+#
+FILES_nlm_Ximports = \
+	@libc.imp \
+	@aprlib.imp \
+	@httpd.imp \
+	$(EOLIST)
+
+#
+# Any symbols exported to here
+#
+FILES_nlm_exports = \
+	dav_module \
+	@dav.imp \
+	$(EOLIST)
+
+#
+# These are the OBJ files needed to create the LIB target above.
+# Paths must all use the '/' character
+#
+FILES_lib_objs = \
+	$(EOLIST)
+
+#
+# implement targets and dependancies (leave this section alone)
+#
+
+libs :: $(OBJDIR) $(TARGET_lib)
+
+nlms :: libs $(TARGET_nlm)
+
+#
+# Updated this target to create necessary directories and copy files to the
+# correct place.  (See $(AP_WORK)/build/NWGNUhead.inc for examples)
+#
+install :: nlms FORCE
+	$(call COPY,$(OBJDIR)/*.nlm, $(INSTALLBASE)/modules/)
+
+#
+# Any specialized rules here
+#
+
+#
+# Include the 'tail' makefile that has targets that depend on variables defined
+# in this makefile
+#
+
+include $(APBUILD)/NWGNUtail.inc
+
+
diff --git a/modules/dav/main/config5.m4 b/modules/dav/main/config5.m4
new file mode 100644
index 0000000..28823c7
--- /dev/null
+++ b/modules/dav/main/config5.m4
@@ -0,0 +1,21 @@
+dnl modules enabled in this directory by default
+
+APACHE_MODPATH_INIT(dav/main)
+
+dav_objects="mod_dav.lo props.lo util.lo util_lock.lo liveprop.lo providers.lo std_liveprop.lo"
+
+if test "$enable_http" = "no"; then
+  dav_enable=no
+else
+  dav_enable=most
+fi
+
+APACHE_MODULE(dav, WebDAV protocol handling.  --enable-dav also enables mod_dav_fs, $dav_objects, , $dav_enable)
+
+if test "$dav_enable" != "no" -o "$enable_dav" != "no"; then
+  apache_need_expat=yes
+fi
+
+APR_ADDTO(INCLUDES, [-I\$(top_srcdir)/$modpath_current])
+
+APACHE_MODPATH_FINISH
diff --git a/modules/dav/main/liveprop.c b/modules/dav/main/liveprop.c
new file mode 100644
index 0000000..d170d75
--- /dev/null
+++ b/modules/dav/main/liveprop.c
@@ -0,0 +1,140 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr_pools.h"
+#include "apr_hash.h"
+#include "apr_errno.h"
+#include "apr_strings.h"
+#include "util_xml.h"   /* for apr_text_header */
+#include "mod_dav.h"
+
+
+static apr_hash_t *dav_liveprop_uris = NULL;
+static long dav_liveprop_count = 0;
+
+
+static apr_status_t dav_cleanup_liveprops(void *ctx)
+{
+    dav_liveprop_uris = NULL;
+    dav_liveprop_count = 0;
+    return APR_SUCCESS;
+}
+
+static void dav_register_liveprop_namespace(apr_pool_t *p, const char *uri)
+{
+    long value;
+
+    if (dav_liveprop_uris == NULL) {
+        dav_liveprop_uris = apr_hash_make(p);
+        apr_pool_cleanup_register(p, NULL, dav_cleanup_liveprops, apr_pool_cleanup_null);
+    }
+
+    value = (long)apr_hash_get(dav_liveprop_uris, uri, APR_HASH_KEY_STRING);
+    if (value != 0) {
+        /* already registered */
+        return;
+    }
+
+    /* start at 1, and count up */
+    apr_hash_set(dav_liveprop_uris, uri, APR_HASH_KEY_STRING,
+                 (void *)++dav_liveprop_count);
+}
+
+DAV_DECLARE(long) dav_get_liveprop_ns_index(const char *uri)
+{
+    return (long)apr_hash_get(dav_liveprop_uris, uri, APR_HASH_KEY_STRING);
+}
+
+DAV_DECLARE(long) dav_get_liveprop_ns_count(void)
+{
+    return dav_liveprop_count;
+}
+
+DAV_DECLARE(void) dav_add_all_liveprop_xmlns(apr_pool_t *p,
+                                             apr_text_header *phdr)
+{
+    apr_hash_index_t *idx = apr_hash_first(p, dav_liveprop_uris);
+
+    for ( ; idx != NULL; idx = apr_hash_next(idx) ) {
+        const void *key;
+        void *val;
+        const char *s;
+
+        apr_hash_this(idx, &key, NULL, &val);
+
+        s = apr_psprintf(p, " xmlns:lp%ld=\"%s\"", (long)val, (const char *)key);
+        apr_text_append(p, phdr, s);
+    }
+}
+
+DAV_DECLARE(int) dav_do_find_liveprop(const char *ns_uri, const char *name,
+                                      const dav_liveprop_group *group,
+                                      const dav_hooks_liveprop **hooks)
+{
+    const char * const *uris = group->namespace_uris;
+    const dav_liveprop_spec *scan;
+    int ns;
+
+    /* first: locate the namespace in the namespace table */
+    for (ns = 0; uris[ns] != NULL; ++ns)
+        if (strcmp(ns_uri, uris[ns]) == 0)
+            break;
+    if (uris[ns] == NULL) {
+        /* not our property (the namespace matched none of ours) */
+        return 0;
+    }
+
+    /* second: look for the property in the liveprop specs */
+    for (scan = group->specs; scan->name != NULL; ++scan)
+        if (ns == scan->ns && strcmp(name, scan->name) == 0) {
+            *hooks = group->hooks;
+            return scan->propid;
+        }
+
+    /* not our property (same namespace, but no matching prop name) */
+    return 0;
+}
+
+DAV_DECLARE(long) dav_get_liveprop_info(int propid,
+                                       const dav_liveprop_group *group,
+                                       const dav_liveprop_spec **info)
+{
+    const dav_liveprop_spec *scan;
+
+    for (scan = group->specs; scan->name != NULL; ++scan) {
+        if (scan->propid == propid) {
+            *info = scan;
+
+            /* map the provider-local NS into a global NS index */
+            return dav_get_liveprop_ns_index(group->namespace_uris[scan->ns]);
+        }
+    }
+
+    /* assert: should not reach this point */
+    *info = NULL;
+    return 0;
+}
+
+DAV_DECLARE(void) dav_register_liveprop_group(apr_pool_t *p,
+                                              const dav_liveprop_group *group)
+{
+    /* register the namespace URIs */
+    const char * const * uris = group->namespace_uris;
+
+    for ( ; *uris != NULL; ++uris) {
+        dav_register_liveprop_namespace(p, *uris);
+    }
+}
diff --git a/modules/dav/main/mod_dav.c b/modules/dav/main/mod_dav.c
new file mode 100644
index 0000000..84012f2
--- /dev/null
+++ b/modules/dav/main/mod_dav.c
@@ -0,0 +1,4946 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * 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 "apr_strings.h"
+#include "apr_lib.h"            /* for apr_is* */
+
+#define APR_WANT_STRFUNC
+#include "apr_want.h"
+
+#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 "ap_provider.h"
+
+
+/* ### what is the best way to set this? */
+#define DAV_DEFAULT_PROVIDER    "filesystem"
+
+/* used to denote that mod_dav will be handling this request */
+#define DAV_HANDLER_NAME "dav-handler"
+
+APLOG_USE_MODULE(dav);
+
+enum {
+    DAV_ENABLED_UNSET = 0,
+    DAV_ENABLED_OFF,
+    DAV_ENABLED_ON
+};
+
+/* per-dir configuration */
+typedef struct {
+    const char *provider_name;
+    const dav_provider *provider;
+    const char *dir;
+    int locktimeout;
+    int allow_depthinfinity;
+
+} dav_dir_conf;
+
+/* per-server configuration */
+typedef struct {
+    int unused;
+
+} dav_server_conf;
+
+#define DAV_INHERIT_VALUE(parent, child, field) \
+                ((child)->field ? (child)->field : (parent)->field)
+
+
+/* forward-declare for use in configuration lookup */
+extern module DAV_DECLARE_DATA dav_module;
+
+/* DAV methods */
+enum {
+    DAV_M_BIND = 0,
+    DAV_M_SEARCH,
+    DAV_M_LAST
+};
+static int dav_methods[DAV_M_LAST];
+
+
+static int dav_init_handler(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp,
+                             server_rec *s)
+{
+    /* DBG0("dav_init_handler"); */
+
+    /* Register DAV methods */
+    dav_methods[DAV_M_BIND] = ap_method_register(p, "BIND");
+    dav_methods[DAV_M_SEARCH] = ap_method_register(p, "SEARCH");
+
+    return OK;
+}
+
+static void *dav_create_server_config(apr_pool_t *p, server_rec *s)
+{
+    dav_server_conf *newconf;
+
+    newconf = (dav_server_conf *)apr_pcalloc(p, sizeof(*newconf));
+
+    /* ### this isn't used at the moment... */
+
+    return newconf;
+}
+
+static void *dav_merge_server_config(apr_pool_t *p, void *base, void *overrides)
+{
+#if 0
+    dav_server_conf *child = overrides;
+#endif
+    dav_server_conf *newconf;
+
+    newconf = (dav_server_conf *)apr_pcalloc(p, sizeof(*newconf));
+
+    /* ### nothing to merge right now... */
+
+    return newconf;
+}
+
+static void *dav_create_dir_config(apr_pool_t *p, char *dir)
+{
+    /* NOTE: dir==NULL creates the default per-dir config */
+
+    dav_dir_conf *conf;
+
+    conf = (dav_dir_conf *)apr_pcalloc(p, sizeof(*conf));
+
+    /* clean up the directory to remove any trailing slash */
+    if (dir != NULL) {
+        char *d;
+        apr_size_t l;
+
+        l = strlen(dir);
+        d = apr_pstrmemdup(p, dir, l);
+        if (l > 1 && d[l - 1] == '/')
+            d[l - 1] = '\0';
+        conf->dir = d;
+    }
+
+    return conf;
+}
+
+static void *dav_merge_dir_config(apr_pool_t *p, void *base, void *overrides)
+{
+    dav_dir_conf *parent = base;
+    dav_dir_conf *child = overrides;
+    dav_dir_conf *newconf = (dav_dir_conf *)apr_pcalloc(p, sizeof(*newconf));
+
+    /* DBG3("dav_merge_dir_config: new=%08lx  base=%08lx  overrides=%08lx",
+       (long)newconf, (long)base, (long)overrides); */
+
+    newconf->provider_name = DAV_INHERIT_VALUE(parent, child, provider_name);
+    newconf->provider = DAV_INHERIT_VALUE(parent, child, provider);
+    if (parent->provider_name != NULL) {
+        if (child->provider_name == NULL) {
+            ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, APLOGNO(00578)
+                         "\"DAV Off\" cannot be used to turn off a subtree "
+                         "of a DAV-enabled location.");
+        }
+        else if (strcasecmp(child->provider_name,
+                            parent->provider_name) != 0) {
+            ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, APLOGNO(00579)
+                         "A subtree cannot specify a different DAV provider "
+                         "than its parent.");
+        }
+    }
+
+    newconf->locktimeout = DAV_INHERIT_VALUE(parent, child, locktimeout);
+    newconf->dir = DAV_INHERIT_VALUE(parent, child, dir);
+    newconf->allow_depthinfinity = DAV_INHERIT_VALUE(parent, child,
+                                                     allow_depthinfinity);
+
+    return newconf;
+}
+
+DAV_DECLARE(const char *) dav_get_provider_name(request_rec *r)
+{
+    dav_dir_conf *conf = ap_get_module_config(r->per_dir_config, &dav_module);
+    return conf ? conf->provider_name : NULL;
+}
+
+static const dav_provider *dav_get_provider(request_rec *r)
+{
+    dav_dir_conf *conf;
+
+    conf = ap_get_module_config(r->per_dir_config, &dav_module);
+    /* assert: conf->provider_name != NULL
+       (otherwise, DAV is disabled, and we wouldn't be here) */
+
+    /* assert: conf->provider != NULL
+       (checked when conf->provider_name is set) */
+    return conf->provider;
+}
+
+DAV_DECLARE(const dav_hooks_locks *) dav_get_lock_hooks(request_rec *r)
+{
+    return dav_get_provider(r)->locks;
+}
+
+DAV_DECLARE(const dav_hooks_propdb *) dav_get_propdb_hooks(request_rec *r)
+{
+    return dav_get_provider(r)->propdb;
+}
+
+DAV_DECLARE(const dav_hooks_vsn *) dav_get_vsn_hooks(request_rec *r)
+{
+    return dav_get_provider(r)->vsn;
+}
+
+DAV_DECLARE(const dav_hooks_binding *) dav_get_binding_hooks(request_rec *r)
+{
+    return dav_get_provider(r)->binding;
+}
+
+DAV_DECLARE(const dav_hooks_search *) dav_get_search_hooks(request_rec *r)
+{
+    return dav_get_provider(r)->search;
+}
+
+/*
+ * Command handler for the DAV directive, which is TAKE1.
+ */
+static const char *dav_cmd_dav(cmd_parms *cmd, void *config, const char *arg1)
+{
+    dav_dir_conf *conf = (dav_dir_conf *)config;
+
+    if (strcasecmp(arg1, "on") == 0) {
+        conf->provider_name = DAV_DEFAULT_PROVIDER;
+    }
+    else if (strcasecmp(arg1, "off") == 0) {
+        conf->provider_name = NULL;
+        conf->provider = NULL;
+    }
+    else {
+        conf->provider_name = arg1;
+    }
+
+    if (conf->provider_name != NULL) {
+        /* lookup and cache the actual provider now */
+        conf->provider = dav_lookup_provider(conf->provider_name);
+
+        if (conf->provider == NULL) {
+            /* by the time they use it, the provider should be loaded and
+               registered with us. */
+            return apr_psprintf(cmd->pool,
+                                "Unknown DAV provider: %s",
+                                conf->provider_name);
+        }
+    }
+
+    return NULL;
+}
+
+/*
+ * Command handler for the DAVDepthInfinity directive, which is FLAG.
+ */
+static const char *dav_cmd_davdepthinfinity(cmd_parms *cmd, void *config,
+                                            int arg)
+{
+    dav_dir_conf *conf = (dav_dir_conf *)config;
+
+    if (arg)
+        conf->allow_depthinfinity = DAV_ENABLED_ON;
+    else
+        conf->allow_depthinfinity = DAV_ENABLED_OFF;
+    return NULL;
+}
+
+/*
+ * Command handler for DAVMinTimeout directive, which is TAKE1
+ */
+static const char *dav_cmd_davmintimeout(cmd_parms *cmd, void *config,
+                                         const char *arg1)
+{
+    dav_dir_conf *conf = (dav_dir_conf *)config;
+
+    conf->locktimeout = atoi(arg1);
+    if (conf->locktimeout < 0)
+        return "DAVMinTimeout requires a non-negative integer.";
+
+    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.
+**
+** ### this function is not logging any errors! (e.g. the body)
+*/
+static int dav_error_response(request_rec *r, int status, const char *body)
+{
+    r->status = status;
+    r->status_line = ap_get_status_line(status);
+
+    ap_set_content_type(r, "text/html; charset=ISO-8859-1");
+
+    /* begin the response now... */
+    ap_rvputs(r,
+              DAV_RESPONSE_BODY_1,
+              r->status_line,
+              DAV_RESPONSE_BODY_2,
+              &r->status_line[4],
+              DAV_RESPONSE_BODY_3,
+              body,
+              DAV_RESPONSE_BODY_4,
+              ap_psignature("<hr />\n", r),
+              DAV_RESPONSE_BODY_5,
+              NULL);
+
+    /* the response has been sent. */
+    /*
+     * ### Use of DONE obviates logging..!
+     */
+    return DONE;
+}
+
+
+/*
+ * Send a "standardized" error response based on the error's namespace & tag
+ */
+static int dav_error_response_tag(request_rec *r,
+                                  dav_error *err)
+{
+    r->status = err->status;
+
+    ap_set_content_type(r, DAV_XML_CONTENT_TYPE);
+
+    ap_rputs(DAV_XML_HEADER DEBUG_CR
+             "<D:error xmlns:D=\"DAV:\"", r);
+
+    if (err->desc != NULL) {
+        /* ### should move this namespace somewhere (with the others!) */
+        ap_rputs(" xmlns:m=\"http://apache.org/dav/xmlns\"", r);
+    }
+
+    if (err->childtags) {
+        if (err->namespace != NULL) {
+            ap_rprintf(r,
+                    " xmlns:C=\"%s\">" DEBUG_CR
+                    "<C:%s>%s</C:%s>" DEBUG_CR,
+                    err->namespace,
+                    err->tagname, err->childtags, err->tagname);
+        }
+        else {
+            ap_rprintf(r,
+                    ">" DEBUG_CR
+                    "<D:%s>%s</D:%s>" DEBUG_CR,
+                    err->tagname, err->childtags, err->tagname);
+        }
+    }
+    else {
+        if (err->namespace != NULL) {
+            ap_rprintf(r,
+                    " xmlns:C=\"%s\">" DEBUG_CR
+                    "<C:%s/>" DEBUG_CR,
+                    err->namespace, err->tagname);
+        }
+        else {
+            ap_rprintf(r,
+                    ">" DEBUG_CR
+                    "<D:%s/>" DEBUG_CR, err->tagname);
+        }
+    }
+
+    /* here's our mod_dav specific tag: */
+    if (err->desc != NULL) {
+        ap_rprintf(r,
+                   "<m:human-readable errcode=\"%d\">" DEBUG_CR
+                   "%s" DEBUG_CR
+                   "</m:human-readable>" DEBUG_CR,
+                   err->error_id,
+                   apr_xml_quote_string(r->pool, err->desc, 0));
+    }
+
+    ap_rputs("</D:error>" DEBUG_CR, r);
+
+    /* 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.
+ */
+static const char *dav_xml_escape_uri(apr_pool_t *p, const char *uri)
+{
+    const char *e_uri = ap_escape_uri(p, uri);
+
+    /* check the easy case... */
+    if (ap_strchr_c(e_uri, '&') == NULL)
+        return e_uri;
+
+    /* there was a '&', so more work is needed... sigh. */
+
+    /*
+     * Note: this is a teeny bit of overkill since we know there are no
+     * '<' or '>' characters, but who cares.
+     */
+    return apr_xml_quote_string(p, e_uri, 0);
+}
+
+
+/* Write a complete RESPONSE object out as a <DAV:repsonse> xml
+   element.  Data is sent into brigade BB, which is auto-flushed into
+   the output filter stack for request R.  Use POOL for any temporary
+   allocations.
+
+   [Presumably the <multistatus> tag has already been written;  this
+   routine is shared by dav_send_multistatus and dav_stream_response.]
+*/
+DAV_DECLARE(void) dav_send_one_response(dav_response *response,
+                                        apr_bucket_brigade *bb,
+                                        request_rec *r,
+                                        apr_pool_t *pool)
+{
+    apr_text *t = NULL;
+
+    if (response->propresult.xmlns == NULL) {
+      ap_fputs(r->output_filters, bb, "<D:response>");
+    }
+    else {
+      ap_fputs(r->output_filters, bb, "<D:response");
+      for (t = response->propresult.xmlns; t; t = t->next) {
+        ap_fputs(r->output_filters, bb, t->text);
+      }
+      ap_fputc(r->output_filters, bb, '>');
+    }
+
+    ap_fputstrs(r->output_filters, bb,
+                DEBUG_CR "<D:href>",
+                dav_xml_escape_uri(pool, response->href),
+                "</D:href>" DEBUG_CR,
+                NULL);
+
+    if (response->propresult.propstats == NULL) {
+      /* 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_fputstrs(r->output_filters, bb,
+                  "<D:status>HTTP/1.1 ",
+                  ap_get_status_line(response->status),
+                  "</D:status>" DEBUG_CR,
+                  NULL);
+    }
+    else {
+      /* assume this includes <propstat> and is quoted properly */
+      for (t = response->propresult.propstats; t; t = t->next) {
+        ap_fputs(r->output_filters, bb, t->text);
+      }
+    }
+
+    if (response->desc != NULL) {
+      /*
+       * We supply the description, so we know it doesn't have to
+       * have any escaping/encoding applied to it.
+       */
+      ap_fputstrs(r->output_filters, bb,
+                  "<D:responsedescription>",
+                  response->desc,
+                  "</D:responsedescription>" DEBUG_CR,
+                  NULL);
+    }
+
+    ap_fputs(r->output_filters, bb, "</D:response>" DEBUG_CR);
+}
+
+
+/* Factorized helper function: prep request_rec R for a multistatus
+   response and write <multistatus> tag into BB, destined for
+   R->output_filters.  Use xml NAMESPACES in initial tag, if
+   non-NULL. */
+DAV_DECLARE(void) dav_begin_multistatus(apr_bucket_brigade *bb,
+                                        request_rec *r, int status,
+                                        apr_array_header_t *namespaces)
+{
+    /* Set the correct status and Content-Type */
+    r->status = status;
+    ap_set_content_type(r, DAV_XML_CONTENT_TYPE);
+
+    /* Send the headers and actual multistatus response now... */
+    ap_fputs(r->output_filters, bb, DAV_XML_HEADER DEBUG_CR
+             "<D:multistatus xmlns:D=\"DAV:\"");
+
+    if (namespaces != NULL) {
+       int i;
+
+       for (i = namespaces->nelts; i--; ) {
+           ap_fprintf(r->output_filters, bb, " xmlns:ns%d=\"%s\"", i,
+                      APR_XML_GET_URI_ITEM(namespaces, i));
+       }
+    }
+
+    ap_fputs(r->output_filters, bb, ">" DEBUG_CR);
+}
+
+/* Finish a multistatus response started by dav_begin_multistatus: */
+DAV_DECLARE(apr_status_t) dav_finish_multistatus(request_rec *r,
+                                                 apr_bucket_brigade *bb)
+{
+    apr_bucket *b;
+
+    ap_fputs(r->output_filters, bb, "</D:multistatus>" DEBUG_CR);
+
+    /* indicate the end of the response body */
+    b = apr_bucket_eos_create(r->connection->bucket_alloc);
+    APR_BRIGADE_INSERT_TAIL(bb, b);
+
+    /* deliver whatever might be remaining in the brigade */
+    return ap_pass_brigade(r->output_filters, bb);
+}
+
+DAV_DECLARE(void) dav_send_multistatus(request_rec *r, int status,
+                                       dav_response *first,
+                                       apr_array_header_t *namespaces)
+{
+    apr_pool_t *subpool;
+    apr_bucket_brigade *bb = apr_brigade_create(r->pool,
+                                                r->connection->bucket_alloc);
+
+    dav_begin_multistatus(bb, r, status, namespaces);
+
+    apr_pool_create(&subpool, r->pool);
+
+    for (; first != NULL; first = first->next) {
+      apr_pool_clear(subpool);
+      dav_send_one_response(first, bb, r, subpool);
+    }
+    apr_pool_destroy(subpool);
+
+    dav_finish_multistatus(r, bb);
+}
+
+/*
+ * dav_log_err()
+ *
+ * Write error information to the log.
+ */
+static void dav_log_err(request_rec *r, dav_error *err, int level)
+{
+    dav_error *errscan;
+
+    /* Log the errors */
+    /* ### should have a directive to log the first or all */
+    for (errscan = err; errscan != NULL; errscan = errscan->prev) {
+        if (errscan->desc == NULL)
+            continue;
+
+        /* Intentional no APLOGNO */
+        ap_log_rerror(APLOG_MARK, level, errscan->aprerr, r, "%s  [%d, #%d]",
+                      errscan->desc, errscan->status, errscan->error_id);
+    }
+}
+
+/*
+ * 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
+ *   - vsn_hooks->update
+ */
+DAV_DECLARE(int) dav_handle_err(request_rec *r, dav_error *err,
+                                dav_response *response)
+{
+    /* log the errors */
+    dav_log_err(r, err, APLOG_ERR);
+
+    if (!ap_is_HTTP_VALID_RESPONSE(err->status)) {
+        /* we have responded already */
+        return AP_FILTER_ERROR;
+    }
+
+    if (response == NULL) {
+        dav_error *stackerr = err;
+
+        /* our error messages are safe; tell Apache this */
+        apr_table_setn(r->notes, "verbose-error-to", "*");
+
+        /* Didn't get a multistatus response passed in, but we still
+           might be able to generate a standard <D:error> response.
+           Search the error stack for an errortag. */
+        while (stackerr != NULL && stackerr->tagname == NULL)
+            stackerr = stackerr->prev;
+
+        if (stackerr != NULL && stackerr->tagname != NULL)
+            return dav_error_response_tag(r, stackerr);
+
+        return err->status;
+    }
+
+    /* send the multistatus and tell Apache the request/response is DONE. */
+    dav_send_multistatus(r, err->status, response, NULL);
+    return DONE;
+}
+
+/* handy function for return values of methods that (may) create things.
+ * locn if provided is assumed to be escaped. */
+static int dav_created(request_rec *r, const char *locn, const char *what,
+                       int replaced)
+{
+    const char *body;
+
+    if (locn == NULL) {
+        locn = ap_escape_uri(r->pool, r->uri);
+    }
+
+    /* 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. */
+
+    /* Convert locn to an absolute URI, and return in Location header */
+    apr_table_setn(r->headers_out, "Location", ap_construct_url(r->pool, locn, r));
+
+    /* ### 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. */
+    body = apr_psprintf(r->pool, "%s %s has been created.",
+                        what, ap_escape_html(r->pool, locn));
+    return dav_error_response(r, HTTP_CREATED, body);
+}
+
+/* ### move to dav_util? */
+DAV_DECLARE(int) dav_get_depth(request_rec *r, int def_depth)
+{
+    const char *depth = apr_table_get(r->headers_in, "Depth");
+
+    if (depth == NULL) {
+        return def_depth;
+    }
+
+    if (strcasecmp(depth, "infinity") == 0) {
+        return DAV_INFINITY;
+    }
+    else if (strcmp(depth, "0") == 0) {
+        return 0;
+    }
+    else if (strcmp(depth, "1") == 0) {
+        return 1;
+    }
+
+    /* The caller will return an HTTP_BAD_REQUEST. This will augment the
+     * default message that Apache provides. */
+    ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00580)
+                  "An invalid Depth header was specified.");
+    return -1;
+}
+
+static int dav_get_overwrite(request_rec *r)
+{
+    const char *overwrite = apr_table_get(r->headers_in, "Overwrite");
+
+    if (overwrite == NULL) {
+        return 1; /* default is "T" */
+    }
+
+    if ((*overwrite == 'F' || *overwrite == 'f') && overwrite[1] == '\0') {
+        return 0;
+    }
+
+    if ((*overwrite == 'T' || *overwrite == 't') && overwrite[1] == '\0') {
+        return 1;
+    }
+
+    /* The caller will return an HTTP_BAD_REQUEST. This will augment the
+     * default message that Apache provides. */
+    ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00581)
+                  "An invalid Overwrite header was specified.");
+    return -1;
+}
+
+/* resolve a request URI to a resource descriptor.
+ *
+ * If label_allowed != 0, then allow the request target to be altered by
+ * a Label: header.
+ *
+ * If use_checked_in is true, then the repository provider should return
+ * the resource identified by the DAV:checked-in property of the resource
+ * identified by the Request-URI.
+ */
+static dav_error *dav_get_resource(request_rec *r, int label_allowed,
+                                   int use_checked_in, dav_resource **res_p)
+{
+    dav_dir_conf *conf;
+    const char *label = NULL;
+    dav_error *err;
+
+    /* if the request target can be overridden, get any target selector */
+    if (label_allowed) {
+        label = apr_table_get(r->headers_in, "label");
+    }
+
+    conf = ap_get_module_config(r->per_dir_config, &dav_module);
+    /* assert: conf->provider != NULL */
+    if (conf->provider == NULL) {
+        return dav_new_error(r->pool, HTTP_METHOD_NOT_ALLOWED, 0, 0,
+                             apr_psprintf(r->pool,
+                             "DAV not enabled for %s",
+                             ap_escape_html(r->pool, r->uri)));
+    }
+
+    /* resolve the resource */
+    err = (*conf->provider->repos->get_resource)(r, conf->dir,
+                                                 label, use_checked_in,
+                                                 res_p);
+    if (err != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             "Could not fetch resource information.", err);
+        return err;
+    }
+
+    /* Note: this shouldn't happen, but just be sure... */
+    if (*res_p == NULL) {
+        /* ### maybe use HTTP_INTERNAL_SERVER_ERROR */
+        return dav_new_error(r->pool, HTTP_NOT_FOUND, 0, 0,
+                             apr_psprintf(r->pool,
+                                          "The provider did not define a "
+                                          "resource for %s.",
+                                          ap_escape_html(r->pool, r->uri)));
+    }
+
+    /* ### hmm. this doesn't feel like the right place or thing to do */
+    /* if there were any input headers requiring a Vary header in the response,
+     * add it now */
+    dav_add_vary_header(r, r, *res_p);
+
+    return NULL;
+}
+
+static dav_error * dav_open_lockdb(request_rec *r, int ro, dav_lockdb **lockdb)
+{
+    const dav_hooks_locks *hooks = DAV_GET_HOOKS_LOCKS(r);
+
+    if (hooks == NULL) {
+        *lockdb = NULL;
+        return NULL;
+    }
+
+    /* open the thing lazily */
+    return (*hooks->open_lockdb)(r, ro, 0, lockdb);
+}
+
+/**
+ * @return  1 if valid content-range,
+ *          0 if no content-range,
+ *         -1 if malformed content-range
+ */
+static int dav_parse_range(request_rec *r,
+                           apr_off_t *range_start, apr_off_t *range_end)
+{
+    const char *range_c;
+    char *range;
+    char *dash;
+    char *slash;
+    char *errp;
+
+    range_c = apr_table_get(r->headers_in, "content-range");
+    if (range_c == NULL)
+        return 0;
+
+    range = apr_pstrdup(r->pool, range_c);
+    if (strncasecmp(range, "bytes ", 6) != 0
+        || (dash = ap_strchr(range, '-')) == NULL
+        || (slash = ap_strchr(range, '/')) == NULL) {
+        /* malformed header */
+        return -1;
+    }
+
+    *dash++ = *slash++ = '\0';
+
+    /* detect invalid ranges */
+    if (apr_strtoff(range_start, range + 6, &errp, 10)
+        || *errp || *range_start < 0) {
+        return -1;
+    }
+    if (apr_strtoff(range_end, dash, &errp, 10)
+        || *errp || *range_end < 0 || *range_end < *range_start) {
+        return -1;
+    }
+
+    if (*slash != '*') {
+        apr_off_t dummy;
+
+        if (apr_strtoff(&dummy, slash, &errp, 10)
+            || *errp || dummy <= *range_end) {
+            return -1;
+        }
+    }
+
+    /* we now have a valid range */
+    return 1;
+}
+
+/* handle the GET method */
+static int dav_method_get(request_rec *r)
+{
+    dav_resource *resource;
+    dav_error *err;
+    int status;
+
+    /* 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.
+     */
+    err = dav_get_resource(r, 1 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    if (!resource->exists) {
+        /* Apache will supply a default error for this. */
+        return HTTP_NOT_FOUND;
+    }
+
+    /* set up the HTTP headers for the response */
+    if ((err = (*resource->hooks->set_headers)(r, resource)) != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             "Unable to set up HTTP headers.",
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* Handle conditional requests */
+    status = ap_meets_conditions(r);
+    if (status) {
+      return status;
+    }
+
+    if (r->header_only) {
+        return DONE;
+    }
+
+    /* okay... time to deliver the content */
+    if ((err = (*resource->hooks->deliver)(resource,
+                                           r->output_filters)) != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             "Unable to deliver content.",
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+
+    return DONE;
+}
+
+/* validate resource/locks on POST, then pass to the default handler */
+static int dav_method_post(request_rec *r)
+{
+    dav_resource *resource;
+    dav_error *err;
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    /* Note: depth == 0. Implies no need for a multistatus response. */
+    if ((err = dav_validate_request(r, resource, 0, NULL, NULL,
+                                    DAV_VALIDATE_RESOURCE, NULL)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, NULL);
+    }
+
+    return DECLINED;
+}
+
+/* handle the PUT method */
+static int dav_method_put(request_rec *r)
+{
+    dav_resource *resource;
+    int resource_state;
+    dav_auto_version_info av_info;
+    const dav_hooks_locks *locks_hooks = DAV_GET_HOOKS_LOCKS(r);
+    const char *body;
+    dav_error *err;
+    dav_error *err2;
+    dav_stream_mode mode;
+    dav_stream *stream;
+    dav_response *multi_response;
+    int has_range;
+    apr_off_t range_start;
+    apr_off_t range_end;
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    /* If not a file or collection resource, PUT not allowed */
+    if (resource->type != DAV_RESOURCE_TYPE_REGULAR
+        && resource->type != DAV_RESOURCE_TYPE_WORKING) {
+        body = apr_psprintf(r->pool,
+                            "Cannot create resource %s with PUT.",
+                            ap_escape_html(r->pool, r->uri));
+        return dav_error_response(r, HTTP_CONFLICT, body);
+    }
+
+    /* Cannot PUT a collection */
+    if (resource->collection) {
+        return dav_error_response(r, HTTP_CONFLICT,
+                                  "Cannot PUT to a collection.");
+
+    }
+
+    resource_state = dav_get_resource_state(r, resource);
+
+    /*
+     * 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.
+     */
+    if ((err = dav_validate_request(r, resource, 0, NULL, &multi_response,
+                                    resource_state == DAV_RESOURCE_NULL ?
+                                    DAV_VALIDATE_PARENT :
+                                    DAV_VALIDATE_RESOURCE, NULL)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, multi_response);
+    }
+
+    has_range = dav_parse_range(r, &range_start, &range_end);
+    if (has_range < 0) {
+        /* RFC 2616 14.16: If we receive an invalid Content-Range we must
+         * not use the content.
+         */
+        body = apr_psprintf(r->pool,
+                            "Malformed Content-Range header for PUT %s.",
+                            ap_escape_html(r->pool, r->uri));
+        return dav_error_response(r, HTTP_BAD_REQUEST, body);
+    } else if (has_range) {
+        mode = DAV_MODE_WRITE_SEEKABLE;
+    }
+    else {
+        mode = DAV_MODE_WRITE_TRUNC;
+    }
+
+    /* make sure the resource can be modified (if versioning repository) */
+    if ((err = dav_auto_checkout(r, resource,
+                                 0 /* not parent_only */,
+                                 &av_info)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* Create the new file in the repository */
+    if ((err = (*resource->hooks->open_stream)(resource, mode,
+                                               &stream)) != NULL) {
+        /* ### assuming FORBIDDEN is probably not quite right... */
+        err = dav_push_error(r->pool, HTTP_FORBIDDEN, 0,
+                             apr_psprintf(r->pool,
+                                          "Unable to PUT new contents for %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+    }
+
+    if (err == NULL && has_range) {
+        /* a range was provided. seek to the start */
+        err = (*resource->hooks->seek_stream)(stream, range_start);
+    }
+
+    if (err == NULL) {
+        apr_bucket_brigade *bb;
+        apr_bucket *b;
+        int seen_eos = 0;
+
+        bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
+
+        do {
+            apr_status_t rc;
+
+            rc = ap_get_brigade(r->input_filters, bb, AP_MODE_READBYTES,
+                                APR_BLOCK_READ, DAV_READ_BLOCKSIZE);
+
+            if (rc != APR_SUCCESS) {
+                int http_err;
+                char *msg = ap_escape_html(r->pool, r->uri);
+                http_err = ap_map_http_request_error(rc, HTTP_BAD_REQUEST);
+                msg = apr_psprintf(r->pool, "An error occurred while reading "
+                                            "the request body (URI: %s)",
+                                            msg);
+                err = dav_new_error(r->pool, http_err, 0, rc, msg);
+                break;
+            }
+
+            for (b = APR_BRIGADE_FIRST(bb);
+                 b != APR_BRIGADE_SENTINEL(bb);
+                 b = APR_BUCKET_NEXT(b))
+            {
+                const char *data;
+                apr_size_t len;
+
+                if (APR_BUCKET_IS_EOS(b)) {
+                    seen_eos = 1;
+                    break;
+                }
+
+                if (APR_BUCKET_IS_METADATA(b)) {
+                    continue;
+                }
+
+                if (err == NULL) {
+                    /* write whatever we read, until we see an error */
+                    rc = apr_bucket_read(b, &data, &len, APR_BLOCK_READ);
+                    if (rc != APR_SUCCESS) {
+                       err = dav_new_error(r->pool, HTTP_BAD_REQUEST, 0, rc,
+                                           apr_psprintf(r->pool,
+                                                        "An error occurred while"
+                                                        " reading the request body"
+                                                        " from the bucket (URI: %s)",
+                                                        ap_escape_html(r->pool, r->uri)));
+                        break;
+                    }
+
+                    err = (*resource->hooks->write_stream)(stream, data, len);
+                }
+            }
+
+            apr_brigade_cleanup(bb);
+        } while (!seen_eos);
+
+        apr_brigade_destroy(bb);
+
+        err2 = (*resource->hooks->close_stream)(stream,
+                                                err == NULL /* commit */);
+        err = dav_join_error(err, err2);
+    }
+
+    /*
+     * 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)
+     */
+    if (err == NULL) {
+        resource->exists = 1;
+    }
+
+    /* restore modifiability of resources back to what they were */
+    err2 = dav_auto_checkin(r, resource, err != NULL /* undo if error */,
+                            0 /*unlock*/, &av_info);
+
+    /* check for errors now */
+    if (err != NULL) {
+        err = dav_join_error(err, err2); /* don't forget err2 */
+        return dav_handle_err(r, err, NULL);
+    }
+
+    if (err2 != NULL) {
+        /* just log a warning */
+        err2 = dav_push_error(r->pool, err2->status, 0,
+                              "The PUT was successful, but there "
+                              "was a problem automatically checking in "
+                              "the resource or its parent collection.",
+                              err2);
+        dav_log_err(r, err2, APLOG_WARNING);
+    }
+
+    /* ### place the Content-Type and Content-Language into the propdb */
+
+    if (locks_hooks != NULL) {
+        dav_lockdb *lockdb;
+
+        if ((err = (*locks_hooks->open_lockdb)(r, 0, 0, &lockdb)) != NULL) {
+            /* The file creation was successful, but the locking failed. */
+            err = dav_push_error(r->pool, err->status, 0,
+                                 "The file was PUT successfully, but there "
+                                 "was a problem opening the lock database "
+                                 "which prevents inheriting locks from the "
+                                 "parent resources.",
+                                 err);
+            return dav_handle_err(r, err, NULL);
+        }
+
+        /* notify lock system that we have created/replaced a resource */
+        err = dav_notify_created(r, lockdb, resource, resource_state, 0);
+
+        (*locks_hooks->close_lockdb)(lockdb);
+
+        if (err != NULL) {
+            /* The file creation was successful, but the locking failed. */
+            err = dav_push_error(r->pool, err->status, 0,
+                                 "The file was PUT successfully, but there "
+                                 "was a problem updating its lock "
+                                 "information.",
+                                 err);
+            return dav_handle_err(r, err, NULL);
+        }
+    }
+
+    /* NOTE: WebDAV spec, S8.7.1 states properties should be unaffected */
+
+    /* return an appropriate response (HTTP_CREATED or HTTP_NO_CONTENT) */
+    return dav_created(r, NULL, "Resource", resource_state == DAV_RESOURCE_EXISTS);
+}
+
+
+/* Use POOL to temporarily construct a dav_response object (from WRES
+   STATUS, and PROPSTATS) and stream it via WRES's ctx->brigade. */
+static void dav_stream_response(dav_walk_resource *wres,
+                                int status,
+                                dav_get_props_result *propstats,
+                                apr_pool_t *pool)
+{
+    dav_response resp = { 0 };
+    dav_walker_ctx *ctx = wres->walk_ctx;
+
+    resp.href = wres->resource->uri;
+    resp.status = status;
+    if (propstats) {
+        resp.propresult = *propstats;
+    }
+
+    dav_send_one_response(&resp, ctx->bb, ctx->r, pool);
+}
+
+
+/* ### move this to dav_util? */
+DAV_DECLARE(void) dav_add_response(dav_walk_resource *wres,
+                                   int status, dav_get_props_result *propstats)
+{
+    dav_response *resp;
+
+    /* just drop some data into an dav_response */
+    resp = apr_pcalloc(wres->pool, sizeof(*resp));
+    resp->href = apr_pstrdup(wres->pool, wres->resource->uri);
+    resp->status = status;
+    if (propstats) {
+        resp->propresult = *propstats;
+    }
+
+    resp->next = wres->response;
+    wres->response = resp;
+}
+
+
+/* handle the DELETE method */
+static int dav_method_delete(request_rec *r)
+{
+    dav_resource *resource;
+    dav_auto_version_info av_info;
+    dav_error *err;
+    dav_error *err2;
+    dav_response *multi_response;
+    int result;
+    int depth;
+
+    /* We don't use the request body right now, so torch it. */
+    if ((result = ap_discard_request_body(r)) != OK) {
+        return result;
+    }
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+    if (!resource->exists) {
+        /* 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).
+     */
+    depth = dav_get_depth(r, DAV_INFINITY);
+
+    if (resource->collection && depth != DAV_INFINITY) {
+        /* This supplies additional information for the default message. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00582)
+                      "Depth must be \"infinity\" for DELETE of a collection.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    if (!resource->collection && depth == 1) {
+        /* This supplies additional information for the default message. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00583)
+                      "Depth of \"1\" is not allowed for DELETE.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /*
+    ** If any resources fail the lock/If: conditions, then we must fail
+    ** 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.
+    */
+    if ((err = dav_validate_request(r, resource, depth, NULL,
+                                    &multi_response,
+                                    DAV_VALIDATE_PARENT
+                                    | DAV_VALIDATE_USE_424, NULL)) != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not DELETE %s due to a failed "
+                                          "precondition (e.g. locks).",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, multi_response);
+    }
+
+    /* ### RFC 2518 s. 8.10.5 says to remove _all_ locks, not just those
+     *     locked by the token(s) in the if_header.
+     */
+    if ((result = dav_unlock(r, resource, NULL)) != OK) {
+        return result;
+    }
+
+    /* if versioned resource, make sure parent is checked out */
+    if ((err = dav_auto_checkout(r, resource, 1 /* parent_only */,
+                                 &av_info)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* try to remove the resource */
+    err = (*resource->hooks->remove_resource)(resource, &multi_response);
+
+    /* restore writability of parent back to what it was */
+    err2 = dav_auto_checkin(r, NULL, err != NULL /* undo if error */,
+                            0 /*unlock*/, &av_info);
+
+    /* check for errors now */
+    if (err != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not DELETE %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, multi_response);
+    }
+    if (err2 != NULL) {
+        /* just log a warning */
+        err = dav_push_error(r->pool, err2->status, 0,
+                             "The DELETE was successful, but there "
+                             "was a problem automatically checking in "
+                             "the parent collection.",
+                             err2);
+        dav_log_err(r, err, APLOG_WARNING);
+    }
+
+    /* ### 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;
+}
+
+/* generate DAV:supported-method-set OPTIONS response */
+static dav_error *dav_gen_supported_methods(request_rec *r,
+                                            const apr_xml_elem *elem,
+                                            const apr_table_t *methods,
+                                            apr_text_header *body)
+{
+    const apr_array_header_t *arr;
+    const apr_table_entry_t *elts;
+    apr_xml_elem *child;
+    apr_xml_attr *attr;
+    char *s;
+    int i;
+
+    apr_text_append(r->pool, body, "<D:supported-method-set>" DEBUG_CR);
+
+    if (elem->first_child == NULL) {
+        /* show all supported methods */
+        arr = apr_table_elts(methods);
+        elts = (const apr_table_entry_t *)arr->elts;
+
+        for (i = 0; i < arr->nelts; ++i) {
+            if (elts[i].key == NULL)
+                continue;
+
+            s = apr_psprintf(r->pool,
+                             "<D:supported-method D:name=\"%s\"/>"
+                             DEBUG_CR,
+                             elts[i].key);
+            apr_text_append(r->pool, body, s);
+        }
+    }
+    else {
+        /* check for support of specific methods */
+        for (child = elem->first_child; child != NULL; child = child->next) {
+            if (child->ns == APR_XML_NS_DAV_ID
+                && strcmp(child->name, "supported-method") == 0) {
+                const char *name = NULL;
+
+                /* go through attributes to find method name */
+                for (attr = child->attr; attr != NULL; attr = attr->next) {
+                    if (attr->ns == APR_XML_NS_DAV_ID
+                        && strcmp(attr->name, "name") == 0)
+                            name = attr->value;
+                }
+
+                if (name == NULL) {
+                    return dav_new_error(r->pool, HTTP_BAD_REQUEST, 0, 0,
+                                         "A DAV:supported-method element "
+                                         "does not have a \"name\" attribute");
+                }
+
+                /* see if method is supported */
+                if (apr_table_get(methods, name) != NULL) {
+                    s = apr_psprintf(r->pool,
+                                     "<D:supported-method D:name=\"%s\"/>"
+                                     DEBUG_CR,
+                                     name);
+                    apr_text_append(r->pool, body, s);
+                }
+            }
+        }
+    }
+
+    apr_text_append(r->pool, body, "</D:supported-method-set>" DEBUG_CR);
+    return NULL;
+}
+
+/* generate DAV:supported-live-property-set OPTIONS response */
+static dav_error *dav_gen_supported_live_props(request_rec *r,
+                                               const dav_resource *resource,
+                                               const apr_xml_elem *elem,
+                                               apr_text_header *body)
+{
+    dav_lockdb *lockdb;
+    dav_propdb *propdb;
+    apr_xml_elem *child;
+    apr_xml_attr *attr;
+    dav_error *err;
+
+    /* open lock database, to report on supported lock properties */
+    /* ### should open read-only */
+    if ((err = dav_open_lockdb(r, 0, &lockdb)) != NULL) {
+        return dav_push_error(r->pool, err->status, 0,
+                              "The lock database could not be opened, "
+                              "preventing the reporting of supported lock "
+                              "properties.",
+                              err);
+    }
+
+    /* open the property database (readonly) for the resource */
+    if ((err = dav_open_propdb(r, lockdb, resource, 1, NULL,
+                               &propdb)) != NULL) {
+        if (lockdb != NULL)
+            (*lockdb->hooks->close_lockdb)(lockdb);
+
+        return dav_push_error(r->pool, err->status, 0,
+                              "The property database could not be opened, "
+                              "preventing report of supported properties.",
+                              err);
+    }
+
+    apr_text_append(r->pool, body, "<D:supported-live-property-set>" DEBUG_CR);
+
+    if (elem->first_child == NULL) {
+        /* show all supported live properties */
+        dav_get_props_result props = dav_get_allprops(propdb, DAV_PROP_INSERT_SUPPORTED);
+        body->last->next = props.propstats;
+        while (body->last->next != NULL)
+            body->last = body->last->next;
+    }
+    else {
+        /* check for support of specific live property */
+        for (child = elem->first_child; child != NULL; child = child->next) {
+            if (child->ns == APR_XML_NS_DAV_ID
+                && strcmp(child->name, "supported-live-property") == 0) {
+                const char *name = NULL;
+                const char *nmspace = NULL;
+
+                /* go through attributes to find name and namespace */
+                for (attr = child->attr; attr != NULL; attr = attr->next) {
+                    if (attr->ns == APR_XML_NS_DAV_ID) {
+                        if (strcmp(attr->name, "name") == 0)
+                            name = attr->value;
+                        else if (strcmp(attr->name, "namespace") == 0)
+                            nmspace = attr->value;
+                    }
+                }
+
+                if (name == NULL) {
+                    err = dav_new_error(r->pool, HTTP_BAD_REQUEST, 0, 0,
+                                        "A DAV:supported-live-property "
+                                        "element does not have a \"name\" "
+                                        "attribute");
+                    break;
+                }
+
+                /* default namespace to DAV: */
+                if (nmspace == NULL)
+                    nmspace = "DAV:";
+
+                /* check for support of property */
+                dav_get_liveprop_supported(propdb, nmspace, name, body);
+            }
+        }
+    }
+
+    apr_text_append(r->pool, body, "</D:supported-live-property-set>" DEBUG_CR);
+
+    dav_close_propdb(propdb);
+
+    if (lockdb != NULL)
+        (*lockdb->hooks->close_lockdb)(lockdb);
+
+    return err;
+}
+
+/* generate DAV:supported-report-set OPTIONS response */
+static dav_error *dav_gen_supported_reports(request_rec *r,
+                                            const dav_resource *resource,
+                                            const apr_xml_elem *elem,
+                                            const dav_hooks_vsn *vsn_hooks,
+                                            apr_text_header *body)
+{
+    apr_xml_elem *child;
+    apr_xml_attr *attr;
+    dav_error *err;
+    char *s;
+
+    apr_text_append(r->pool, body, "<D:supported-report-set>" DEBUG_CR);
+
+    if (vsn_hooks != NULL) {
+        const dav_report_elem *reports;
+        const dav_report_elem *rp;
+
+        if ((err = (*vsn_hooks->avail_reports)(resource, &reports)) != NULL) {
+            return dav_push_error(r->pool, err->status, 0,
+                                  "DAV:supported-report-set could not be "
+                                  "determined due to a problem fetching the "
+                                  "available reports for this resource.",
+                                  err);
+        }
+
+        if (reports != NULL) {
+            if (elem->first_child == NULL) {
+                /* show all supported reports */
+                for (rp = reports; rp->nmspace != NULL; ++rp) {
+                    /* Note: we presume reports->namespace is
+                     * properly XML/URL quoted */
+                    s = apr_psprintf(r->pool,
+                                     "<D:supported-report D:name=\"%s\" "
+                                     "D:namespace=\"%s\"/>" DEBUG_CR,
+                                     rp->name, rp->nmspace);
+                    apr_text_append(r->pool, body, s);
+                }
+            }
+            else {
+                /* check for support of specific report */
+                for (child = elem->first_child; child != NULL; child = child->next) {
+                    if (child->ns == APR_XML_NS_DAV_ID
+                        && strcmp(child->name, "supported-report") == 0) {
+                        const char *name = NULL;
+                        const char *nmspace = NULL;
+
+                        /* go through attributes to find name and namespace */
+                        for (attr = child->attr; attr != NULL; attr = attr->next) {
+                            if (attr->ns == APR_XML_NS_DAV_ID) {
+                                if (strcmp(attr->name, "name") == 0)
+                                    name = attr->value;
+                                else if (strcmp(attr->name, "namespace") == 0)
+                                    nmspace = attr->value;
+                            }
+                        }
+
+                        if (name == NULL) {
+                            return dav_new_error(r->pool, HTTP_BAD_REQUEST, 0, 0,
+                                                 "A DAV:supported-report element "
+                                                 "does not have a \"name\" attribute");
+                        }
+
+                        /* default namespace to DAV: */
+                        if (nmspace == NULL)
+                            nmspace = "DAV:";
+
+                        for (rp = reports; rp->nmspace != NULL; ++rp) {
+                            if (strcmp(name, rp->name) == 0
+                                && strcmp(nmspace, rp->nmspace) == 0) {
+                                /* Note: we presume reports->nmspace is
+                                 * properly XML/URL quoted
+                                 */
+                                s = apr_psprintf(r->pool,
+                                                 "<D:supported-report "
+                                                 "D:name=\"%s\" "
+                                                 "D:namespace=\"%s\"/>"
+                                                 DEBUG_CR,
+                                                 rp->name, rp->nmspace);
+                                apr_text_append(r->pool, body, s);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    apr_text_append(r->pool, body, "</D:supported-report-set>" DEBUG_CR);
+    return NULL;
+}
+
+
+/* handle the SEARCH method */
+static int dav_method_search(request_rec *r)
+{
+    const dav_hooks_search *search_hooks = DAV_GET_HOOKS_SEARCH(r);
+    dav_resource *resource;
+    dav_error *err;
+    dav_response *multi_status;
+
+    /* If no search provider, decline the request */
+    if (search_hooks == NULL)
+        return DECLINED;
+
+    /* 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.
+     */
+    err = dav_get_resource(r, 1 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    if (!resource->exists) {
+        /* Apache will supply a default error for this. */
+        return HTTP_NOT_FOUND;
+    }
+
+    /* set up the HTTP headers for the response */
+    if ((err = (*resource->hooks->set_headers)(r, resource)) != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             "Unable to set up HTTP headers.",
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+
+    if (r->header_only) {
+        return DONE;
+    }
+
+    /* okay... time to search the content */
+    /* Let's validate XML and process walk function
+     * in the hook function
+     */
+    if ((err = (*search_hooks->search_resource)(r, &multi_status)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* We have results in multi_status */
+    /* Should I pass namespace?? */
+    dav_send_multistatus(r, HTTP_MULTI_STATUS, multi_status, NULL);
+
+    return DONE;
+}
+
+
+/* handle the OPTIONS method */
+static int dav_method_options(request_rec *r)
+{
+    const dav_hooks_locks *locks_hooks = DAV_GET_HOOKS_LOCKS(r);
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    const dav_hooks_binding *binding_hooks = DAV_GET_HOOKS_BINDING(r);
+    const dav_hooks_search *search_hooks = DAV_GET_HOOKS_SEARCH(r);
+    dav_resource *resource;
+    const char *dav_level;
+    char *allow;
+    char *s;
+    const apr_array_header_t *arr;
+    const apr_table_entry_t *elts;
+    apr_table_t *methods = apr_table_make(r->pool, 12);
+    apr_text_header vsn_options = { 0 };
+    apr_text_header body = { 0 };
+    apr_text *t;
+    int text_size;
+    int result;
+    int i;
+    apr_array_header_t *uri_ary;
+    apr_xml_doc *doc;
+    const apr_xml_elem *elem;
+    dav_error *err;
+
+    apr_array_header_t *extensions;
+    ap_list_provider_names_t *entry;
+
+    /* resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    /* parse any request body */
+    if ((result = ap_xml_parse_input(r, &doc)) != OK) {
+        return result;
+    }
+    /* note: doc == NULL if no request body */
+
+    if (doc && !dav_validate_root(doc, "options")) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00584)
+                      "The \"options\" element was not found.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* determine which providers are available */
+    dav_level = "1";
+
+    if (locks_hooks != NULL) {
+        dav_level = "1,2";
+    }
+
+    if (binding_hooks != NULL)
+        dav_level = apr_pstrcat(r->pool, dav_level, ",bindings", NULL);
+
+    /* DAV header additions registered by external modules */
+    extensions = ap_list_provider_names(r->pool, DAV_OPTIONS_EXTENSION_GROUP, "0");
+    entry = (ap_list_provider_names_t *)extensions->elts;
+
+    for (i = 0; i < extensions->nelts; i++, entry++) {
+        const dav_options_provider *options =
+            dav_get_options_providers(entry->provider_name);
+
+        if (options && options->dav_header) {
+            apr_text_header hoptions = { 0 };
+
+            options->dav_header(r, resource, &hoptions);
+            for (t = hoptions.first; t && t->text; t = t->next)
+                dav_level = apr_pstrcat(r->pool, dav_level, ",", t->text, NULL);
+        }
+    }
+
+    /* ###
+     * MSFT Web Folders chokes if length of DAV header value > 63 characters!
+     * To workaround that, we use separate DAV headers for versioning and
+     * live prop provider namespace URIs.
+     * ###
+     */
+    apr_table_setn(r->headers_out, "DAV", dav_level);
+
+    /*
+     * If there is a versioning provider, generate DAV headers
+     * for versioning options.
+     */
+    if (vsn_hooks != NULL) {
+        (*vsn_hooks->get_vsn_options)(r->pool, &vsn_options);
+
+        for (t = vsn_options.first; t != NULL; t = t->next)
+            apr_table_addn(r->headers_out, "DAV", t->text);
+    }
+
+    /*
+     * Gather property set URIs from all the liveprop providers,
+     * and generate a separate DAV header for each URI, to avoid
+     * problems with long header lengths.
+     */
+    uri_ary = apr_array_make(r->pool, 5, sizeof(const char *));
+    dav_run_gather_propsets(uri_ary);
+    for (i = 0; i < uri_ary->nelts; ++i) {
+        if (((char **)uri_ary->elts)[i] != NULL)
+            apr_table_addn(r->headers_out, "DAV", ((char **)uri_ary->elts)[i]);
+    }
+
+    /* this tells MSFT products to skip looking for FrontPage extensions */
+    apr_table_setn(r->headers_out, "MS-Author-Via", "DAV");
+
+    /*
+     * Determine which methods are allowed on the resource.
+     * Three cases:  resource is null (3), is lock-null (7.4), or exists.
+     *
+     * All cases support OPTIONS, and if there is a lock provider, LOCK.
+     * (Lock-) null resources also support MKCOL and PUT.
+     * Lock-null supports PROPFIND and UNLOCK.
+     * Existing resources support lots of stuff.
+     */
+
+    apr_table_addn(methods, "OPTIONS", "");
+
+    /* ### take into account resource type */
+    switch (dav_get_resource_state(r, resource))
+    {
+    case DAV_RESOURCE_EXISTS:
+        /* resource exists */
+        apr_table_addn(methods, "GET", "");
+        apr_table_addn(methods, "HEAD", "");
+        apr_table_addn(methods, "POST", "");
+        apr_table_addn(methods, "DELETE", "");
+        apr_table_addn(methods, "TRACE", "");
+        apr_table_addn(methods, "PROPFIND", "");
+        apr_table_addn(methods, "PROPPATCH", "");
+        apr_table_addn(methods, "COPY", "");
+        apr_table_addn(methods, "MOVE", "");
+
+        if (!resource->collection)
+            apr_table_addn(methods, "PUT", "");
+
+        if (locks_hooks != NULL) {
+            apr_table_addn(methods, "LOCK", "");
+            apr_table_addn(methods, "UNLOCK", "");
+        }
+
+        break;
+
+    case DAV_RESOURCE_LOCK_NULL:
+        /* resource is lock-null. */
+        apr_table_addn(methods, "MKCOL", "");
+        apr_table_addn(methods, "PROPFIND", "");
+        apr_table_addn(methods, "PUT", "");
+
+        if (locks_hooks != NULL) {
+            apr_table_addn(methods, "LOCK", "");
+            apr_table_addn(methods, "UNLOCK", "");
+        }
+
+        break;
+
+    case DAV_RESOURCE_NULL:
+        /* resource is null. */
+        apr_table_addn(methods, "MKCOL", "");
+        apr_table_addn(methods, "PUT", "");
+
+        if (locks_hooks != NULL)
+            apr_table_addn(methods, "LOCK", "");
+
+        break;
+
+    default:
+        /* ### internal error! */
+        break;
+    }
+
+    /* If there is a versioning provider, add versioning methods */
+    if (vsn_hooks != NULL) {
+        if (!resource->exists) {
+            if ((*vsn_hooks->versionable)(resource))
+                apr_table_addn(methods, "VERSION-CONTROL", "");
+
+            if (vsn_hooks->can_be_workspace != NULL
+                && (*vsn_hooks->can_be_workspace)(resource))
+                apr_table_addn(methods, "MKWORKSPACE", "");
+
+            if (vsn_hooks->can_be_activity != NULL
+                && (*vsn_hooks->can_be_activity)(resource))
+                apr_table_addn(methods, "MKACTIVITY", "");
+        }
+        else if (!resource->versioned) {
+            if ((*vsn_hooks->versionable)(resource))
+                apr_table_addn(methods, "VERSION-CONTROL", "");
+        }
+        else if (resource->working) {
+            apr_table_addn(methods, "CHECKIN", "");
+
+            /* ### we might not support this DeltaV option */
+            apr_table_addn(methods, "UNCHECKOUT", "");
+        }
+        else if (vsn_hooks->add_label != NULL) {
+            apr_table_addn(methods, "CHECKOUT", "");
+            apr_table_addn(methods, "LABEL", "");
+        }
+        else {
+            apr_table_addn(methods, "CHECKOUT", "");
+        }
+    }
+
+    /* If there is a bindings provider, see if resource is bindable */
+    if (binding_hooks != NULL
+        && (*binding_hooks->is_bindable)(resource)) {
+        apr_table_addn(methods, "BIND", "");
+    }
+
+    /* If there is a search provider, set SEARCH in option */
+    if (search_hooks != NULL) {
+        apr_table_addn(methods, "SEARCH", "");
+    }
+
+    /* additional methods registered by external modules */
+    extensions = ap_list_provider_names(r->pool, DAV_OPTIONS_EXTENSION_GROUP, "0");
+    entry = (ap_list_provider_names_t *)extensions->elts;
+
+    for (i = 0; i < extensions->nelts; i++, entry++) {
+        const dav_options_provider *options =
+            dav_get_options_providers(entry->provider_name);
+
+        if (options && options->dav_method) {
+            apr_text_header hoptions = { 0 };
+
+            options->dav_method(r, resource, &hoptions);
+            for (t = hoptions.first; t && t->text; t = t->next)
+                apr_table_addn(methods, t->text, "");
+        }
+    }
+
+    /* Generate the Allow header */
+    arr = apr_table_elts(methods);
+    elts = (const apr_table_entry_t *)arr->elts;
+    text_size = 0;
+
+    /* first, compute total length */
+    for (i = 0; i < arr->nelts; ++i) {
+        if (elts[i].key == NULL)
+            continue;
+
+        /* add 1 for comma or null */
+        text_size += strlen(elts[i].key) + 1;
+    }
+
+    s = allow = apr_palloc(r->pool, text_size);
+
+    for (i = 0; i < arr->nelts; ++i) {
+        if (elts[i].key == NULL)
+            continue;
+
+        if (s != allow)
+            *s++ = ',';
+
+        strcpy(s, elts[i].key);
+        s += strlen(s);
+    }
+
+    apr_table_setn(r->headers_out, "Allow", allow);
+
+
+    /* If there is search set_option_head function, set head */
+    /* DASL: <DAV:basicsearch>
+     * DASL: <http://foo.bar.com/syntax1>
+     * DASL: <http://akuma.com/syntax2>
+     */
+    if (search_hooks != NULL
+        && *search_hooks->set_option_head != NULL) {
+        if ((err = (*search_hooks->set_option_head)(r)) != NULL) {
+            return dav_handle_err(r, err, NULL);
+        }
+    }
+
+    /* if there was no request body, then there is no response body */
+    if (doc == NULL) {
+        ap_set_content_length(r, 0);
+
+        /* ### this sends 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. */
+        return DONE;
+    }
+
+    /* handle each options request */
+    for (elem = doc->root->first_child; elem != NULL; elem = elem->next) {
+        /* check for something we recognize first */
+        int core_option = 0;
+        dav_error *err = NULL;
+
+        if (elem->ns == APR_XML_NS_DAV_ID) {
+            if (strcmp(elem->name, "supported-method-set") == 0) {
+                err = dav_gen_supported_methods(r, elem, methods, &body);
+                core_option = 1;
+            }
+            else if (strcmp(elem->name, "supported-live-property-set") == 0) {
+                err = dav_gen_supported_live_props(r, resource, elem, &body);
+                core_option = 1;
+            }
+            else if (strcmp(elem->name, "supported-report-set") == 0) {
+                err = dav_gen_supported_reports(r, resource, elem, vsn_hooks, &body);
+                core_option = 1;
+            }
+        }
+
+        if (err != NULL)
+            return dav_handle_err(r, err, NULL);
+
+        /* if unrecognized option, pass to versioning provider */
+        if (!core_option && vsn_hooks != NULL) {
+            if ((err = (*vsn_hooks->get_option)(resource, elem, &body))
+                != NULL) {
+                return dav_handle_err(r, err, NULL);
+            }
+        }
+    }
+
+    /* send the options response */
+    r->status = HTTP_OK;
+    ap_set_content_type(r, DAV_XML_CONTENT_TYPE);
+
+    /* send the headers and response body */
+    ap_rputs(DAV_XML_HEADER DEBUG_CR
+             "<D:options-response xmlns:D=\"DAV:\">" DEBUG_CR, r);
+
+    for (t = body.first; t != NULL; t = t->next)
+        ap_rputs(t->text, r);
+
+    ap_rputs("</D:options-response>" DEBUG_CR, r);
+
+    /* we've sent everything necessary to the client. */
+    return DONE;
+}
+
+static void dav_cache_badprops(dav_walker_ctx *ctx)
+{
+    const apr_xml_elem *elem;
+    apr_text_header hdr = { 0 };
+
+    /* just return if we built the thing already */
+    if (ctx->propstat_404 != NULL) {
+        return;
+    }
+
+    apr_text_append(ctx->w.pool, &hdr,
+                    "<D:propstat>" DEBUG_CR
+                    "<D:prop>" DEBUG_CR);
+
+    elem = dav_find_child(ctx->doc->root, "prop");
+    for (elem = elem->first_child; elem; elem = elem->next) {
+        apr_text_append(ctx->w.pool, &hdr,
+                        apr_xml_empty_elem(ctx->w.pool, elem));
+    }
+
+    apr_text_append(ctx->w.pool, &hdr,
+                    "</D:prop>" DEBUG_CR
+                    "<D:status>HTTP/1.1 404 Not Found</D:status>" DEBUG_CR
+                    "</D:propstat>" DEBUG_CR);
+
+    ctx->propstat_404 = hdr.first;
+}
+
+static dav_error * dav_propfind_walker(dav_walk_resource *wres, int calltype)
+{
+    dav_walker_ctx *ctx = wres->walk_ctx;
+    dav_error *err;
+    dav_propdb *propdb;
+    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.
+    */
+    err = dav_open_propdb(ctx->r, ctx->w.lockdb, wres->resource, 1,
+                          ctx->doc ? ctx->doc->namespaces : NULL, &propdb);
+    if (err != NULL) {
+        /* ### do something with err! */
+
+        if (ctx->propfind_type == DAV_PROPFIND_IS_PROP) {
+            dav_get_props_result badprops = { 0 };
+
+            /* some props were expected on this collection/resource */
+            dav_cache_badprops(ctx);
+            badprops.propstats = ctx->propstat_404;
+            dav_stream_response(wres, 0, &badprops, ctx->scratchpool);
+        }
+        else {
+            /* no props on this collection/resource */
+            dav_stream_response(wres, HTTP_OK, NULL, ctx->scratchpool);
+        }
+
+        apr_pool_clear(ctx->scratchpool);
+        return NULL;
+    }
+    /* ### what to do about closing the propdb on server failure? */
+
+    if (ctx->propfind_type == DAV_PROPFIND_IS_PROP) {
+        propstats = dav_get_props(propdb, ctx->doc);
+    }
+    else {
+        dav_prop_insert what = ctx->propfind_type == DAV_PROPFIND_IS_ALLPROP
+                                 ? DAV_PROP_INSERT_VALUE
+                                 : DAV_PROP_INSERT_NAME;
+        propstats = dav_get_allprops(propdb, what);
+    }
+    dav_close_propdb(propdb);
+
+    dav_stream_response(wres, 0, &propstats, ctx->scratchpool);
+
+    /* at this point, ctx->scratchpool has been used to stream a
+       single response.  this function fully controls the pool, and
+       thus has the right to clear it for the next iteration of this
+       callback. */
+    apr_pool_clear(ctx->scratchpool);
+
+    return NULL;
+}
+
+/* handle the PROPFIND method */
+static int dav_method_propfind(request_rec *r)
+{
+    dav_resource *resource;
+    int depth;
+    dav_error *err;
+    int result;
+    apr_xml_doc *doc;
+    dav_walker_ctx ctx = { { 0 } };
+    dav_response *multi_status;
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 1 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    if (dav_get_resource_state(r, resource) == DAV_RESOURCE_NULL) {
+        /* Apache will supply a default error for this. */
+        return HTTP_NOT_FOUND;
+    }
+
+    if ((depth = dav_get_depth(r, DAV_INFINITY)) < 0) {
+        /* dav_get_depth() supplies additional information for the
+         * default message. */
+        return HTTP_BAD_REQUEST;
+    }
+
+    if (depth == DAV_INFINITY && resource->collection) {
+        dav_dir_conf *conf;
+        conf = (dav_dir_conf *)ap_get_module_config(r->per_dir_config,
+                                                    &dav_module);
+        /* default is to DISALLOW these requests */
+        if (conf->allow_depthinfinity != DAV_ENABLED_ON) {
+            return dav_error_response(r, HTTP_FORBIDDEN,
+                                      apr_psprintf(r->pool,
+                                                   "PROPFIND requests with a "
+                                                   "Depth of \"infinity\" are "
+                                                   "not allowed for %s.",
+                                                   ap_escape_html(r->pool,
+                                                                  r->uri)));
+        }
+    }
+
+    if ((result = ap_xml_parse_input(r, &doc)) != OK) {
+        return result;
+    }
+    /* note: doc == NULL if no request body */
+
+    if (doc && !dav_validate_root(doc, "propfind")) {
+        /* This supplies additional information for the default message. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00585)
+                      "The \"propfind\" element was not found.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* ### validate that only one of these three elements is present */
+
+    if (doc == NULL || dav_find_child(doc->root, "allprop") != NULL) {
+        /* note: no request body implies allprop */
+        ctx.propfind_type = DAV_PROPFIND_IS_ALLPROP;
+    }
+    else if (dav_find_child(doc->root, "propname") != NULL) {
+        ctx.propfind_type = DAV_PROPFIND_IS_PROPNAME;
+    }
+    else if (dav_find_child(doc->root, "prop") != NULL) {
+        ctx.propfind_type = DAV_PROPFIND_IS_PROP;
+    }
+    else {
+        /* "propfind" element must have one of the above three children */
+
+        /* This supplies additional information for the default message. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00586)
+                      "The \"propfind\" element does not contain one of "
+                      "the required child elements (the specific command).");
+        return HTTP_BAD_REQUEST;
+    }
+
+    ctx.w.walk_type = DAV_WALKTYPE_NORMAL | DAV_WALKTYPE_AUTH;
+    ctx.w.func = dav_propfind_walker;
+    ctx.w.walk_ctx = &ctx;
+    ctx.w.pool = r->pool;
+    ctx.w.root = resource;
+
+    ctx.doc = doc;
+    ctx.r = r;
+    ctx.bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
+    apr_pool_create(&ctx.scratchpool, r->pool);
+
+    /* ### should open read-only */
+    if ((err = dav_open_lockdb(r, 0, &ctx.w.lockdb)) != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             "The lock database could not be opened, "
+                             "preventing access to the various lock "
+                             "properties for the PROPFIND.",
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+    if (ctx.w.lockdb != NULL) {
+        /* if we have a lock database, then we can walk locknull resources */
+        ctx.w.walk_type |= DAV_WALKTYPE_LOCKNULL;
+    }
+
+    /* send <multistatus> tag, with all doc->namespaces attached.  */
+
+    /* NOTE: we *cannot* leave out the doc's namespaces from the
+       initial <multistatus> tag.  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. */
+    dav_begin_multistatus(ctx.bb, r, HTTP_MULTI_STATUS,
+                          doc ? doc->namespaces : NULL);
+
+    /* Have the provider walk the resource. */
+    err = (*resource->hooks->walk)(&ctx.w, depth, &multi_status);
+
+    if (ctx.w.lockdb != NULL) {
+        (*ctx.w.lockdb->hooks->close_lockdb)(ctx.w.lockdb);
+    }
+
+    if (err != NULL) {
+        /* If an error occurred during the resource walk, there's
+           basically nothing we can do but abort the connection and
+           log an error.  This is one of the limitations of HTTP; it
+           needs to "know" the entire status of the response before
+           generating it, which is just impossible in these streamy
+           response situations. */
+        err = dav_push_error(r->pool, err->status, 0,
+                             "Provider encountered an error while streaming"
+                             " a multistatus PROPFIND response.", err);
+        dav_log_err(r, err, APLOG_ERR);
+        r->connection->aborted = 1;
+        return DONE;
+    }
+
+    dav_finish_multistatus(r, ctx.bb);
+
+    /* the response has been sent. */
+    return DONE;
+}
+
+DAV_DECLARE(apr_text *) dav_failed_proppatch(apr_pool_t *p,
+                                             apr_array_header_t *prop_ctx)
+{
+    apr_text_header hdr = { 0 };
+    int i = prop_ctx->nelts;
+    dav_prop_ctx *ctx = (dav_prop_ctx *)prop_ctx->elts;
+    dav_error *err424_set = NULL;
+    dav_error *err424_delete = NULL;
+    const char *s;
+
+    /* ### might be nice to sort by status code and description */
+
+    for ( ; i-- > 0; ++ctx ) {
+        apr_text_append(p, &hdr,
+                        "<D:propstat>" DEBUG_CR
+                        "<D:prop>");
+        apr_text_append(p, &hdr, apr_xml_empty_elem(p, ctx->prop));
+        apr_text_append(p, &hdr, "</D:prop>" DEBUG_CR);
+
+        if (ctx->err == NULL) {
+            /* nothing was assigned here yet, so make it a 424 */
+
+            if (ctx->operation == DAV_PROP_OP_SET) {
+                if (err424_set == NULL)
+                    err424_set = dav_new_error(p, HTTP_FAILED_DEPENDENCY, 0, 0,
+                                               "Attempted DAV:set operation "
+                                               "could not be completed due "
+                                               "to other errors.");
+                ctx->err = err424_set;
+            }
+            else if (ctx->operation == DAV_PROP_OP_DELETE) {
+                if (err424_delete == NULL)
+                    err424_delete = dav_new_error(p, HTTP_FAILED_DEPENDENCY, 0, 0,
+                                                  "Attempted DAV:remove "
+                                                  "operation could not be "
+                                                  "completed due to other "
+                                                  "errors.");
+                ctx->err = err424_delete;
+            }
+        }
+
+        s = apr_psprintf(p,
+                         "<D:status>"
+                         "HTTP/1.1 %d (status)"
+                         "</D:status>" DEBUG_CR,
+                         ctx->err->status);
+        apr_text_append(p, &hdr, s);
+
+        /* ### we should use compute_desc if necessary... */
+        if (ctx->err->desc != NULL) {
+            apr_text_append(p, &hdr, "<D:responsedescription>" DEBUG_CR);
+            apr_text_append(p, &hdr, ctx->err->desc);
+            apr_text_append(p, &hdr, "</D:responsedescription>" DEBUG_CR);
+        }
+
+        apr_text_append(p, &hdr, "</D:propstat>" DEBUG_CR);
+    }
+
+    return hdr.first;
+}
+
+DAV_DECLARE(apr_text *) dav_success_proppatch(apr_pool_t *p,
+                                              apr_array_header_t *prop_ctx)
+{
+    apr_text_header hdr = { 0 };
+    int i = prop_ctx->nelts;
+    dav_prop_ctx *ctx = (dav_prop_ctx *)prop_ctx->elts;
+
+    /*
+     * ### we probably need to revise the way we assemble the response...
+     * ### this code assumes everything will return status==200.
+     */
+
+    apr_text_append(p, &hdr,
+                    "<D:propstat>" DEBUG_CR
+                    "<D:prop>" DEBUG_CR);
+
+    for ( ; i-- > 0; ++ctx ) {
+        apr_text_append(p, &hdr, apr_xml_empty_elem(p, ctx->prop));
+    }
+
+    apr_text_append(p, &hdr,
+                   "</D:prop>" DEBUG_CR
+                   "<D:status>HTTP/1.1 200 OK</D:status>" DEBUG_CR
+                   "</D:propstat>" DEBUG_CR);
+
+    return hdr.first;
+}
+
+static void dav_prop_log_errors(dav_prop_ctx *ctx)
+{
+    dav_log_err(ctx->r, ctx->err, APLOG_ERR);
+}
+
+/*
+ * 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.
+ */
+static int dav_process_ctx_list(void (*func)(dav_prop_ctx *ctx),
+                                apr_array_header_t *ctx_list, int stop_on_error,
+                                int reverse)
+{
+    int i = ctx_list->nelts;
+    dav_prop_ctx *ctx = (dav_prop_ctx *)ctx_list->elts;
+
+    if (reverse)
+        ctx += i;
+
+    while (i--) {
+        if (reverse)
+            --ctx;
+
+        (*func)(ctx);
+        if (stop_on_error && DAV_PROP_CTX_HAS_ERR(*ctx)) {
+            return 1;
+        }
+
+        if (!reverse)
+            ++ctx;
+    }
+
+    return 0;
+}
+
+/* handle the PROPPATCH method */
+static int dav_method_proppatch(request_rec *r)
+{
+    dav_error *err;
+    dav_resource *resource;
+    int result;
+    apr_xml_doc *doc;
+    apr_xml_elem *child;
+    dav_propdb *propdb;
+    int failure = 0;
+    dav_response resp = { 0 };
+    apr_text *propstat_text;
+    apr_array_header_t *ctx_list;
+    dav_prop_ctx *ctx;
+    dav_auto_version_info av_info;
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+    if (!resource->exists) {
+        /* Apache will supply a default error for this. */
+        return HTTP_NOT_FOUND;
+    }
+
+    if ((result = ap_xml_parse_input(r, &doc)) != OK) {
+        return result;
+    }
+    /* note: doc == NULL if no request body */
+
+    if (doc == NULL || !dav_validate_root(doc, "propertyupdate")) {
+        /* This supplies additional information for the default message. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00587)
+                      "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. */
+    if ((err = dav_validate_request(r, resource, 0, NULL, NULL,
+                                    DAV_VALIDATE_RESOURCE, NULL)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* make sure the resource can be modified (if versioning repository) */
+    if ((err = dav_auto_checkout(r, resource,
+                                 0 /* not parent_only */,
+                                 &av_info)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, NULL);
+    }
+
+    if ((err = dav_open_propdb(r, NULL, resource, 0, doc->namespaces,
+                               &propdb)) != NULL) {
+        /* undo any auto-checkout */
+        dav_auto_checkin(r, resource, 1 /*undo*/, 0 /*unlock*/, &av_info);
+
+        err = dav_push_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not open the property "
+                                          "database for %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+    /* ### what to do about closing the propdb on server failure? */
+
+    /* ### validate "live" properties */
+
+    /* set up an array to hold property operation contexts */
+    ctx_list = apr_array_make(r->pool, 10, sizeof(dav_prop_ctx));
+
+    /* do a first pass to ensure that all "remove" properties exist */
+    for (child = doc->root->first_child; child; child = child->next) {
+        int is_remove;
+        apr_xml_elem *prop_group;
+        apr_xml_elem *one_prop;
+
+        /* Ignore children that are not set/remove */
+        if (child->ns != APR_XML_NS_DAV_ID
+            || (!(is_remove = (strcmp(child->name, "remove") == 0))
+                && strcmp(child->name, "set") != 0)) {
+            continue;
+        }
+
+        /* make sure that a "prop" child exists for set/remove */
+        if ((prop_group = dav_find_child(child, "prop")) == NULL) {
+            dav_close_propdb(propdb);
+
+            /* undo any auto-checkout */
+            dav_auto_checkin(r, resource, 1 /*undo*/, 0 /*unlock*/, &av_info);
+
+            /* This supplies additional information for the default message. */
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00588)
+                          "A \"prop\" element is missing inside "
+                          "the propertyupdate command.");
+            return HTTP_BAD_REQUEST;
+        }
+
+        for (one_prop = prop_group->first_child; one_prop;
+             one_prop = one_prop->next) {
+
+            ctx = (dav_prop_ctx *)apr_array_push(ctx_list);
+            ctx->propdb = propdb;
+            ctx->operation = is_remove ? DAV_PROP_OP_DELETE : DAV_PROP_OP_SET;
+            ctx->prop = one_prop;
+
+            ctx->r = r;         /* for later use by dav_prop_log_errors() */
+
+            dav_prop_validate(ctx);
+
+            if ( DAV_PROP_CTX_HAS_ERR(*ctx) ) {
+                failure = 1;
+            }
+        }
+    }
+
+    /* ### should test that we found at least one set/remove */
+
+    /* execute all of the operations */
+    if (!failure && dav_process_ctx_list(dav_prop_exec, ctx_list, 1, 0)) {
+        failure = 1;
+    }
+
+    /* generate a failure/success response */
+    if (failure) {
+        (void)dav_process_ctx_list(dav_prop_rollback, ctx_list, 0, 1);
+        propstat_text = dav_failed_proppatch(r->pool, ctx_list);
+    }
+    else {
+        (void)dav_process_ctx_list(dav_prop_commit, ctx_list, 0, 0);
+        propstat_text = dav_success_proppatch(r->pool, ctx_list);
+    }
+
+    /* make sure this gets closed! */
+    dav_close_propdb(propdb);
+
+    /* complete any auto-versioning */
+    dav_auto_checkin(r, resource, failure, 0 /*unlock*/, &av_info);
+
+    /* log any errors that occurred */
+    (void)dav_process_ctx_list(dav_prop_log_errors, ctx_list, 0, 0);
+
+    resp.href = resource->uri;
+
+    /* ### should probably use something new to pass along this text... */
+    resp.propresult.propstats = propstat_text;
+
+    dav_send_multistatus(r, HTTP_MULTI_STATUS, &resp, doc->namespaces);
+
+    /* 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). */
+
+    const char *tenc = apr_table_get(r->headers_in, "Transfer-Encoding");
+    const char *lenp = apr_table_get(r->headers_in, "Content-Length");
+
+    /* make sure to set the Apache request fields properly. */
+    r->read_body = REQUEST_NO_BODY;
+    r->read_chunked = 0;
+    r->remaining = 0;
+
+    if (tenc) {
+        if (strcasecmp(tenc, "chunked")) {
+            /* Use this instead of Apache's default error string */
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00589)
+                          "Unknown Transfer-Encoding %s", tenc);
+            return HTTP_NOT_IMPLEMENTED;
+        }
+
+        r->read_chunked = 1;
+    }
+    else if (lenp) {
+        const char *pos = lenp;
+
+        while (apr_isdigit(*pos) || apr_isspace(*pos)) {
+            ++pos;
+        }
+
+        if (*pos != '\0') {
+            /* This supplies additional information for the default message. */
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00590)
+                          "Invalid Content-Length %s", lenp);
+            return HTTP_BAD_REQUEST;
+        }
+
+        r->remaining = apr_atoi64(lenp);
+    }
+
+    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)
+{
+    dav_resource *resource;
+    int resource_state;
+    dav_auto_version_info av_info;
+    const dav_hooks_locks *locks_hooks = DAV_GET_HOOKS_LOCKS(r);
+    dav_error *err;
+    dav_error *err2;
+    int result;
+    dav_response *multi_status;
+
+    /* handle the request body */
+    /* ### this may move lower once we start processing bodies */
+    if ((result = process_mkcol_body(r)) != OK) {
+        return result;
+    }
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    if (resource->exists) {
+        /* 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;
+    }
+
+    resource_state = dav_get_resource_state(r, resource);
+
+    /*
+     * 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.
+     */
+    if ((err = dav_validate_request(r, resource, 0, NULL, &multi_status,
+                                    resource_state == DAV_RESOURCE_NULL ?
+                                    DAV_VALIDATE_PARENT :
+                                    DAV_VALIDATE_RESOURCE, NULL)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, multi_status);
+    }
+
+    /* if versioned resource, make sure parent is checked out */
+    if ((err = dav_auto_checkout(r, resource, 1 /* parent_only */,
+                                 &av_info)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* try to create the collection */
+    resource->collection = 1;
+    err = (*resource->hooks->create_collection)(resource);
+
+    /* restore modifiability of parent back to what it was */
+    err2 = dav_auto_checkin(r, NULL, err != NULL /* undo if error */,
+                            0 /*unlock*/, &av_info);
+
+    /* check for errors now */
+    if (err != NULL) {
+        return dav_handle_err(r, err, NULL);
+    }
+    if (err2 != NULL) {
+        /* just log a warning */
+        err = dav_push_error(r->pool, err2->status, 0,
+                             "The MKCOL was successful, but there "
+                             "was a problem automatically checking in "
+                             "the parent collection.",
+                             err2);
+        dav_log_err(r, err, APLOG_WARNING);
+    }
+
+    if (locks_hooks != NULL) {
+        dav_lockdb *lockdb;
+
+        if ((err = (*locks_hooks->open_lockdb)(r, 0, 0, &lockdb)) != NULL) {
+            /* The directory creation was successful, but the locking failed. */
+            err = dav_push_error(r->pool, err->status, 0,
+                                 "The MKCOL was successful, but there "
+                                 "was a problem opening the lock database "
+                                 "which prevents inheriting locks from the "
+                                 "parent resources.",
+                                 err);
+            return dav_handle_err(r, err, NULL);
+        }
+
+        /* notify lock system that we have created/replaced a resource */
+        err = dav_notify_created(r, lockdb, resource, resource_state, 0);
+
+        (*locks_hooks->close_lockdb)(lockdb);
+
+        if (err != NULL) {
+            /* The dir creation was successful, but the locking failed. */
+            err = dav_push_error(r->pool, err->status, 0,
+                                 "The MKCOL was successful, but there "
+                                 "was a problem updating its lock "
+                                 "information.",
+                                 err);
+            return dav_handle_err(r, err, NULL);
+        }
+    }
+
+    /* return an appropriate response (HTTP_CREATED) */
+    return dav_created(r, NULL, "Collection", 0);
+}
+
+/* handle the COPY and MOVE methods */
+static int dav_method_copymove(request_rec *r, int is_move)
+{
+    dav_resource *resource;
+    dav_resource *resnew;
+    dav_auto_version_info src_av_info = { 0 };
+    dav_auto_version_info dst_av_info = { 0 };
+    const char *body;
+    const char *dest;
+    dav_error *err;
+    dav_error *err2;
+    dav_error *err3;
+    dav_response *multi_response;
+    dav_lookup_result lookup;
+    int is_dir;
+    int overwrite;
+    int depth;
+    int result;
+    dav_lockdb *lockdb;
+    int replace_dest;
+    int resnew_state;
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, !is_move /* label_allowed */,
+                           0 /* use_checked_in */, &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    if (!resource->exists) {
+        /* Apache will supply a default error for this. */
+        return HTTP_NOT_FOUND;
+    }
+
+    /* If not a file or collection resource, COPY/MOVE not allowed */
+    /* ### allow COPY/MOVE of DeltaV resource types */
+    if (resource->type != DAV_RESOURCE_TYPE_REGULAR) {
+        body = apr_psprintf(r->pool,
+                            "Cannot COPY/MOVE resource %s.",
+                            ap_escape_html(r->pool, r->uri));
+        return dav_error_response(r, HTTP_METHOD_NOT_ALLOWED, body);
+    }
+
+    /* get the destination URI */
+    dest = apr_table_get(r->headers_in, "Destination");
+    if (dest == NULL) {
+        /* Look in headers provided by Netscape's Roaming Profiles */
+        const char *nscp_host = apr_table_get(r->headers_in, "Host");
+        const char *nscp_path = apr_table_get(r->headers_in, "New-uri");
+
+        if (nscp_host != NULL && nscp_path != NULL)
+            dest = apr_psprintf(r->pool, "http://%s%s", nscp_host, nscp_path);
+    }
+    if (dest == NULL) {
+        /* This supplies additional information for the default message. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00591)
+                      "The request is missing a Destination header.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    lookup = dav_lookup_uri(dest, r, 1 /* must_be_absolute */);
+    if (lookup.rnew == NULL) {
+        if (lookup.err.status == HTTP_BAD_REQUEST) {
+            /* This supplies additional information for the default message. */
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00592)
+                          "%s", lookup.err.desc);
+            return HTTP_BAD_REQUEST;
+        }
+
+        /* ### this assumes that dav_lookup_uri() only generates a status
+         * ### that Apache can provide a status line for!! */
+
+        return dav_error_response(r, lookup.err.status, lookup.err.desc);
+    }
+    if (lookup.rnew->status != HTTP_OK) {
+        const char *auth = apr_table_get(lookup.rnew->err_headers_out,
+                                        "WWW-Authenticate");
+        if (lookup.rnew->status == HTTP_UNAUTHORIZED && auth != NULL) {
+            /* propagate the WWW-Authorization header up from the
+             * subreq so the client sees it. */
+            apr_table_setn(r->err_headers_out, "WWW-Authenticate",
+                           apr_pstrdup(r->pool, auth));
+        }
+
+        /* ### how best to report this... */
+        return dav_error_response(r, lookup.rnew->status,
+                                  "Destination URI had an error.");
+    }
+
+    /* Resolve destination resource */
+    err = dav_get_resource(lookup.rnew, 0 /* label_allowed */,
+                           0 /* use_checked_in */, &resnew);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    /* are the two resources handled by the same repository? */
+    if (resource->hooks != resnew->hooks) {
+        /* ### 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. */
+    if (resnew->exists && !overwrite) {
+        /* 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? */
+    if ((*resource->hooks->is_same_resource)(resource, resnew)) {
+        /* Supply some text for the error response body. */
+        return dav_error_response(r, HTTP_FORBIDDEN,
+                                  "Source and Destination URIs are the same.");
+
+    }
+
+    is_dir = resource->collection;
+
+    /* get and parse the Depth header value. "0" and "infinity" are legal. */
+    if ((depth = dav_get_depth(r, DAV_INFINITY)) < 0) {
+        /* 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. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00593)
+                      "Depth must be \"0\" or \"infinity\" for COPY or MOVE.");
+        return HTTP_BAD_REQUEST;
+    }
+    if (is_move && is_dir && depth != DAV_INFINITY) {
+        /* This supplies additional information for the default message. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00594)
+                      "Depth must be \"infinity\" when moving a collection.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /*
+     * Check If-Headers and existing locks for each resource in the source.
+     * 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, if 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 ((err = dav_validate_request(r, resource, depth, NULL,
+                                    &multi_response,
+                                    (is_move ? DAV_VALIDATE_PARENT
+                                             : DAV_VALIDATE_RESOURCE
+                                               | DAV_VALIDATE_NO_MODIFY)
+                                    | DAV_VALIDATE_USE_424,
+                                    NULL)) != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not %s %s due to a failed "
+                                          "precondition on the source "
+                                          "(e.g. locks).",
+                                          is_move ? "MOVE" : "COPY",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, multi_response);
+    }
+
+    /*
+     * Check If-Headers and existing locks for destination. Note that we
+     * use depth==infinity since the target (hierarchy) will be deleted
+     * before the move/copy is completed.
+     *
+     * Note that we are overwriting the target, which implies a DELETE, so
+     * we are subject to the error/response rules as a DELETE. Namely, we
+     * will return a 424 error if any of the validations fail.
+     * (see dav_method_delete() for more information)
+     */
+    if ((err = dav_validate_request(lookup.rnew, resnew, DAV_INFINITY, NULL,
+                                    &multi_response,
+                                    DAV_VALIDATE_PARENT
+                                    | DAV_VALIDATE_USE_424, NULL)) != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not MOVE/COPY %s due to a "
+                                          "failed precondition on the "
+                                          "destination (e.g. locks).",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, multi_response);
+    }
+
+    if (is_dir
+        && depth == DAV_INFINITY
+        && (*resource->hooks->is_parent_resource)(resource, resnew)) {
+        /* Supply some text for the error response body. */
+        return dav_error_response(r, HTTP_FORBIDDEN,
+                                  "Source collection contains the "
+                                  "Destination.");
+
+    }
+    if (is_dir
+        && (*resnew->hooks->is_parent_resource)(resnew, resource)) {
+        /* The destination must exist (since it contains the source), and
+         * a condition above implies Overwrite==T. Obviously, we cannot
+         * delete the Destination before the MOVE/COPY, as that would
+         * 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 */
+    if ((result = ap_discard_request_body(r)) != OK) {
+        return result;
+    }
+
+    if ((err = dav_open_lockdb(r, 0, &lockdb)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* 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 :-(
+     *
+     * ### note that we now have a problem atomicity in the move/copy
+     * ### since a failure after this would have removed locks (technically,
+     * ### this is okay to do, but really...)
+     */
+    if (is_move && lockdb != NULL) {
+        /* ### this is wrong! it blasts direct locks on parent resources */
+        /* ### pass lockdb! */
+        (void)dav_unlock(r, resource, NULL);
+    }
+
+    /* if this is a move, then the source parent collection will be modified */
+    if (is_move) {
+        if ((err = dav_auto_checkout(r, resource, 1 /* parent_only */,
+                                     &src_av_info)) != NULL) {
+            if (lockdb != NULL)
+                (*lockdb->hooks->close_lockdb)(lockdb);
+
+            /* ### add a higher-level description? */
+            return dav_handle_err(r, err, NULL);
+        }
+    }
+
+    /*
+     * Remember the initial state of the destination, so the lock system
+     * can be notified as to how it changed.
+     */
+    resnew_state = dav_get_resource_state(lookup.rnew, resnew);
+
+    /* In a MOVE operation, the destination is replaced by the source.
+     * In a COPY operation, if the destination exists, is under version
+     * control, and is the same resource type as the source,
+     * then it should not be replaced, but modified to be a copy of
+     * the source.
+     */
+    if (!resnew->exists)
+        replace_dest = 0;
+    else if (is_move || !resource->versioned)
+        replace_dest = 1;
+    else if (resource->type != resnew->type)
+        replace_dest = 1;
+    else if ((resource->collection == 0) != (resnew->collection == 0))
+        replace_dest = 1;
+    else
+        replace_dest = 0;
+
+    /* If the destination must be created or replaced,
+     * make sure the parent collection is writable
+     */
+    if (!resnew->exists || replace_dest) {
+        if ((err = dav_auto_checkout(r, resnew, 1 /*parent_only*/,
+                                     &dst_av_info)) != NULL) {
+            /* could not make destination writable:
+             * if move, restore state of source parent
+             */
+            if (is_move) {
+                (void)dav_auto_checkin(r, NULL, 1 /* undo */,
+                                       0 /*unlock*/, &src_av_info);
+            }
+
+            if (lockdb != NULL)
+                (*lockdb->hooks->close_lockdb)(lockdb);
+
+            /* ### add a higher-level description? */
+            return dav_handle_err(r, err, NULL);
+        }
+    }
+
+    /* If source and destination parents are the same, then
+     * use the same resource object, so status updates to one are reflected
+     * in the other, when doing auto-versioning. Otherwise,
+     * we may try to checkin the parent twice.
+     */
+    if (src_av_info.parent_resource != NULL
+        && dst_av_info.parent_resource != NULL
+        && (*src_av_info.parent_resource->hooks->is_same_resource)
+            (src_av_info.parent_resource, dst_av_info.parent_resource)) {
+
+        dst_av_info.parent_resource = src_av_info.parent_resource;
+    }
+
+    /* If destination is being replaced, remove it first
+     * (we know Ovewrite must be TRUE). Then try to copy/move the resource.
+     */
+    if (replace_dest)
+        err = (*resnew->hooks->remove_resource)(resnew, &multi_response);
+
+    if (err == NULL) {
+        if (is_move)
+            err = (*resource->hooks->move_resource)(resource, resnew,
+                                                    &multi_response);
+        else
+            err = (*resource->hooks->copy_resource)(resource, resnew, depth,
+                                                    &multi_response);
+    }
+
+    /* perform any auto-versioning cleanup */
+    err2 = dav_auto_checkin(r, NULL, err != NULL /* undo if error */,
+                            0 /*unlock*/, &dst_av_info);
+
+    if (is_move) {
+        err3 = dav_auto_checkin(r, NULL, err != NULL /* undo if error */,
+                                0 /*unlock*/, &src_av_info);
+    }
+    else
+        err3 = NULL;
+
+    /* check for error from remove/copy/move operations */
+    if (err != NULL) {
+        if (lockdb != NULL)
+            (*lockdb->hooks->close_lockdb)(lockdb);
+
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not MOVE/COPY %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, multi_response);
+    }
+
+    /* check for errors from auto-versioning */
+    if (err2 != NULL) {
+        /* just log a warning */
+        err = dav_push_error(r->pool, err2->status, 0,
+                             "The MOVE/COPY was successful, but there was a "
+                             "problem automatically checking in the "
+                             "source parent collection.",
+                             err2);
+        dav_log_err(r, err, APLOG_WARNING);
+    }
+    if (err3 != NULL) {
+        /* just log a warning */
+        err = dav_push_error(r->pool, err3->status, 0,
+                             "The MOVE/COPY was successful, but there was a "
+                             "problem automatically checking in the "
+                             "destination or its parent collection.",
+                             err3);
+        dav_log_err(r, err, APLOG_WARNING);
+    }
+
+    /* propagate any indirect locks at the target */
+    if (lockdb != NULL) {
+
+        /* notify lock system that we have created/replaced a resource */
+        err = dav_notify_created(r, lockdb, resnew, resnew_state, depth);
+
+        (*lockdb->hooks->close_lockdb)(lockdb);
+
+        if (err != NULL) {
+            /* The move/copy was successful, but the locking failed. */
+            err = dav_push_error(r->pool, err->status, 0,
+                                 "The MOVE/COPY was successful, but there "
+                                 "was a problem updating the lock "
+                                 "information.",
+                                 err);
+            return dav_handle_err(r, err, NULL);
+        }
+    }
+
+    /* return an appropriate response (HTTP_CREATED or HTTP_NO_CONTENT) */
+    return dav_created(r, lookup.rnew->unparsed_uri, "Destination",
+                       resnew_state == DAV_RESOURCE_EXISTS);
+}
+
+/* dav_method_lock:  Handler to implement the DAV LOCK method
+ *    Returns appropriate HTTP_* response.
+ */
+static int dav_method_lock(request_rec *r)
+{
+    dav_error *err;
+    dav_resource *resource;
+    dav_resource *parent;
+    const dav_hooks_locks *locks_hooks;
+    int result;
+    int depth;
+    int new_lock_request = 0;
+    apr_xml_doc *doc;
+    dav_lock *lock;
+    dav_response *multi_response = NULL;
+    dav_lockdb *lockdb;
+    int resource_state;
+
+    /* If no locks provider, decline the request */
+    locks_hooks = DAV_GET_HOOKS_LOCKS(r);
+    if (locks_hooks == NULL)
+        return DECLINED;
+
+    if ((result = ap_xml_parse_input(r, &doc)) != OK)
+        return result;
+
+    depth = dav_get_depth(r, DAV_INFINITY);
+    if (depth != 0 && depth != DAV_INFINITY) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00595)
+                      "Depth must be 0 or \"infinity\" for LOCK.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    /* Check if parent collection exists */
+    if ((err = resource->hooks->get_parent_resource(resource, &parent)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, NULL);
+    }
+    if (parent && (!parent->exists || parent->collection != 1)) {
+        err = dav_new_error(r->pool, HTTP_CONFLICT, 0, 0,
+                           apr_psprintf(r->pool,
+                                        "The parent resource of %s does not "
+                                        "exist or is not a collection.",
+                                        ap_escape_html(r->pool, r->uri)));
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /*
+     * Open writable. Unless an error occurs, we'll be
+     * writing into the database.
+     */
+    if ((err = (*locks_hooks->open_lockdb)(r, 0, 0, &lockdb)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, NULL);
+    }
+
+    if (doc != NULL) {
+        if ((err = dav_lock_parse_lockinfo(r, resource, lockdb, doc,
+                                               &lock)) != NULL) {
+            /* ### add a higher-level description to err? */
+            goto error;
+        }
+        new_lock_request = 1;
+
+        lock->auth_user = apr_pstrdup(r->pool, r->user);
+    }
+
+    resource_state = dav_get_resource_state(r, resource);
+
+    /*
+     * Check If-Headers and existing locks.
+     *
+     * If this will create a locknull resource, then the LOCK will affect
+     * the parent collection (much like a PUT/MKCOL). For that case, we must
+     * validate the parent resource's conditions.
+     */
+    if ((err = dav_validate_request(r, resource, depth, NULL, &multi_response,
+                                    (resource_state == DAV_RESOURCE_NULL
+                                     ? DAV_VALIDATE_PARENT
+                                     : DAV_VALIDATE_RESOURCE)
+                                    | (new_lock_request ? lock->scope : 0)
+                                    | DAV_VALIDATE_ADD_LD,
+                                    lockdb)) != OK) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not LOCK %s due to a failed "
+                                          "precondition (e.g. other locks).",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        goto error;
+    }
+
+    if (new_lock_request == 0) {
+        dav_locktoken_list *ltl;
+
+        /*
+         * 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.
+         */
+
+        if ((err = dav_get_locktoken_list(r, &ltl)) != NULL) {
+            err = dav_push_error(r->pool, err->status, 0,
+                                 apr_psprintf(r->pool,
+                                              "The lock refresh for %s failed "
+                                              "because no lock tokens were "
+                                              "specified in an \"If:\" "
+                                              "header.",
+                                              ap_escape_html(r->pool, r->uri)),
+                                 err);
+            goto error;
+        }
+
+        if ((err = (*locks_hooks->refresh_locks)(lockdb, resource, ltl,
+                                                 dav_get_timeout(r),
+                                                 &lock)) != NULL) {
+            /* ### add a higher-level description to err? */
+            goto error;
+        }
+    } else {
+        /* New lock request */
+        char *locktoken_txt;
+        dav_dir_conf *conf;
+
+        conf = (dav_dir_conf *)ap_get_module_config(r->per_dir_config,
+                                                    &dav_module);
+
+        /* apply lower bound (if any) from DAVMinTimeout directive */
+        if (lock->timeout != DAV_TIMEOUT_INFINITE
+            && lock->timeout < time(NULL) + conf->locktimeout)
+            lock->timeout = time(NULL) + conf->locktimeout;
+
+        err = dav_add_lock(r, resource, lockdb, lock, &multi_response);
+        if (err != NULL) {
+            /* ### add a higher-level description to err? */
+            goto error;
+        }
+
+        locktoken_txt = apr_pstrcat(r->pool, "<",
+                                    (*locks_hooks->format_locktoken)(r->pool,
+                                        lock->locktoken),
+                                    ">", NULL);
+
+        apr_table_setn(r->headers_out, "Lock-Token", locktoken_txt);
+    }
+
+    (*locks_hooks->close_lockdb)(lockdb);
+
+    r->status = HTTP_OK;
+    ap_set_content_type(r, DAV_XML_CONTENT_TYPE);
+
+    ap_rputs(DAV_XML_HEADER DEBUG_CR "<D:prop xmlns:D=\"DAV:\">" DEBUG_CR, r);
+    if (lock == NULL)
+        ap_rputs("<D:lockdiscovery/>" DEBUG_CR, r);
+    else {
+        ap_rprintf(r,
+                   "<D:lockdiscovery>" DEBUG_CR
+                   "%s" DEBUG_CR
+                   "</D:lockdiscovery>" DEBUG_CR,
+                   dav_lock_get_activelock(r, lock, NULL));
+    }
+    ap_rputs("</D:prop>", r);
+
+    /* the response has been sent. */
+    return DONE;
+
+  error:
+    (*locks_hooks->close_lockdb)(lockdb);
+    return dav_handle_err(r, err, multi_response);
+}
+
+/* dav_method_unlock:  Handler to implement the DAV UNLOCK method
+ *    Returns appropriate HTTP_* response.
+ */
+static int dav_method_unlock(request_rec *r)
+{
+    dav_error *err;
+    dav_resource *resource;
+    const dav_hooks_locks *locks_hooks;
+    int result;
+    const char *const_locktoken_txt;
+    char *locktoken_txt;
+    dav_locktoken *locktoken = NULL;
+    int resource_state;
+    dav_response *multi_response;
+
+    /* If no locks provider, decline the request */
+    locks_hooks = DAV_GET_HOOKS_LOCKS(r);
+    if (locks_hooks == NULL)
+        return DECLINED;
+
+    if ((const_locktoken_txt = apr_table_get(r->headers_in,
+                                             "Lock-Token")) == NULL) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00596)
+                      "Unlock failed (%s):  "
+                      "No Lock-Token specified in header", r->filename);
+        return HTTP_BAD_REQUEST;
+    }
+
+    locktoken_txt = apr_pstrdup(r->pool, const_locktoken_txt);
+    if (locktoken_txt[0] != '<') {
+        /* ### should provide more specifics... */
+        return HTTP_BAD_REQUEST;
+    }
+    locktoken_txt++;
+
+    if (locktoken_txt[strlen(locktoken_txt) - 1] != '>') {
+        /* ### should provide more specifics... */
+        return HTTP_BAD_REQUEST;
+    }
+    locktoken_txt[strlen(locktoken_txt) - 1] = '\0';
+
+    if ((err = (*locks_hooks->parse_locktoken)(r->pool, locktoken_txt,
+                                               &locktoken)) != NULL) {
+        err = dav_push_error(r->pool, HTTP_BAD_REQUEST, 0,
+                             apr_psprintf(r->pool,
+                                          "The UNLOCK on %s failed -- an "
+                                          "invalid lock token was specified "
+                                          "in the \"If:\" header.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    resource_state = dav_get_resource_state(r, resource);
+
+    /*
+     * 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.
+     */
+    if ((err = dav_validate_request(r, resource, 0, locktoken,
+                                    &multi_response,
+                                    resource_state == DAV_RESOURCE_LOCK_NULL
+                                    ? DAV_VALIDATE_PARENT
+                                    : DAV_VALIDATE_RESOURCE, NULL)) != NULL) {
+        /* ### add a higher-level description? */
+        return dav_handle_err(r, err, multi_response);
+    }
+
+    /* ### 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.
+     */
+    if ((result = dav_unlock(r, resource, locktoken)) != OK) {
+        return result;
+    }
+
+    return HTTP_NO_CONTENT;
+}
+
+static int dav_method_vsn_control(request_rec *r)
+{
+    dav_resource *resource;
+    int resource_state;
+    dav_auto_version_info av_info;
+    const dav_hooks_locks *locks_hooks = DAV_GET_HOOKS_LOCKS(r);
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    dav_error *err;
+    apr_xml_doc *doc;
+    const char *target = NULL;
+    int result;
+
+    /* if no versioning provider, decline the request */
+    if (vsn_hooks == NULL)
+        return DECLINED;
+
+    /* ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    /* remember the pre-creation resource state */
+    resource_state = dav_get_resource_state(r, resource);
+
+    /* parse the request body (may be a version-control element) */
+    if ((result = ap_xml_parse_input(r, &doc)) != OK) {
+        return result;
+    }
+    /* note: doc == NULL if no request body */
+
+    if (doc != NULL) {
+        const apr_xml_elem *child;
+        apr_size_t tsize;
+
+        if (!dav_validate_root(doc, "version-control")) {
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00597)
+                          "The request body does not contain "
+                          "a \"version-control\" element.");
+            return HTTP_BAD_REQUEST;
+        }
+
+        /* get the version URI */
+        if ((child = dav_find_child(doc->root, "version")) == NULL) {
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00598)
+                          "The \"version-control\" element does not contain "
+                          "a \"version\" element.");
+            return HTTP_BAD_REQUEST;
+        }
+
+        if ((child = dav_find_child(child, "href")) == NULL) {
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00599)
+                          "The \"version\" element does not contain "
+                          "an \"href\" element.");
+            return HTTP_BAD_REQUEST;
+        }
+
+        /* get version URI */
+        apr_xml_to_text(r->pool, child, APR_XML_X2T_INNER, NULL, NULL,
+                        &target, &tsize);
+        if (tsize == 0) {
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00600)
+                          "An \"href\" element does not contain a URI.");
+            return HTTP_BAD_REQUEST;
+        }
+    }
+
+    /* Check request preconditions */
+
+    /* ### need a general mechanism for reporting precondition violations
+     * ### (should be returning XML document for 403/409 responses)
+     */
+
+    /* if not versioning existing resource, must specify version to select */
+    if (!resource->exists && target == NULL) {
+        err = dav_new_error(r->pool, HTTP_CONFLICT, 0, 0,
+                            "<DAV:initial-version-required/>");
+        return dav_handle_err(r, err, NULL);
+    }
+    else if (resource->exists) {
+        /* cannot add resource to existing version history */
+        if (target != NULL) {
+            err = dav_new_error(r->pool, HTTP_CONFLICT, 0, 0,
+                                "<DAV:cannot-add-to-existing-history/>");
+            return dav_handle_err(r, err, NULL);
+        }
+
+        /* resource must be unversioned and versionable, or version selector */
+        if (resource->type != DAV_RESOURCE_TYPE_REGULAR
+            || (!resource->versioned && !(vsn_hooks->versionable)(resource))) {
+            err = dav_new_error(r->pool, HTTP_CONFLICT, 0, 0,
+                                "<DAV:must-be-versionable/>");
+            return dav_handle_err(r, err, NULL);
+        }
+
+        /* the DeltaV spec says if resource is a version selector,
+         * then VERSION-CONTROL is a no-op
+         */
+        if (resource->versioned) {
+            /* set the Cache-Control header, per the spec */
+            apr_table_setn(r->headers_out, "Cache-Control", "no-cache");
+
+            /* no body */
+            ap_set_content_length(r, 0);
+
+            return DONE;
+        }
+    }
+
+    /* Check If-Headers and existing locks */
+    /* Note: depth == 0. Implies no need for a multistatus response. */
+    if ((err = dav_validate_request(r, resource, 0, NULL, NULL,
+                                    resource_state == DAV_RESOURCE_NULL ?
+                                    DAV_VALIDATE_PARENT :
+                                    DAV_VALIDATE_RESOURCE, NULL)) != NULL) {
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* if in versioned collection, make sure parent is checked out */
+    if ((err = dav_auto_checkout(r, resource, 1 /* parent_only */,
+                                 &av_info)) != NULL) {
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* attempt to version-control the resource */
+    if ((err = (*vsn_hooks->vsn_control)(resource, target)) != NULL) {
+        dav_auto_checkin(r, resource, 1 /*undo*/, 0 /*unlock*/, &av_info);
+        err = dav_push_error(r->pool, HTTP_CONFLICT, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not VERSION-CONTROL resource %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* revert writability of parent directory */
+    err = dav_auto_checkin(r, resource, 0 /*undo*/, 0 /*unlock*/, &av_info);
+    if (err != NULL) {
+        /* just log a warning */
+        err = dav_push_error(r->pool, err->status, 0,
+                             "The VERSION-CONTROL was successful, but there "
+                             "was a problem automatically checking in "
+                             "the parent collection.",
+                             err);
+        dav_log_err(r, err, APLOG_WARNING);
+    }
+
+    /* if the resource is lockable, let lock system know of new resource */
+    if (locks_hooks != NULL
+        && (*locks_hooks->get_supportedlock)(resource) != NULL) {
+        dav_lockdb *lockdb;
+
+        if ((err = (*locks_hooks->open_lockdb)(r, 0, 0, &lockdb)) != NULL) {
+            /* The resource creation was successful, but the locking failed. */
+            err = dav_push_error(r->pool, err->status, 0,
+                                 "The VERSION-CONTROL was successful, but there "
+                                 "was a problem opening the lock database "
+                                 "which prevents inheriting locks from the "
+                                 "parent resources.",
+                                 err);
+            return dav_handle_err(r, err, NULL);
+        }
+
+        /* notify lock system that we have created/replaced a resource */
+        err = dav_notify_created(r, lockdb, resource, resource_state, 0);
+
+        (*locks_hooks->close_lockdb)(lockdb);
+
+        if (err != NULL) {
+            /* The dir creation was successful, but the locking failed. */
+            err = dav_push_error(r->pool, err->status, 0,
+                                 "The VERSION-CONTROL was successful, but there "
+                                 "was a problem updating its lock "
+                                 "information.",
+                                 err);
+            return dav_handle_err(r, err, NULL);
+        }
+    }
+
+    /* set the Cache-Control header, per the spec */
+    apr_table_setn(r->headers_out, "Cache-Control", "no-cache");
+
+    /* return an appropriate response (HTTP_CREATED) */
+    return dav_created(r, resource->uri, "Version selector", 0 /*replaced*/);
+}
+
+/* handle the CHECKOUT method */
+static int dav_method_checkout(request_rec *r)
+{
+    dav_resource *resource;
+    dav_resource *working_resource;
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    dav_error *err;
+    int result;
+    apr_xml_doc *doc;
+    int apply_to_vsn = 0;
+    int is_unreserved = 0;
+    int is_fork_ok = 0;
+    int create_activity = 0;
+    apr_array_header_t *activities = NULL;
+
+    /* If no versioning provider, decline the request */
+    if (vsn_hooks == NULL)
+        return DECLINED;
+
+    if ((result = ap_xml_parse_input(r, &doc)) != OK)
+        return result;
+
+    if (doc != NULL) {
+        const apr_xml_elem *aset;
+
+        if (!dav_validate_root(doc, "checkout")) {
+            /* This supplies additional information for the default msg. */
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00601)
+                          "The request body, if present, must be a "
+                          "DAV:checkout element.");
+            return HTTP_BAD_REQUEST;
+        }
+
+        if (dav_find_child(doc->root, "apply-to-version") != NULL) {
+            if (apr_table_get(r->headers_in, "label") != NULL) {
+                /* ### we want generic 403/409 XML reporting here */
+                /* ### DAV:must-not-have-label-and-apply-to-version */
+                return dav_error_response(r, HTTP_CONFLICT,
+                                          "DAV:apply-to-version cannot be "
+                                          "used in conjunction with a "
+                                          "Label header.");
+            }
+            apply_to_vsn = 1;
+        }
+
+        is_unreserved = dav_find_child(doc->root, "unreserved") != NULL;
+        is_fork_ok = dav_find_child(doc->root, "fork-ok") != NULL;
+
+        if ((aset = dav_find_child(doc->root, "activity-set")) != NULL) {
+            if (dav_find_child(aset, "new") != NULL) {
+                create_activity = 1;
+            }
+            else {
+                const apr_xml_elem *child = aset->first_child;
+
+                activities = apr_array_make(r->pool, 1, sizeof(const char *));
+
+                for (; child != NULL; child = child->next) {
+                    if (child->ns == APR_XML_NS_DAV_ID
+                        && strcmp(child->name, "href") == 0) {
+                        const char *href;
+
+                        href = dav_xml_get_cdata(child, r->pool,
+                                                 1 /* strip_white */);
+                        *(const char **)apr_array_push(activities) = href;
+                    }
+                }
+
+                if (activities->nelts == 0) {
+                    /* no href's is a DTD violation:
+                       <!ELEMENT activity-set (href+ | new)>
+                    */
+
+                    /* This supplies additional info for the default msg. */
+                    ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00602)
+                                  "Within the DAV:activity-set element, the "
+                                  "DAV:new element must be used, or at least "
+                                  "one DAV:href must be specified.");
+                    return HTTP_BAD_REQUEST;
+                }
+            }
+        }
+    }
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 1 /*label_allowed*/, apply_to_vsn, &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    if (!resource->exists) {
+        /* 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.
+     */
+    if (resource->type != DAV_RESOURCE_TYPE_REGULAR
+        && resource->type != DAV_RESOURCE_TYPE_VERSION) {
+        return dav_error_response(r, HTTP_CONFLICT,
+                                  "Cannot checkout this type of resource.");
+    }
+
+    if (!resource->versioned) {
+        return dav_error_response(r, HTTP_CONFLICT,
+                                  "Cannot checkout unversioned resource.");
+    }
+
+    if (resource->working) {
+        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 */
+    if ((err = (*vsn_hooks->checkout)(resource, 0 /*auto_checkout*/,
+                                      is_unreserved, is_fork_ok,
+                                      create_activity, activities,
+                                      &working_resource)) != NULL) {
+        err = dav_push_error(r->pool, HTTP_CONFLICT, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not CHECKOUT resource %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* set the Cache-Control header, per the spec */
+    apr_table_setn(r->headers_out, "Cache-Control", "no-cache");
+
+    /* if no working resource created, return OK,
+     * else return CREATED with working resource URL in Location header
+     */
+    if (working_resource == NULL) {
+        /* no body */
+        ap_set_content_length(r, 0);
+        return DONE;
+    }
+
+    return dav_created(r, working_resource->uri, "Checked-out resource", 0);
+}
+
+/* handle the UNCHECKOUT method */
+static int dav_method_uncheckout(request_rec *r)
+{
+    dav_resource *resource;
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    dav_error *err;
+    int result;
+
+    /* If no versioning provider, decline the request */
+    if (vsn_hooks == NULL)
+        return DECLINED;
+
+    if ((result = ap_discard_request_body(r)) != OK) {
+        return result;
+    }
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    if (!resource->exists) {
+        /* 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.
+     */
+    if (resource->type != DAV_RESOURCE_TYPE_REGULAR) {
+        return dav_error_response(r, HTTP_CONFLICT,
+                                  "Cannot uncheckout this type of resource.");
+    }
+
+    if (!resource->versioned) {
+        return dav_error_response(r, HTTP_CONFLICT,
+                                  "Cannot uncheckout unversioned resource.");
+    }
+
+    if (!resource->working) {
+        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 */
+    if ((err = (*vsn_hooks->uncheckout)(resource)) != NULL) {
+        err = dav_push_error(r->pool, HTTP_CONFLICT, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not UNCHECKOUT resource %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* no body */
+    ap_set_content_length(r, 0);
+
+    return DONE;
+}
+
+/* handle the CHECKIN method */
+static int dav_method_checkin(request_rec *r)
+{
+    dav_resource *resource;
+    dav_resource *new_version;
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    dav_error *err;
+    int result;
+    apr_xml_doc *doc;
+    int keep_checked_out = 0;
+
+    /* If no versioning provider, decline the request */
+    if (vsn_hooks == NULL)
+        return DECLINED;
+
+    if ((result = ap_xml_parse_input(r, &doc)) != OK)
+        return result;
+
+    if (doc != NULL) {
+        if (!dav_validate_root(doc, "checkin")) {
+            /* This supplies additional information for the default msg. */
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00603)
+                          "The request body, if present, must be a "
+                          "DAV:checkin element.");
+            return HTTP_BAD_REQUEST;
+        }
+
+        keep_checked_out = dav_find_child(doc->root, "keep-checked-out") != NULL;
+    }
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    if (!resource->exists) {
+        /* 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.
+     */
+    if (resource->type != DAV_RESOURCE_TYPE_REGULAR) {
+        return dav_error_response(r, HTTP_CONFLICT,
+                                  "Cannot checkin this type of resource.");
+    }
+
+    if (!resource->versioned) {
+        return dav_error_response(r, HTTP_CONFLICT,
+                                  "Cannot checkin unversioned resource.");
+    }
+
+    if (!resource->working) {
+        return dav_error_response(r, HTTP_CONFLICT,
+                                  "The resource is not checked out.");
+    }
+
+    /* ### do lock checks, once behavior is defined */
+
+    /* Do the checkin */
+    if ((err = (*vsn_hooks->checkin)(resource, keep_checked_out, &new_version))
+        != NULL) {
+        err = dav_push_error(r->pool, HTTP_CONFLICT, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not CHECKIN resource %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+
+    return dav_created(r, new_version->uri, "Version", 0);
+}
+
+static int dav_method_update(request_rec *r)
+{
+    dav_resource *resource;
+    dav_resource *version = NULL;
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    apr_xml_doc *doc;
+    apr_xml_elem *child;
+    int is_label = 0;
+    int depth;
+    int result;
+    apr_size_t tsize;
+    const char *target;
+    dav_response *multi_response;
+    dav_error *err;
+    dav_lookup_result lookup;
+
+    /* If no versioning provider, or UPDATE not supported,
+     * decline the request */
+    if (vsn_hooks == NULL || vsn_hooks->update == NULL)
+        return DECLINED;
+
+    if ((depth = dav_get_depth(r, 0)) < 0) {
+        /* dav_get_depth() supplies additional information for the
+         * default message. */
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* parse the request body */
+    if ((result = ap_xml_parse_input(r, &doc)) != OK) {
+        return result;
+    }
+
+    if (doc == NULL || !dav_validate_root(doc, "update")) {
+        /* This supplies additional information for the default message. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00604)
+                      "The request body does not contain "
+                      "an \"update\" element.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* check for label-name or version element, but not both */
+    if ((child = dav_find_child(doc->root, "label-name")) != NULL)
+        is_label = 1;
+    else if ((child = dav_find_child(doc->root, "version")) != NULL) {
+        /* get the href element */
+        if ((child = dav_find_child(child, "href")) == NULL) {
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00605)
+                          "The version element does not contain "
+                          "an \"href\" element.");
+            return HTTP_BAD_REQUEST;
+        }
+    }
+    else {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00606)
+                      "The \"update\" element does not contain "
+                      "a \"label-name\" or \"version\" element.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* a depth greater than zero is only allowed for a label */
+    if (!is_label && depth != 0) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00607)
+                      "Depth must be zero for UPDATE with a version");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* get the target value (a label or a version URI) */
+    apr_xml_to_text(r->pool, child, APR_XML_X2T_INNER, NULL, NULL,
+                    &target, &tsize);
+    if (tsize == 0) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00608)
+                      "A \"label-name\" or \"href\" element does not contain "
+                      "any content.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    if (!resource->exists) {
+        /* Apache will supply a default error for this. */
+        return HTTP_NOT_FOUND;
+    }
+
+    /* ### need a general mechanism for reporting precondition violations
+     * ### (should be returning XML document for 403/409 responses)
+     */
+    if (resource->type != DAV_RESOURCE_TYPE_REGULAR
+        || !resource->versioned || resource->working) {
+        return dav_error_response(r, HTTP_CONFLICT,
+                                  "<DAV:must-be-checked-in-version-controlled-resource>");
+    }
+
+    /* if target is a version, resolve the version resource */
+    /* ### dav_lookup_uri only allows absolute URIs; is that OK? */
+    if (!is_label) {
+        lookup = dav_lookup_uri(target, r, 0 /* must_be_absolute */);
+        if (lookup.rnew == NULL) {
+            if (lookup.err.status == HTTP_BAD_REQUEST) {
+                /* This supplies additional information for the default message. */
+                ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00609)
+                              "%s", lookup.err.desc);
+                return HTTP_BAD_REQUEST;
+            }
+
+            /* ### this assumes that dav_lookup_uri() only generates a status
+             * ### that Apache can provide a status line for!! */
+
+            return dav_error_response(r, lookup.err.status, lookup.err.desc);
+        }
+        if (lookup.rnew->status != HTTP_OK) {
+            /* ### how best to report this... */
+            return dav_error_response(r, lookup.rnew->status,
+                                      "Version URI had an error.");
+        }
+
+        /* resolve version resource */
+        err = dav_get_resource(lookup.rnew, 0 /* label_allowed */,
+                               0 /* use_checked_in */, &version);
+        if (err != NULL)
+            return dav_handle_err(r, err, NULL);
+
+        /* NULL out target, since we're using a version resource */
+        target = NULL;
+    }
+
+    /* do the UPDATE operation */
+    err = (*vsn_hooks->update)(resource, version, target, depth, &multi_response);
+
+    if (err != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not UPDATE %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, multi_response);
+    }
+
+    /* set the Cache-Control header, per the spec */
+    apr_table_setn(r->headers_out, "Cache-Control", "no-cache");
+
+    /* no body */
+    ap_set_content_length(r, 0);
+
+    return DONE;
+}
+
+/* context maintained during LABEL treewalk */
+typedef struct dav_label_walker_ctx
+{
+    /* input: */
+    dav_walk_params w;
+
+    /* label being manipulated */
+    const char *label;
+
+    /* label operation */
+    int label_op;
+#define DAV_LABEL_ADD           1
+#define DAV_LABEL_SET           2
+#define DAV_LABEL_REMOVE        3
+
+    /* version provider hooks */
+    const dav_hooks_vsn *vsn_hooks;
+
+} dav_label_walker_ctx;
+
+static dav_error * dav_label_walker(dav_walk_resource *wres, int calltype)
+{
+    dav_label_walker_ctx *ctx = wres->walk_ctx;
+    dav_error *err = NULL;
+
+    /* Check the state of the resource: must be a version or
+     * non-checkedout version selector
+     */
+    /* ### need a general mechanism for reporting precondition violations
+     * ### (should be returning XML document for 403/409 responses)
+     */
+    if (wres->resource->type != DAV_RESOURCE_TYPE_VERSION &&
+        (wres->resource->type != DAV_RESOURCE_TYPE_REGULAR
+         || !wres->resource->versioned)) {
+        err = dav_new_error(ctx->w.pool, HTTP_CONFLICT, 0, 0,
+                            "<DAV:must-be-version-or-version-selector/>");
+    }
+    else if (wres->resource->working) {
+        err = dav_new_error(ctx->w.pool, HTTP_CONFLICT, 0, 0,
+                            "<DAV:must-not-be-checked-out/>");
+    }
+    else {
+        /* do the label operation */
+        if (ctx->label_op == DAV_LABEL_REMOVE)
+            err = (*ctx->vsn_hooks->remove_label)(wres->resource, ctx->label);
+        else
+            err = (*ctx->vsn_hooks->add_label)(wres->resource, ctx->label,
+                                               ctx->label_op == DAV_LABEL_SET);
+    }
+
+    if (err != NULL) {
+        /* ### need utility routine to add response with description? */
+        dav_add_response(wres, err->status, NULL);
+        wres->response->desc = err->desc;
+    }
+
+    return NULL;
+}
+
+static int dav_method_label(request_rec *r)
+{
+    dav_resource *resource;
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    apr_xml_doc *doc;
+    apr_xml_elem *child;
+    int depth;
+    int result;
+    apr_size_t tsize;
+    dav_error *err;
+    dav_label_walker_ctx ctx = { { 0 } };
+    dav_response *multi_status;
+
+    /* If no versioning provider, or the provider doesn't support
+     * labels, decline the request */
+    if (vsn_hooks == NULL || vsn_hooks->add_label == NULL)
+        return DECLINED;
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 1 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+    if (!resource->exists) {
+        /* Apache will supply a default error for this. */
+        return HTTP_NOT_FOUND;
+    }
+
+    if ((depth = dav_get_depth(r, 0)) < 0) {
+        /* dav_get_depth() supplies additional information for the
+         * default message. */
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* parse the request body */
+    if ((result = ap_xml_parse_input(r, &doc)) != OK) {
+        return result;
+    }
+
+    if (doc == NULL || !dav_validate_root(doc, "label")) {
+        /* This supplies additional information for the default message. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00610)
+                      "The request body does not contain "
+                      "a \"label\" element.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* check for add, set, or remove element */
+    if ((child = dav_find_child(doc->root, "add")) != NULL) {
+        ctx.label_op = DAV_LABEL_ADD;
+    }
+    else if ((child = dav_find_child(doc->root, "set")) != NULL) {
+        ctx.label_op = DAV_LABEL_SET;
+    }
+    else if ((child = dav_find_child(doc->root, "remove")) != NULL) {
+        ctx.label_op = DAV_LABEL_REMOVE;
+    }
+    else {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00611)
+                      "The \"label\" element does not contain "
+                      "an \"add\", \"set\", or \"remove\" element.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* get the label string */
+    if ((child = dav_find_child(child, "label-name")) == NULL) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00612)
+                      "The label command element does not contain "
+                      "a \"label-name\" element.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    apr_xml_to_text(r->pool, child, APR_XML_X2T_INNER, NULL, NULL,
+                    &ctx.label, &tsize);
+    if (tsize == 0) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00613)
+                      "A \"label-name\" element does not contain "
+                      "a label name.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* do the label operation walk */
+    ctx.w.walk_type = DAV_WALKTYPE_NORMAL;
+    ctx.w.func = dav_label_walker;
+    ctx.w.walk_ctx = &ctx;
+    ctx.w.pool = r->pool;
+    ctx.w.root = resource;
+    ctx.vsn_hooks = vsn_hooks;
+
+    err = (*resource->hooks->walk)(&ctx.w, depth, &multi_status);
+
+    if (err != NULL) {
+        /* some sort of error occurred which terminated the walk */
+        err = dav_push_error(r->pool, err->status, 0,
+                             "The LABEL operation was terminated prematurely.",
+                             err);
+        return dav_handle_err(r, err, multi_status);
+    }
+
+    if (multi_status != NULL) {
+        /* One or more resources had errors. If depth was zero, convert
+         * response to simple error, else make sure there is an
+         * overall error to pass to dav_handle_err()
+         */
+        if (depth == 0) {
+            err = dav_new_error(r->pool, multi_status->status, 0, 0,
+                                multi_status->desc);
+            multi_status = NULL;
+        }
+        else {
+            err = dav_new_error(r->pool, HTTP_MULTI_STATUS, 0, 0,
+                                "Errors occurred during the LABEL operation.");
+        }
+
+        return dav_handle_err(r, err, multi_status);
+    }
+
+    /* set the Cache-Control header, per the spec */
+    apr_table_setn(r->headers_out, "Cache-Control", "no-cache");
+
+    /* no body */
+    ap_set_content_length(r, 0);
+
+    return DONE;
+}
+
+static int dav_method_report(request_rec *r)
+{
+    dav_resource *resource;
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    int result;
+    int label_allowed;
+    apr_xml_doc *doc;
+    dav_error *err;
+
+    /* If no versioning provider, decline the request */
+    if (vsn_hooks == NULL)
+        return DECLINED;
+
+    if ((result = ap_xml_parse_input(r, &doc)) != OK)
+        return result;
+    if (doc == NULL) {
+        /* This supplies additional information for the default msg. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00614)
+                      "The request body must specify a report.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* Ask repository module to resolve the resource.
+     * First determine whether a Target-Selector header is allowed
+     * for this report.
+     */
+    label_allowed = (*vsn_hooks->report_label_header_allowed)(doc);
+    err = dav_get_resource(r, label_allowed, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    if (!resource->exists) {
+        /* Apache will supply a default error for this. */
+        return HTTP_NOT_FOUND;
+    }
+
+    /* set up defaults for the report response */
+    r->status = HTTP_OK;
+    ap_set_content_type(r, DAV_XML_CONTENT_TYPE);
+
+    /* run report hook */
+    if ((err = (*vsn_hooks->deliver_report)(r, resource, doc,
+                                            r->output_filters)) != NULL) {
+        if (! r->sent_bodyct)
+          /* No data has been sent to client yet;  throw normal error. */
+          return dav_handle_err(r, err, NULL);
+
+        /* If an error occurred during the report delivery, there's
+           basically nothing we can do but abort the connection and
+           log an error.  This is one of the limitations of HTTP; it
+           needs to "know" the entire status of the response before
+           generating it, which is just impossible in these streamy
+           response situations. */
+        err = dav_push_error(r->pool, err->status, 0,
+                             "Provider encountered an error while streaming"
+                             " a REPORT response.", err);
+        dav_log_err(r, err, APLOG_ERR);
+        r->connection->aborted = 1;
+        return DONE;
+    }
+
+    return DONE;
+}
+
+static int dav_method_make_workspace(request_rec *r)
+{
+    dav_resource *resource;
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    dav_error *err;
+    apr_xml_doc *doc;
+    int result;
+
+    /* if no versioning provider, or the provider does not support workspaces,
+     * decline the request
+     */
+    if (vsn_hooks == NULL || vsn_hooks->make_workspace == NULL)
+        return DECLINED;
+
+    /* ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    /* parse the request body (must be a mkworkspace element) */
+    if ((result = ap_xml_parse_input(r, &doc)) != OK) {
+        return result;
+    }
+
+    if (doc == NULL
+        || !dav_validate_root(doc, "mkworkspace")) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00615)
+                      "The request body does not contain "
+                      "a \"mkworkspace\" element.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    /* Check request preconditions */
+
+    /* ### need a general mechanism for reporting precondition violations
+     * ### (should be returning XML document for 403/409 responses)
+     */
+
+    /* resource must not already exist */
+    if (resource->exists) {
+        err = dav_new_error(r->pool, HTTP_CONFLICT, 0, 0,
+                            "<DAV:resource-must-be-null/>");
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* ### what about locking? */
+
+    /* attempt to create the workspace */
+    if ((err = (*vsn_hooks->make_workspace)(resource, doc)) != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not create workspace %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* set the Cache-Control header, per the spec */
+    apr_table_setn(r->headers_out, "Cache-Control", "no-cache");
+
+    /* return an appropriate response (HTTP_CREATED) */
+    return dav_created(r, resource->uri, "Workspace", 0 /*replaced*/);
+}
+
+static int dav_method_make_activity(request_rec *r)
+{
+    dav_resource *resource;
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    dav_error *err;
+    int result;
+
+    /* if no versioning provider, or the provider does not support activities,
+     * decline the request
+     */
+    if (vsn_hooks == NULL || vsn_hooks->make_activity == NULL)
+        return DECLINED;
+
+    /* ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    /* MKACTIVITY does not have a defined request body. */
+    if ((result = ap_discard_request_body(r)) != OK) {
+        return result;
+    }
+
+    /* Check request preconditions */
+
+    /* ### need a general mechanism for reporting precondition violations
+     * ### (should be returning XML document for 403/409 responses)
+     */
+
+    /* resource must not already exist */
+    if (resource->exists) {
+        err = dav_new_error(r->pool, HTTP_CONFLICT, 0, 0,
+                            "<DAV:resource-must-be-null/>");
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* the provider must say whether the resource can be created as
+       an activity, i.e. whether the location is ok.  */
+    if (vsn_hooks->can_be_activity != NULL
+        && !(*vsn_hooks->can_be_activity)(resource)) {
+      err = dav_new_error(r->pool, HTTP_FORBIDDEN, 0, 0,
+                          "<DAV:activity-location-ok/>");
+      return dav_handle_err(r, err, NULL);
+    }
+
+    /* ### what about locking? */
+
+    /* attempt to create the activity */
+    if ((err = (*vsn_hooks->make_activity)(resource)) != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not create activity %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* set the Cache-Control header, per the spec */
+    apr_table_setn(r->headers_out, "Cache-Control", "no-cache");
+
+    /* return an appropriate response (HTTP_CREATED) */
+    return dav_created(r, resource->uri, "Activity", 0 /*replaced*/);
+}
+
+static int dav_method_baseline_control(request_rec *r)
+{
+    /* ### */
+    return HTTP_METHOD_NOT_ALLOWED;
+}
+
+static int dav_method_merge(request_rec *r)
+{
+    dav_resource *resource;
+    dav_resource *source_resource;
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    dav_error *err;
+    int result;
+    apr_xml_doc *doc;
+    apr_xml_elem *source_elem;
+    apr_xml_elem *href_elem;
+    apr_xml_elem *prop_elem;
+    const char *source;
+    int no_auto_merge;
+    int no_checkout;
+    dav_lookup_result lookup;
+
+    /* If no versioning provider, decline the request */
+    if (vsn_hooks == NULL)
+        return DECLINED;
+
+    if ((result = ap_xml_parse_input(r, &doc)) != OK)
+        return result;
+
+    if (doc == NULL || !dav_validate_root(doc, "merge")) {
+        /* This supplies additional information for the default msg. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00616)
+                      "The request body must be present and must be a "
+                      "DAV:merge element.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    if ((source_elem = dav_find_child(doc->root, "source")) == NULL) {
+        /* This supplies additional information for the default msg. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00617)
+                      "The DAV:merge element must contain a DAV:source "
+                      "element.");
+        return HTTP_BAD_REQUEST;
+    }
+    if ((href_elem = dav_find_child(source_elem, "href")) == NULL) {
+        /* This supplies additional information for the default msg. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00618)
+                      "The DAV:source element must contain a DAV:href "
+                      "element.");
+        return HTTP_BAD_REQUEST;
+    }
+    source = dav_xml_get_cdata(href_elem, r->pool, 1 /* strip_white */);
+
+    /* get a subrequest for the source, so that we can get a dav_resource
+       for that source. */
+    lookup = dav_lookup_uri(source, r, 0 /* must_be_absolute */);
+    if (lookup.rnew == NULL) {
+        if (lookup.err.status == HTTP_BAD_REQUEST) {
+            /* This supplies additional information for the default message. */
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00619)
+                          "%s", lookup.err.desc);
+            return HTTP_BAD_REQUEST;
+        }
+
+        /* ### this assumes that dav_lookup_uri() only generates a status
+         * ### that Apache can provide a status line for!! */
+
+        return dav_error_response(r, lookup.err.status, lookup.err.desc);
+    }
+    if (lookup.rnew->status != HTTP_OK) {
+        /* ### how best to report this... */
+        return dav_error_response(r, lookup.rnew->status,
+                                  "Merge source URI had an error.");
+    }
+    err = dav_get_resource(lookup.rnew, 0 /* label_allowed */,
+                           0 /* use_checked_in */, &source_resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    no_auto_merge = dav_find_child(doc->root, "no-auto-merge") != NULL;
+    no_checkout = dav_find_child(doc->root, "no-checkout") != NULL;
+
+    prop_elem = dav_find_child(doc->root, "prop");
+
+    /* ### check RFC. I believe the DAV:merge element may contain any
+       ### element also allowed within DAV:checkout. need to extract them
+       ### here, and pass them along.
+       ### if so, then refactor the CHECKOUT method handling so we can reuse
+       ### the code. maybe create a structure to hold CHECKOUT parameters
+       ### which can be passed to the checkout() and merge() hooks. */
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+    if (!resource->exists) {
+        /* Apache will supply a default error for this. */
+        return HTTP_NOT_FOUND;
+    }
+
+    /* ### check the source and target resources flags/types */
+
+    /* ### do lock checks, once behavior is defined */
+
+    /* set the Cache-Control header, per the spec */
+    /* ### correct? */
+    apr_table_setn(r->headers_out, "Cache-Control", "no-cache");
+
+    /* Initialize these values for a standard MERGE response. If the MERGE
+       is going to do something different (i.e. an error), then it must
+       return a dav_error, and we'll reset these values properly. */
+    r->status = HTTP_OK;
+    ap_set_content_type(r, "text/xml");
+
+    /* ### should we do any preliminary response generation? probably not,
+       ### because we may have an error, thus demanding something else in
+       ### the response body. */
+
+    /* Do the merge, including any response generation. */
+    if ((err = (*vsn_hooks->merge)(resource, source_resource,
+                                   no_auto_merge, no_checkout,
+                                   prop_elem,
+                                   r->output_filters)) != NULL) {
+        /* ### is err->status the right error here? */
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not MERGE resource \"%s\" "
+                                          "into \"%s\".",
+                                          ap_escape_html(r->pool, source),
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* the response was fully generated by the merge() hook. */
+    /* ### urk. does this prevent logging? need to check... */
+    return DONE;
+}
+
+static int dav_method_bind(request_rec *r)
+{
+    dav_resource *resource;
+    dav_resource *binding;
+    dav_auto_version_info av_info;
+    const dav_hooks_binding *binding_hooks = DAV_GET_HOOKS_BINDING(r);
+    const char *dest;
+    dav_error *err;
+    dav_error *err2;
+    dav_response *multi_response = NULL;
+    dav_lookup_result lookup;
+    int overwrite;
+
+    /* If no bindings provider, decline the request */
+    if (binding_hooks == NULL)
+        return DECLINED;
+
+    /* Ask repository module to resolve the resource */
+    err = dav_get_resource(r, 0 /* label_allowed */, 0 /* use_checked_in */,
+                           &resource);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    if (!resource->exists) {
+        /* Apache will supply a default error for this. */
+        return HTTP_NOT_FOUND;
+    }
+
+    /* get the destination URI */
+    dest = apr_table_get(r->headers_in, "Destination");
+    if (dest == NULL) {
+        /* This supplies additional information for the default message. */
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00620)
+                      "The request is missing a Destination header.");
+        return HTTP_BAD_REQUEST;
+    }
+
+    lookup = dav_lookup_uri(dest, r, 0 /* must_be_absolute */);
+    if (lookup.rnew == NULL) {
+        if (lookup.err.status == HTTP_BAD_REQUEST) {
+            /* This supplies additional information for the default message. */
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00621)
+                          "%s", lookup.err.desc);
+            return HTTP_BAD_REQUEST;
+        }
+        else if (lookup.err.status == HTTP_BAD_GATEWAY) {
+            /* ### Bindings protocol draft 02 says to return 507
+             * ### (Cross Server Binding Forbidden); Apache already defines 507
+             * ### as HTTP_INSUFFICIENT_STORAGE. So, for now, we'll return
+             * ### HTTP_FORBIDDEN
+             */
+             return dav_error_response(r, HTTP_FORBIDDEN,
+                                       "Cross server bindings are not "
+                                       "allowed by this server.");
+        }
+
+        /* ### this assumes that dav_lookup_uri() only generates a status
+         * ### that Apache can provide a status line for!! */
+
+        return dav_error_response(r, lookup.err.status, lookup.err.desc);
+    }
+    if (lookup.rnew->status != HTTP_OK) {
+        /* ### how best to report this... */
+        return dav_error_response(r, lookup.rnew->status,
+                                  "Destination URI had an error.");
+    }
+
+    /* resolve binding resource */
+    err = dav_get_resource(lookup.rnew, 0 /* label_allowed */,
+                           0 /* use_checked_in */, &binding);
+    if (err != NULL)
+        return dav_handle_err(r, err, NULL);
+
+    /* are the two resources handled by the same repository? */
+    if (resource->hooks != binding->hooks) {
+        /* ### 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. "
+                                  "BIND 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. */
+    if (binding->exists && !overwrite) {
+        return dav_error_response(r, HTTP_PRECONDITION_FAILED,
+                                  "Destination is not empty and "
+                                  "Overwrite is not \"T\"");
+    }
+
+    /* are the source and destination the same? */
+    if ((*resource->hooks->is_same_resource)(resource, binding)) {
+        return dav_error_response(r, HTTP_FORBIDDEN,
+                                  "Source and Destination URIs are the same.");
+    }
+
+    /*
+     * Check If-Headers and existing locks for destination. Note that we
+     * use depth==infinity since the target (hierarchy) will be deleted
+     * before the move/copy is completed.
+     *
+     * Note that we are overwriting the target, which implies a DELETE, so
+     * we are subject to the error/response rules as a DELETE. Namely, we
+     * will return a 424 error if any of the validations fail.
+     * (see dav_method_delete() for more information)
+     */
+    if ((err = dav_validate_request(lookup.rnew, binding, DAV_INFINITY, NULL,
+                                    &multi_response,
+                                    DAV_VALIDATE_PARENT
+                                    | DAV_VALIDATE_USE_424, NULL)) != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not BIND %s due to a "
+                                          "failed precondition on the "
+                                          "destination (e.g. locks).",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, multi_response);
+    }
+
+    /* guard against creating circular bindings */
+    if (resource->collection
+        && (*resource->hooks->is_parent_resource)(resource, binding)) {
+        return dav_error_response(r, HTTP_FORBIDDEN,
+                                  "Source collection contains the Destination.");
+    }
+    if (resource->collection
+        && (*resource->hooks->is_parent_resource)(binding, resource)) {
+        /* The destination must exist (since it contains the source), and
+         * a condition above implies Overwrite==T. Obviously, we cannot
+         * delete the Destination before the BIND, as that would
+         * delete the Source.
+         */
+
+        return dav_error_response(r, HTTP_FORBIDDEN,
+                                  "Destination collection contains the Source and "
+                                  "Overwrite has been specified.");
+    }
+
+    /* prepare the destination collection for modification */
+    if ((err = dav_auto_checkout(r, binding, 1 /* parent_only */,
+                                 &av_info)) != NULL) {
+        /* could not make destination writable */
+        return dav_handle_err(r, err, NULL);
+    }
+
+    /* If target exists, remove it first (we know Ovewrite must be TRUE).
+     * Then try to bind to the resource.
+     */
+    if (binding->exists)
+        err = (*resource->hooks->remove_resource)(binding, &multi_response);
+
+    if (err == NULL) {
+        err = (*binding_hooks->bind_resource)(resource, binding);
+    }
+
+    /* restore parent collection states */
+    err2 = dav_auto_checkin(r, NULL,
+                            err != NULL /* undo if error */,
+                            0 /* unlock */, &av_info);
+
+    /* check for error from remove/bind operations */
+    if (err != NULL) {
+        err = dav_push_error(r->pool, err->status, 0,
+                             apr_psprintf(r->pool,
+                                          "Could not BIND %s.",
+                                          ap_escape_html(r->pool, r->uri)),
+                             err);
+        return dav_handle_err(r, err, multi_response);
+    }
+
+    /* check for errors from reverting writability */
+    if (err2 != NULL) {
+        /* just log a warning */
+        err = dav_push_error(r->pool, err2->status, 0,
+                             "The BIND was successful, but there was a "
+                             "problem automatically checking in the "
+                             "source parent collection.",
+                             err2);
+        dav_log_err(r, err, APLOG_WARNING);
+    }
+
+    /* return an appropriate response (HTTP_CREATED) */
+    /* ### spec doesn't say what happens when destination was replaced */
+    return dav_created(r, lookup.rnew->unparsed_uri, "Binding", 0);
+}
+
+
+/*
+ * Response handler for DAV resources
+ */
+static int dav_handler(request_rec *r)
+{
+    if (strcmp(r->handler, DAV_HANDLER_NAME) != 0)
+        return DECLINED;
+
+    /* Reject requests with an unescaped hash character, as these may
+     * be more destructive than the user intended. */
+    if (r->parsed_uri.fragment != NULL) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00622)
+                     "buggy client used un-escaped hash in Request-URI");
+        return dav_error_response(r, HTTP_BAD_REQUEST,
+                                  "The request was invalid: the URI included "
+                                  "an un-escaped hash character");
+    }
+
+    /* ### do we need to do anything with r->proxyreq ?? */
+
+    /*
+     * ### anything else to do here? could another module and/or
+     * ### 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?)
+     */
+
+    /*
+     * 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
+        | (AP_METHOD_BIT << M_GET)
+        | (AP_METHOD_BIT << M_PUT)
+        | (AP_METHOD_BIT << M_DELETE)
+        | (AP_METHOD_BIT << M_OPTIONS)
+        | (AP_METHOD_BIT << M_INVALID);
+
+    /*
+     * These are the DAV methods we handle.
+     */
+    r->allowed |= 0
+        | (AP_METHOD_BIT << M_COPY)
+        | (AP_METHOD_BIT << M_LOCK)
+        | (AP_METHOD_BIT << M_UNLOCK)
+        | (AP_METHOD_BIT << M_MKCOL)
+        | (AP_METHOD_BIT << M_MOVE)
+        | (AP_METHOD_BIT << M_PROPFIND)
+        | (AP_METHOD_BIT << 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
+        | (AP_METHOD_BIT << 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)
+     */
+
+    /* 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);
+    }
+
+    if (r->method_number == M_VERSION_CONTROL) {
+        return dav_method_vsn_control(r);
+    }
+
+    if (r->method_number == M_CHECKOUT) {
+        return dav_method_checkout(r);
+    }
+
+    if (r->method_number == M_UNCHECKOUT) {
+        return dav_method_uncheckout(r);
+    }
+
+    if (r->method_number == M_CHECKIN) {
+        return dav_method_checkin(r);
+    }
+
+    if (r->method_number == M_UPDATE) {
+        return dav_method_update(r);
+    }
+
+    if (r->method_number == M_LABEL) {
+        return dav_method_label(r);
+    }
+
+    if (r->method_number == M_REPORT) {
+        return dav_method_report(r);
+    }
+
+    if (r->method_number == M_MKWORKSPACE) {
+        return dav_method_make_workspace(r);
+    }
+
+    if (r->method_number == M_MKACTIVITY) {
+        return dav_method_make_activity(r);
+    }
+
+    if (r->method_number == M_BASELINE_CONTROL) {
+        return dav_method_baseline_control(r);
+    }
+
+    if (r->method_number == M_MERGE) {
+        return dav_method_merge(r);
+    }
+
+    /* BIND method */
+    if (r->method_number == dav_methods[DAV_M_BIND]) {
+        return dav_method_bind(r);
+    }
+
+    /* DASL method */
+    if (r->method_number == dav_methods[DAV_M_SEARCH]) {
+        return dav_method_search(r);
+    }
+
+    /* ### add'l methods for Advanced Collections, ACLs */
+
+    return DECLINED;
+}
+
+static int dav_fixups(request_rec *r)
+{
+    dav_dir_conf *conf;
+
+    /* quickly ignore any HTTP/0.9 requests which aren't subreqs. */
+    if (r->assbackwards && !r->main) {
+        return DECLINED;
+    }
+
+    conf = (dav_dir_conf *)ap_get_module_config(r->per_dir_config,
+                                                &dav_module);
+
+    /* if DAV is not enabled, then we've got nothing to do */
+    if (conf->provider == NULL) {
+        return DECLINED;
+    }
+
+    /* We are going to handle almost every request. In certain cases,
+       the provider maps to the filesystem (thus, handle_get is
+       FALSE), and core Apache will handle it. a For that case, we
+       just return right away.  */
+    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->provider->repos->handle_get) {
+            return DECLINED;
+        }
+    }
+
+    /* ### this is wrong.  We should only be setting the r->handler for the
+     * requests that mod_dav knows about.  If we set the handler for M_POST
+     * requests, then CGI scripts that use POST will return the source for the
+     * script.  However, mod_dav DOES handle POST, so something else needs
+     * to be fixed.
+     */
+    if (r->method_number != M_POST) {
+
+        /* We are going to be handling the response for this resource. */
+        r->handler = DAV_HANDLER_NAME;
+        return OK;
+    }
+
+    return DECLINED;
+}
+
+static void register_hooks(apr_pool_t *p)
+{
+    ap_hook_handler(dav_handler, NULL, NULL, APR_HOOK_MIDDLE);
+    ap_hook_post_config(dav_init_handler, NULL, NULL, APR_HOOK_MIDDLE);
+    ap_hook_fixups(dav_fixups, NULL, NULL, APR_HOOK_MIDDLE);
+
+    dav_hook_find_liveprop(dav_core_find_liveprop, NULL, NULL, APR_HOOK_LAST);
+    dav_hook_insert_all_liveprops(dav_core_insert_all_liveprops,
+                                  NULL, NULL, APR_HOOK_MIDDLE);
+
+    dav_core_register_uris(p);
+}
+
+/*---------------------------------------------------------------------------
+ *
+ * Configuration info for the module
+ */
+
+static const command_rec dav_cmds[] =
+{
+    /* per directory/location */
+    AP_INIT_TAKE1("DAV", dav_cmd_dav, NULL, ACCESS_CONF,
+                  "specify the DAV provider for a directory or location"),
+
+    /* per directory/location, or per server */
+    AP_INIT_TAKE1("DAVMinTimeout", dav_cmd_davmintimeout, NULL,
+                  ACCESS_CONF|RSRC_CONF,
+                  "specify minimum allowed timeout"),
+
+    /* per directory/location, or per server */
+    AP_INIT_FLAG("DAVDepthInfinity", dav_cmd_davdepthinfinity, NULL,
+                 ACCESS_CONF|RSRC_CONF,
+                 "allow Depth infinity PROPFIND requests"),
+
+    { NULL }
+};
+
+module DAV_DECLARE_DATA dav_module =
+{
+    STANDARD20_MODULE_STUFF,
+    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 */
+    register_hooks,             /* register hooks */
+};
+
+APR_HOOK_STRUCT(
+    APR_HOOK_LINK(gather_propsets)
+    APR_HOOK_LINK(find_liveprop)
+    APR_HOOK_LINK(insert_all_liveprops)
+    )
+
+APR_IMPLEMENT_EXTERNAL_HOOK_VOID(dav, DAV, gather_propsets,
+                                 (apr_array_header_t *uris),
+                                 (uris))
+
+APR_IMPLEMENT_EXTERNAL_HOOK_RUN_FIRST(dav, DAV, int, find_liveprop,
+                                      (const dav_resource *resource,
+                                       const char *ns_uri, const char *name,
+                                       const dav_hooks_liveprop **hooks),
+                                      (resource, ns_uri, name, hooks), 0)
+
+APR_IMPLEMENT_EXTERNAL_HOOK_VOID(dav, DAV, insert_all_liveprops,
+                                 (request_rec *r, const dav_resource *resource,
+                                  dav_prop_insert what, apr_text_header *phdr),
+                                 (r, resource, what, phdr))
diff --git a/modules/dav/main/mod_dav.dep b/modules/dav/main/mod_dav.dep
new file mode 100644
index 0000000..5efe2f4
--- /dev/null
+++ b/modules/dav/main/mod_dav.dep
@@ -0,0 +1,354 @@
+# Microsoft Developer Studio Generated Dependency File, included by mod_dav.mak
+
+.\liveprop.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\mod_dav.h"\
+	
+
+.\mod_dav.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_expr.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_provider.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.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\httpd.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_cfgtree.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_script.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_dso.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_global_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_lib.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_portable.h"\
+	"..\..\..\srclib\apr\include\apr_proc_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_shm.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\mod_dav.h"\
+	
+
+.\props.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\http_config.h"\
+	"..\..\..\include\http_log.h"\
+	"..\..\..\include\http_request.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_cfgtree.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\mod_dav.h"\
+	
+
+.\providers.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_provider.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\mod_dav.h"\
+	
+
+.\std_liveprop.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_provider.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\mod_dav.h"\
+	
+
+.\util.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\http_config.h"\
+	"..\..\..\include\http_log.h"\
+	"..\..\..\include\http_protocol.h"\
+	"..\..\..\include\http_request.h"\
+	"..\..\..\include\http_vhost.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_cfgtree.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_dso.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_global_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_lib.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_portable.h"\
+	"..\..\..\srclib\apr\include\apr_proc_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_shm.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\mod_dav.h"\
+	
+
+.\util_lock.c : \
+	"..\..\..\include\ap_config.h"\
+	"..\..\..\include\ap_config_layout.h"\
+	"..\..\..\include\ap_expr.h"\
+	"..\..\..\include\ap_hooks.h"\
+	"..\..\..\include\ap_mmn.h"\
+	"..\..\..\include\ap_regex.h"\
+	"..\..\..\include\ap_release.h"\
+	"..\..\..\include\apache_noprobes.h"\
+	"..\..\..\include\http_config.h"\
+	"..\..\..\include\http_core.h"\
+	"..\..\..\include\http_log.h"\
+	"..\..\..\include\http_protocol.h"\
+	"..\..\..\include\httpd.h"\
+	"..\..\..\include\os.h"\
+	"..\..\..\include\util_cfgtree.h"\
+	"..\..\..\include\util_filter.h"\
+	"..\..\..\include\util_xml.h"\
+	"..\..\..\srclib\apr-util\include\apr_buckets.h"\
+	"..\..\..\srclib\apr-util\include\apr_dbm.h"\
+	"..\..\..\srclib\apr-util\include\apr_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional.h"\
+	"..\..\..\srclib\apr-util\include\apr_optional_hooks.h"\
+	"..\..\..\srclib\apr-util\include\apr_uri.h"\
+	"..\..\..\srclib\apr-util\include\apr_xlate.h"\
+	"..\..\..\srclib\apr-util\include\apr_xml.h"\
+	"..\..\..\srclib\apr-util\include\apu.h"\
+	"..\..\..\srclib\apr\include\apr.h"\
+	"..\..\..\srclib\apr\include\apr_allocator.h"\
+	"..\..\..\srclib\apr\include\apr_dso.h"\
+	"..\..\..\srclib\apr\include\apr_errno.h"\
+	"..\..\..\srclib\apr\include\apr_file_info.h"\
+	"..\..\..\srclib\apr\include\apr_file_io.h"\
+	"..\..\..\srclib\apr\include\apr_general.h"\
+	"..\..\..\srclib\apr\include\apr_global_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_hash.h"\
+	"..\..\..\srclib\apr\include\apr_inherit.h"\
+	"..\..\..\srclib\apr\include\apr_mmap.h"\
+	"..\..\..\srclib\apr\include\apr_network_io.h"\
+	"..\..\..\srclib\apr\include\apr_poll.h"\
+	"..\..\..\srclib\apr\include\apr_pools.h"\
+	"..\..\..\srclib\apr\include\apr_portable.h"\
+	"..\..\..\srclib\apr\include\apr_proc_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_ring.h"\
+	"..\..\..\srclib\apr\include\apr_shm.h"\
+	"..\..\..\srclib\apr\include\apr_strings.h"\
+	"..\..\..\srclib\apr\include\apr_tables.h"\
+	"..\..\..\srclib\apr\include\apr_thread_mutex.h"\
+	"..\..\..\srclib\apr\include\apr_thread_proc.h"\
+	"..\..\..\srclib\apr\include\apr_time.h"\
+	"..\..\..\srclib\apr\include\apr_user.h"\
+	"..\..\..\srclib\apr\include\apr_want.h"\
+	".\mod_dav.h"\
+	
+
+..\..\..\build\win32\httpd.rc : \
+	"..\..\..\include\ap_release.h"\
+	
diff --git a/modules/dav/main/mod_dav.dsp b/modules/dav/main/mod_dav.dsp
new file mode 100644
index 0000000..752cea8
--- /dev/null
+++ b/modules/dav/main/mod_dav.dsp
@@ -0,0 +1,147 @@
+# Microsoft Developer Studio Project File - Name="mod_dav" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=mod_dav - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "mod_dav.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "mod_dav.mak" CFG="mod_dav - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "mod_dav - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "mod_dav - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "mod_dav - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FD /c
+# ADD CPP /nologo /MD /W3 /O2 /Oy- /Zi /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "DAV_DECLARE_EXPORT" /Fd"Release\mod_dav_src" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /fo"Release/mod_dav.res" /i "../../../include" /i "../../../srclib/apr/include" /d "NDEBUG" /d BIN_NAME="mod_dav.so" /d LONG_NAME="dav_module for Apache"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /out:".\Release\mod_dav.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav.so
+# ADD LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Release\mod_dav.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav.so /opt:ref
+# Begin Special Build Tool
+TargetPath=.\Release\mod_dav.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+PostBuild_Cmds=if exist $(TargetPath).manifest mt.exe -manifest $(TargetPath).manifest -outputresource:$(TargetPath);2
+# End Special Build Tool
+
+!ELSEIF  "$(CFG)" == "mod_dav - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MDd /W3 /EHsc /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FD /c
+# ADD CPP /nologo /MDd /W3 /EHsc /Zi /Od /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "DAV_DECLARE_EXPORT" /Fd"Debug\mod_dav_src" /FD /c
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /fo"Debug/mod_dav.res" /i "../../../include" /i "../../../srclib/apr/include" /d "_DEBUG" /d BIN_NAME="mod_dav.so" /d LONG_NAME="dav_module for Apache"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Debug\mod_dav.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav.so
+# ADD LINK32 kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Debug\mod_dav.so" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav.so
+# Begin Special Build Tool
+TargetPath=.\Debug\mod_dav.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+PostBuild_Cmds=if exist $(TargetPath).manifest mt.exe -manifest $(TargetPath).manifest -outputresource:$(TargetPath);2
+# End Special Build Tool
+
+!ENDIF 
+
+# Begin Target
+
+# Name "mod_dav - Win32 Release"
+# Name "mod_dav - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\liveprop.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\mod_dav.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\props.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\providers.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\std_liveprop.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\util.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\util_lock.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\mod_dav.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\build\win32\httpd.rc
+# End Source File
+# End Target
+# End Project
diff --git a/modules/dav/main/mod_dav.h b/modules/dav/main/mod_dav.h
new file mode 100644
index 0000000..80ad117
--- /dev/null
+++ b/modules/dav/main/mod_dav.h
@@ -0,0 +1,2553 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file  mod_dav.h
+ * @brief DAV extension module for Apache 2.0.*
+ *
+ * @defgroup MOD_DAV mod_dav
+ * @ingroup APACHE_MODS
+ * @{
+ */
+
+#ifndef _MOD_DAV_H_
+#define _MOD_DAV_H_
+
+#include "apr_hooks.h"
+#include "apr_hash.h"
+#include "apr_dbm.h"
+#include "apr_tables.h"
+
+#include "httpd.h"
+#include "util_filter.h"
+#include "util_xml.h"
+
+#include <limits.h>     /* for INT_MAX */
+#include <time.h>       /* for time_t */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define DAV_VERSION             AP_SERVER_BASEREVISION
+
+#define DAV_XML_HEADER          "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
+#define DAV_XML_CONTENT_TYPE    "text/xml; charset=\"utf-8\""
+
+#define DAV_READ_BLOCKSIZE      2048    /* used for reading input blocks */
+
+#define DAV_RESPONSE_BODY_1     "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<html><head>\n<title>"
+#define DAV_RESPONSE_BODY_2     "</title>\n</head><body>\n<h1>"
+#define DAV_RESPONSE_BODY_3     "</h1>\n<p>"
+#define DAV_RESPONSE_BODY_4     "</p>\n"
+#define DAV_RESPONSE_BODY_5     "</body></html>\n"
+
+#define DAV_DO_COPY             0
+#define DAV_DO_MOVE             1
+
+
+#if 1
+#define DAV_DEBUG        1
+#define DEBUG_CR         "\n"
+#define DBG0(f)          ap_log_error(APLOG_MARK, \
+                                APLOG_ERR, 0, NULL, (f))
+#define DBG1(f,a1)       ap_log_error(APLOG_MARK, \
+                                APLOG_ERR, 0, NULL, f, a1)
+#define DBG2(f,a1,a2)    ap_log_error(APLOG_MARK, \
+                                APLOG_ERR, 0, NULL, f, a1, a2)
+#define DBG3(f,a1,a2,a3) ap_log_error(APLOG_MARK, \
+                                APLOG_ERR, 0, NULL, f, a1, a2, a3)
+#else
+#undef DAV_DEBUG
+#define DEBUG_CR        ""
+#endif
+
+#define DAV_INFINITY    INT_MAX    /* for the Depth: header */
+
+/* Create a set of DAV_DECLARE(type), DAV_DECLARE_NONSTD(type) and
+ * DAV_DECLARE_DATA with appropriate export and import tags for the platform
+ */
+#if !defined(WIN32)
+#define DAV_DECLARE(type)            type
+#define DAV_DECLARE_NONSTD(type)     type
+#define DAV_DECLARE_DATA
+#elif defined(DAV_DECLARE_STATIC)
+#define DAV_DECLARE(type)            type __stdcall
+#define DAV_DECLARE_NONSTD(type)     type
+#define DAV_DECLARE_DATA
+#elif defined(DAV_DECLARE_EXPORT)
+#define DAV_DECLARE(type)            __declspec(dllexport) type __stdcall
+#define DAV_DECLARE_NONSTD(type)     __declspec(dllexport) type
+#define DAV_DECLARE_DATA             __declspec(dllexport)
+#else
+#define DAV_DECLARE(type)            __declspec(dllimport) type __stdcall
+#define DAV_DECLARE_NONSTD(type)     __declspec(dllimport) type
+#define DAV_DECLARE_DATA             __declspec(dllimport)
+#endif
+
+/* --------------------------------------------------------------------
+**
+** ERROR MANAGEMENT
+*/
+
+/*
+** dav_error structure.
+**
+** In most cases, mod_dav uses a pointer to a dav_error structure. If the
+** pointer is NULL, then no error has occurred.
+**
+** In certain cases, a dav_error structure is directly used. In these cases,
+** a status value of 0 means that an error has not occurred.
+**
+** Note: this implies that status != 0 whenever an error occurs.
+**
+** The desc field is optional (it may be NULL). When NULL, it typically
+** implies that Apache has a proper description for the specified status.
+*/
+typedef struct dav_error {
+    int status;                 /* suggested HTTP status (0 for no error) */
+    int error_id;               /* DAV-specific error ID */
+    const char *desc;           /* DAV:responsedescription and error log */
+
+    apr_status_t aprerr;        /* APR error if any, or 0/APR_SUCCESS */
+
+    const char *namespace;      /* [optional] namespace of error */
+    const char *tagname;        /* name of error-tag */
+
+    struct dav_error *prev;     /* previous error (in stack) */
+
+    const char *childtags;      /* error-tag may have children */
+
+} dav_error;
+
+/*
+** Create a new error structure. save_errno will be filled with the current
+** errno value.
+*/
+DAV_DECLARE(dav_error*) dav_new_error(apr_pool_t *p, int status,
+                                      int error_id, apr_status_t aprerr,
+                                      const char *desc);
+
+
+/*
+** Create a new error structure with tagname and (optional) namespace;
+** namespace may be NULL, which means "DAV:".
+*/
+DAV_DECLARE(dav_error*) dav_new_error_tag(apr_pool_t *p, int status,
+                                          int error_id, apr_status_t aprerr,
+                                          const char *desc,
+                                          const char *namespace,
+                                          const char *tagname);
+
+
+/*
+** Push a new error description onto the stack of errors.
+**
+** This function is used to provide an additional description to an existing
+** error.
+**
+** <status> should contain the caller's view of what the current status is,
+** given the underlying error. If it doesn't have a better idea, then the
+** caller should pass prev->status.
+**
+** <error_id> can specify a new error_id since the topmost description has
+** changed.
+*/
+DAV_DECLARE(dav_error*) dav_push_error(apr_pool_t *p, int status, int error_id,
+                                       const char *desc, dav_error *prev);
+
+
+/*
+** Join two errors together.
+**
+** This function is used to add a new error stack onto an existing error so
+** that subsequent errors can be reported after the first error.  It returns
+** the correct error stack to use so that the caller can blindly call it
+** without checking that both dest and src are not NULL.
+** 
+** <dest> is the error stack that the error will be added to.
+**
+** <src> is the error stack that will be appended.
+*/
+DAV_DECLARE(dav_error*) dav_join_error(dav_error* dest, dav_error* src);
+
+typedef struct dav_response dav_response;
+
+/*
+** 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
+**   - vsn_hooks->update
+*/
+DAV_DECLARE(int) dav_handle_err(request_rec *r, dav_error *err,
+                                dav_response *response);
+
+/* error ID values... */
+
+/* IF: header errors */
+#define DAV_ERR_IF_PARSE                100    /* general parsing error */
+#define DAV_ERR_IF_MULTIPLE_NOT         101    /* multiple "Not" found */
+#define DAV_ERR_IF_UNK_CHAR             102    /* unknown char in header */
+#define DAV_ERR_IF_ABSENT               103    /* no locktokens given */
+#define DAV_ERR_IF_TAGGED               104    /* in parsing tagged-list */
+#define DAV_ERR_IF_UNCLOSED_PAREN       105    /* in no-tagged-list */
+
+/* Prop DB errors */
+#define DAV_ERR_PROP_BAD_MAJOR          200    /* major version was wrong */
+#define DAV_ERR_PROP_READONLY           201    /* prop is read-only */
+#define DAV_ERR_PROP_NO_DATABASE        202    /* writable db not avail */
+#define DAV_ERR_PROP_NOT_FOUND          203    /* prop not found */
+#define DAV_ERR_PROP_BAD_LOCKDB         204    /* could not open lockdb */
+#define DAV_ERR_PROP_OPENING            205    /* problem opening propdb */
+#define DAV_ERR_PROP_EXEC               206    /* problem exec'ing patch */
+
+/* Predefined DB errors */
+/* ### any to define?? */
+
+/* Predefined locking system errors */
+#define DAV_ERR_LOCK_OPENDB             400    /* could not open lockdb */
+#define DAV_ERR_LOCK_NO_DB              401    /* no database defined */
+#define DAV_ERR_LOCK_CORRUPT_DB         402    /* DB is corrupt */
+#define DAV_ERR_LOCK_UNK_STATE_TOKEN    403    /* unknown State-token */
+#define DAV_ERR_LOCK_PARSE_TOKEN        404    /* bad opaquelocktoken */
+#define DAV_ERR_LOCK_SAVE_LOCK          405    /* err saving locks */
+
+/*
+** Some comments on Error ID values:
+**
+** The numbers do not necessarily need to be unique. Uniqueness simply means
+** that two errors that have not been predefined above can be distinguished
+** from each other. At the moment, mod_dav does not use this distinguishing
+** feature, but it could be used in the future to collapse <response> elements
+** into groups based on the error ID (and associated responsedescription).
+**
+** If a compute_desc is provided, then the error ID should be unique within
+** the context of the compute_desc function (so the function can figure out
+** what to filled into the desc).
+**
+** Basically, subsystems can ignore defining new error ID values if they want
+** to. The subsystems *do* need to return the predefined errors when
+** appropriate, so that mod_dav can figure out what to do. Subsystems can
+** simply leave the error ID field unfilled (zero) if there isn't an error
+** that must be placed there.
+*/
+
+
+/* --------------------------------------------------------------------
+**
+** HOOK STRUCTURES
+**
+** These are here for forward-declaration purposes. For more info, see
+** the section title "HOOK HANDLING" for more information, plus each
+** structure definition.
+*/
+
+/* forward-declare this structure */
+typedef struct dav_hooks_propdb dav_hooks_propdb;
+typedef struct dav_hooks_locks dav_hooks_locks;
+typedef struct dav_hooks_vsn dav_hooks_vsn;
+typedef struct dav_hooks_repository dav_hooks_repository;
+typedef struct dav_hooks_liveprop dav_hooks_liveprop;
+typedef struct dav_hooks_binding dav_hooks_binding;
+typedef struct dav_hooks_search dav_hooks_search;
+
+/* ### deprecated name */
+typedef dav_hooks_propdb dav_hooks_db;
+
+
+/* --------------------------------------------------------------------
+**
+** RESOURCE HANDLING
+*/
+
+/*
+** Resource Types:
+** The base protocol defines only file and collection resources.
+** The versioning protocol defines several additional resource types
+** to represent artifacts of a version control system.
+**
+** This enumeration identifies the type of URL used to identify the
+** resource. Since the same resource may have more than one type of
+** URL which can identify it, dav_resource_type cannot be used
+** alone to determine the type of the resource; attributes of the
+** dav_resource object must also be consulted.
+*/
+typedef enum {
+    DAV_RESOURCE_TYPE_UNKNOWN,
+
+    DAV_RESOURCE_TYPE_REGULAR,          /* file or collection; could be
+                                         * unversioned, or version selector,
+                                         * or baseline selector */
+
+    DAV_RESOURCE_TYPE_VERSION,          /* version or baseline URL */
+
+    DAV_RESOURCE_TYPE_HISTORY,          /* version or baseline history URL */
+
+    DAV_RESOURCE_TYPE_WORKING,          /* working resource URL */
+
+    DAV_RESOURCE_TYPE_WORKSPACE,        /* workspace URL */
+
+    DAV_RESOURCE_TYPE_ACTIVITY,         /* activity URL */
+
+    DAV_RESOURCE_TYPE_PRIVATE           /* repository-private type */
+
+} dav_resource_type;
+
+/*
+** Opaque, repository-specific information for a resource.
+*/
+typedef struct dav_resource_private dav_resource_private;
+
+/*
+** Resource descriptor, generated by a repository provider.
+**
+** Note: the lock-null state is not explicitly represented here,
+** since it may be expensive to compute. Use dav_get_resource_state()
+** to determine whether a non-existent resource is a lock-null resource.
+**
+** A quick explanation of how the flags can apply to different resources:
+**
+** unversioned file or collection:
+**     type       = DAV_RESOURCE_TYPE_REGULAR
+**     exists     = ? (1 if exists)
+**     collection = ? (1 if collection)
+**     versioned  = 0
+**     baselined  = 0
+**     working    = 0
+**
+** version-controlled resource or configuration:
+**     type       = DAV_RESOURCE_TYPE_REGULAR
+**     exists     = 1
+**     collection = ? (1 if collection)
+**     versioned  = 1
+**     baselined  = ? (1 if configuration)
+**     working    = ? (1 if checked out)
+**
+** version/baseline history:
+**     type       = DAV_RESOURCE_TYPE_HISTORY
+**     exists     = 1
+**     collection = 0
+**     versioned  = 0
+**     baselined  = 0
+**     working    = 0
+**
+** version/baseline:
+**     type       = DAV_RESOURCE_TYPE_VERSION
+**     exists     = 1
+**     collection = ? (1 if collection)
+**     versioned  = 1
+**     baselined  = ? (1 if baseline)
+**     working    = 0
+**
+** working resource:
+**     type       = DAV_RESOURCE_TYPE_WORKING
+**     exists     = 1
+**     collection = ? (1 if collection)
+**     versioned  = 1
+**     baselined  = 0
+**     working    = 1
+**
+** workspace:
+**     type       = DAV_RESOURCE_TYPE_WORKSPACE
+**     exists     = ? (1 if exists)
+**     collection = 1
+**     versioned  = ? (1 if version-controlled)
+**     baselined  = ? (1 if baseline-controlled)
+**     working    = ? (1 if checked out)
+**
+** activity:
+**     type       = DAV_RESOURCE_TYPE_ACTIVITY
+**     exists     = ? (1 if exists)
+**     collection = 0
+**     versioned  = 0
+**     baselined  = 0
+**     working    = 0
+*/
+typedef struct dav_resource {
+    dav_resource_type type;
+
+    int exists;         /* 0 => null resource */
+
+    int collection;     /* 0 => file; can be 1 for
+                         * REGULAR, VERSION, and WORKING resources,
+                         * and is always 1 for WORKSPACE */
+
+    int versioned;      /* 0 => unversioned; can be 1 for
+                         * REGULAR and WORKSPACE resources,
+                         * and is always 1 for VERSION and WORKING */
+
+    int baselined;      /* 0 => not baselined; can be 1 for
+                         * REGULAR, VERSION, and WORKSPACE resources;
+                         * versioned == 1 when baselined == 1 */
+
+    int working;        /* 0 => not checked out; can be 1 for
+                         * REGULAR and WORKSPACE resources,
+                         * and is always 1 for WORKING */
+
+    const char *uri;    /* the URI for this resource;
+                         * currently has an ABI flaw where sometimes it is
+                         * assumed to be encoded and sometimes not */
+
+    dav_resource_private *info;         /* the provider's private info */
+
+    const dav_hooks_repository *hooks;  /* hooks used for this resource */
+
+    /* When allocating items related specifically to this resource, the
+       following pool should be used. Its lifetime will be at least as
+       long as the dav_resource structure. */
+    apr_pool_t *pool;
+
+} dav_resource;
+
+/*
+** Lock token type. Lock providers define the details of a lock token.
+** However, all providers are expected to at least be able to parse
+** the "opaquelocktoken" scheme, which is represented by a uuid_t.
+*/
+typedef struct dav_locktoken dav_locktoken;
+
+
+/* --------------------------------------------------------------------
+**
+** BUFFER HANDLING
+**
+** These buffers are used as a lightweight buffer reuse mechanism. Apache
+** provides sub-pool creation and destruction to much the same effect, but
+** the sub-pools are a bit more general and heavyweight than these buffers.
+*/
+
+/* buffer for reuse; can grow to accommodate needed size */
+typedef struct
+{
+    apr_size_t alloc_len;       /* how much has been allocated */
+    apr_size_t cur_len;         /* how much is currently being used */
+    char *buf;                  /* buffer contents */
+} dav_buffer;
+#define DAV_BUFFER_MINSIZE      256    /* minimum size for buffer */
+#define DAV_BUFFER_PAD          64     /* amount of pad when growing */
+
+/* set the cur_len to the given size and ensure space is available */
+DAV_DECLARE(void) dav_set_bufsize(apr_pool_t *p, dav_buffer *pbuf,
+                                  apr_size_t size);
+
+/* initialize a buffer and copy the specified (null-term'd) string into it */
+DAV_DECLARE(void) dav_buffer_init(apr_pool_t *p, dav_buffer *pbuf,
+                                  const char *str);
+
+/* check that the buffer can accommodate <extra_needed> more bytes */
+DAV_DECLARE(void) dav_check_bufsize(apr_pool_t *p, dav_buffer *pbuf,
+                                    apr_size_t extra_needed);
+
+/* append a string to the end of the buffer, adjust length */
+DAV_DECLARE(void) dav_buffer_append(apr_pool_t *p, dav_buffer *pbuf,
+                                    const char *str);
+
+/* place a string on the end of the buffer, do NOT adjust length */
+DAV_DECLARE(void) dav_buffer_place(apr_pool_t *p, dav_buffer *pbuf,
+                                   const char *str);
+
+/* place some memory on the end of a buffer; do NOT adjust length */
+DAV_DECLARE(void) dav_buffer_place_mem(apr_pool_t *p, dav_buffer *pbuf,
+                                       const void *mem, apr_size_t amt,
+                                       apr_size_t pad);
+
+
+/* --------------------------------------------------------------------
+**
+** HANDY UTILITIES
+*/
+
+/* contains results from one of the getprop functions */
+typedef struct
+{
+    apr_text * propstats;       /* <propstat> element text */
+    apr_text * xmlns;           /* namespace decls for <response> elem */
+} dav_get_props_result;
+
+/* holds the contents of a <response> element */
+struct dav_response
+{
+    const char *href;           /* always */
+    const char *desc;           /* optional description at <response> level */
+
+    /* use status if propresult.propstats is NULL. */
+    dav_get_props_result propresult;
+
+    int status;
+
+    struct dav_response *next;
+};
+
+typedef struct
+{
+    request_rec *rnew;          /* new subrequest */
+    dav_error err;              /* potential error response */
+} dav_lookup_result;
+
+
+DAV_DECLARE(dav_lookup_result) dav_lookup_uri(const char *uri, request_rec *r,
+                                              int must_be_absolute);
+
+/* defines type of property info a provider is to return */
+typedef enum {
+    DAV_PROP_INSERT_NOTDEF,     /* property is defined by this provider,
+                                   but nothing was inserted because the
+                                   (live) property is not defined for this
+                                   resource (it may be present as a dead
+                                   property). */
+    DAV_PROP_INSERT_NOTSUPP,    /* property is recognized by this provider,
+                                   but it is not supported, and cannot be
+                                   treated as a dead property */
+    DAV_PROP_INSERT_NAME,       /* a property name (empty elem) was
+                                   inserted into the text block */
+    DAV_PROP_INSERT_VALUE,      /* a property name/value pair was inserted
+                                   into the text block */
+    DAV_PROP_INSERT_SUPPORTED   /* a supported live property was added to
+                                   the text block as a
+                                   <DAV:supported-live-property> element */
+} dav_prop_insert;
+
+/* ### this stuff is private to dav/fs/repos.c; move it... */
+/* format a time string (buf must be at least DAV_TIMEBUF_SIZE chars) */
+#define DAV_STYLE_ISO8601       1
+#define DAV_STYLE_RFC822        2
+#define DAV_TIMEBUF_SIZE        30
+
+/* Write a complete RESPONSE object out as a <DAV:response> xml
+ * element.  Data is sent into brigade BB, which is auto-flushed into
+ * the output filter stack for request R.  Use POOL for any temporary
+ * allocations.
+ *
+ * [Presumably the <multistatus> tag has already been written;  this
+ * routine is shared by dav_send_multistatus and dav_stream_response.]
+ */
+DAV_DECLARE(void) dav_send_one_response(dav_response *response,
+                                        apr_bucket_brigade *bb,
+                                        request_rec *r,
+                                        apr_pool_t *pool);
+
+/* Factorized helper function: prep request_rec R for a multistatus
+ * response and write <multistatus> tag into BB, destined for
+ * R->output_filters.  Use xml NAMESPACES in initial tag, if
+ * non-NULL.
+ */
+DAV_DECLARE(void) dav_begin_multistatus(apr_bucket_brigade *bb,
+                                        request_rec *r, int status,
+                                        apr_array_header_t *namespaces);
+
+/* Finish a multistatus response started by dav_begin_multistatus: */
+DAV_DECLARE(apr_status_t) dav_finish_multistatus(request_rec *r,
+                                                 apr_bucket_brigade *bb);
+
+/* Send a multistatus response */
+DAV_DECLARE(void) dav_send_multistatus(request_rec *r, int status,
+                                       dav_response *first,
+                                       apr_array_header_t *namespaces);
+
+DAV_DECLARE(apr_text *) dav_failed_proppatch(apr_pool_t *p,
+                                             apr_array_header_t *prop_ctx);
+DAV_DECLARE(apr_text *) dav_success_proppatch(apr_pool_t *p,
+                                              apr_array_header_t *prop_ctx);
+
+DAV_DECLARE(int) dav_get_depth(request_rec *r, int def_depth);
+
+DAV_DECLARE(int) dav_validate_root(const apr_xml_doc *doc,
+                                   const char *tagname);
+DAV_DECLARE(apr_xml_elem *) dav_find_child(const apr_xml_elem *elem,
+                                           const char *tagname);
+
+/* gather up all the CDATA into a single string */
+DAV_DECLARE(const char *) dav_xml_get_cdata(const apr_xml_elem *elem, apr_pool_t *pool,
+                              int strip_white);
+
+/*
+** XML namespace handling
+**
+** This structure tracks namespace declarations (xmlns:prefix="URI").
+** It maintains a one-to-many relationship of URIs-to-prefixes. In other
+** words, one URI may be defined by many prefixes, but any specific
+** prefix will specify only one URI.
+**
+** Prefixes using the "g###" pattern can be generated automatically if
+** the caller does not have specific prefix requirements.
+*/
+typedef struct {
+    apr_pool_t *pool;
+    apr_hash_t *uri_prefix;     /* map URIs to an available prefix */
+    apr_hash_t *prefix_uri;     /* map all prefixes to their URIs */
+    int count;                  /* counter for "g###" prefixes */
+} dav_xmlns_info;
+
+/* create an empty dav_xmlns_info structure */
+DAV_DECLARE(dav_xmlns_info *) dav_xmlns_create(apr_pool_t *pool);
+
+/* add a specific prefix/URI pair. the prefix/uri should have a lifetime
+   at least that of xmlns->pool */
+DAV_DECLARE(void) dav_xmlns_add(dav_xmlns_info *xi,
+                                const char *prefix, const char *uri);
+
+/* add a URI (if not present); any prefix is acceptable and is returned.
+   the uri should have a lifetime at least that xmlns->pool */
+DAV_DECLARE(const char *) dav_xmlns_add_uri(dav_xmlns_info *xi,
+                                            const char *uri);
+
+/* return the URI for a specified prefix (or NULL if the prefix is unknown) */
+DAV_DECLARE(const char *) dav_xmlns_get_uri(dav_xmlns_info *xi,
+                                            const char *prefix);
+
+/* return an available prefix for a specified URI (or NULL if the URI
+   is unknown) */
+DAV_DECLARE(const char *) dav_xmlns_get_prefix(dav_xmlns_info *xi,
+                                               const char *uri);
+
+/* generate xmlns declarations (appending into the given text) */
+DAV_DECLARE(void) dav_xmlns_generate(dav_xmlns_info *xi,
+                                     apr_text_header *phdr);
+
+/* --------------------------------------------------------------------
+**
+** DAV PLUGINS
+*/
+
+/* ### docco ... */
+
+/*
+** dav_provider
+**
+** This structure wraps up all of the hooks that a mod_dav provider can
+** supply. The provider MUST supply <repos> and <propdb>. The rest are
+** optional and should contain NULL if that feature is not supplied.
+**
+** Note that a provider cannot pick and choose portions from various
+** underlying implementations (which was theoretically possible in
+** mod_dav 1.0). There are too many dependencies between a dav_resource
+** (defined by <repos>) and the other functionality.
+**
+** Live properties are not part of the dav_provider structure because they
+** are handled through the APR_HOOK interface (to allow for multiple liveprop
+** providers). The core always provides some properties, and then a given
+** provider will add more properties.
+**
+** Some providers may need to associate a context with the dav_provider
+** structure -- the ctx field is available for storing this context. Just
+** leave it NULL if it isn't required.
+*/
+typedef struct {
+    const dav_hooks_repository *repos;
+    const dav_hooks_propdb *propdb;
+    const dav_hooks_locks *locks;
+    const dav_hooks_vsn *vsn;
+    const dav_hooks_binding *binding;
+    const dav_hooks_search *search;
+
+    void *ctx;
+} dav_provider;
+
+/*
+** gather_propsets: gather all live property propset-URIs
+**
+** The hook implementor should push one or more URIs into the specified
+** array. These URIs are returned in the DAV: header to let clients know
+** what sets of live properties are supported by the installation. mod_dav
+** will place open/close angle brackets around each value (much like
+** a Coded-URL); quotes and brackets should not be in the value.
+**
+** Example:    http://apache.org/dav/props/
+**
+** (of course, use your own domain to ensure a unique value)
+*/
+APR_DECLARE_EXTERNAL_HOOK(dav, DAV, void, gather_propsets,
+                         (apr_array_header_t *uris))
+
+/*
+** find_liveprop: find a live property, returning a non-zero, unique,
+**                opaque identifier.
+**
+** If the hook implementor determines the specified URI/name refers to
+** one of its properties, then it should fill in HOOKS and return a
+** non-zero value. The returned value is the "property ID" and will
+** be passed to the various liveprop hook functions.
+**
+** Return 0 if the property is not defined by the hook implementor.
+*/
+APR_DECLARE_EXTERNAL_HOOK(dav, DAV, int, find_liveprop,
+                         (const dav_resource *resource,
+                          const char *ns_uri, const char *name,
+                          const dav_hooks_liveprop **hooks))
+
+/*
+** insert_all_liveprops: insert all (known) live property names/values.
+**
+** The hook implementor should append XML text to PHDR, containing liveprop
+** names. If INSVALUE is true, then the property values should also be
+** inserted into the output XML stream.
+**
+** The liveprop provider should insert *all* known and *defined* live
+** properties on the specified resource. If a particular liveprop is
+** not defined for this resource, then it should not be inserted.
+*/
+APR_DECLARE_EXTERNAL_HOOK(dav, DAV, void, insert_all_liveprops,
+                         (request_rec *r, const dav_resource *resource,
+                          dav_prop_insert what, apr_text_header *phdr))
+
+DAV_DECLARE(const dav_hooks_locks *) dav_get_lock_hooks(request_rec *r);
+DAV_DECLARE(const dav_hooks_propdb *) dav_get_propdb_hooks(request_rec *r);
+DAV_DECLARE(const dav_hooks_vsn *) dav_get_vsn_hooks(request_rec *r);
+DAV_DECLARE(const dav_hooks_binding *) dav_get_binding_hooks(request_rec *r);
+DAV_DECLARE(const dav_hooks_search *) dav_get_search_hooks(request_rec *r);
+
+DAV_DECLARE(void) dav_register_provider(apr_pool_t *p, const char *name,
+                                        const dav_provider *hooks);
+DAV_DECLARE(const dav_provider *) dav_lookup_provider(const char *name);
+DAV_DECLARE(const char *) dav_get_provider_name(request_rec *r);
+
+
+/* ### deprecated */
+#define DAV_GET_HOOKS_PROPDB(r)         dav_get_propdb_hooks(r)
+#define DAV_GET_HOOKS_LOCKS(r)          dav_get_lock_hooks(r)
+#define DAV_GET_HOOKS_VSN(r)            dav_get_vsn_hooks(r)
+#define DAV_GET_HOOKS_BINDING(r)        dav_get_binding_hooks(r)
+#define DAV_GET_HOOKS_SEARCH(r)         dav_get_search_hooks(r)
+
+
+/* --------------------------------------------------------------------
+**
+** IF HEADER PROCESSING
+**
+** Here is the definition of the If: header from RFC 2518, S9.4:
+**
+**    If = "If" ":" (1*No-tag-list | 1*Tagged-list)
+**    No-tag-list = List
+**    Tagged-list = Resource 1*List
+**    Resource = Coded-URL
+**    List = "(" 1*(["Not"](State-token | "[" entity-tag "]")) ")"
+**    State-token = Coded-URL
+**    Coded-URL = "<" absoluteURI ">"        ; absoluteURI from RFC 2616
+**
+** List corresponds to dav_if_state_list. No-tag-list corresponds to
+** dav_if_header with uri==NULL. Tagged-list corresponds to a sequence of
+** dav_if_header structures with (duplicate) uri==Resource -- one
+** dav_if_header per state_list. A second Tagged-list will start a new
+** sequence of dav_if_header structures with the new URI.
+**
+** A summary of the semantics, mapped into our structures:
+**    - Chained dav_if_headers: OR
+**    - Chained dav_if_state_lists: AND
+**    - NULL uri matches all resources
+*/
+
+typedef enum
+{
+    dav_if_etag,
+    dav_if_opaquelock,
+    dav_if_unknown /* the "unknown" state type; always matches false. */
+} dav_if_state_type;
+
+typedef struct dav_if_state_list
+{
+    dav_if_state_type type;
+
+    int condition;
+#define DAV_IF_COND_NORMAL      0
+#define DAV_IF_COND_NOT         1    /* "Not" was applied */
+
+    const char *etag;
+    dav_locktoken *locktoken;
+
+    struct dav_if_state_list *next;
+} dav_if_state_list;
+
+typedef struct dav_if_header
+{
+    const char *uri;
+    apr_size_t uri_len;
+    struct dav_if_state_list *state;
+    struct dav_if_header *next;
+
+    int dummy_header;   /* used internally by the lock/etag validation */
+} dav_if_header;
+
+typedef struct dav_locktoken_list
+{
+    dav_locktoken *locktoken;
+    struct dav_locktoken_list *next;
+} dav_locktoken_list;
+
+DAV_DECLARE(dav_error *) dav_get_locktoken_list(request_rec *r,
+                                                dav_locktoken_list **ltl);
+
+
+/* --------------------------------------------------------------------
+**
+** LIVE PROPERTY HANDLING
+*/
+
+/* opaque type for PROPPATCH rollback information */
+typedef struct dav_liveprop_rollback dav_liveprop_rollback;
+
+struct dav_hooks_liveprop
+{
+    /*
+    ** Insert property information into a text block. The property to
+    ** insert is identified by the propid value. The information to insert
+    ** is identified by the "what" argument, as follows:
+    **   DAV_PROP_INSERT_NAME
+    **      property name, as an empty XML element
+    **   DAV_PROP_INSERT_VALUE
+    **      property name/value, as an XML element
+    **   DAV_PROP_INSERT_SUPPORTED
+    **      if the property is defined on the resource, then
+    **      a DAV:supported-live-property element, as defined
+    **      by the DeltaV extensions to RFC2518.
+    **
+    ** Providers should return DAV_PROP_INSERT_NOTDEF if the property is
+    ** known and not defined for this resource, so should be handled as a
+    ** dead property. If a provider recognizes, but does not support, a
+    ** property, and does not want it handled as a dead property, it should
+    ** return DAV_PROP_INSERT_NOTSUPP.
+    **
+    ** Returns one of DAV_PROP_INSERT_* based on what happened.
+    **
+    ** ### we may need more context... ie. the lock database
+    */
+    dav_prop_insert (*insert_prop)(const dav_resource *resource,
+                                   int propid, dav_prop_insert what,
+                                   apr_text_header *phdr);
+
+    /*
+    ** Determine whether a given property is writable.
+    **
+    ** ### we may want a different semantic. i.e. maybe it should be
+    ** ### "can we write <value> into this property?"
+    **
+    ** Returns 1 if the live property can be written, 0 if read-only.
+    */
+    int (*is_writable)(const dav_resource *resource, int propid);
+
+    /*
+    ** This member defines the set of namespace URIs that the provider
+    ** uses for its properties. When insert_all is called, it will be
+    ** passed a list of integers that map from indices into this list
+    ** to namespace IDs for output generation.
+    **
+    ** The last entry in this list should be a NULL value (sentinel).
+    */
+    const char * const * namespace_uris;
+
+    /*
+    ** ### this is not the final design. we want an open-ended way for
+    ** ### liveprop providers to attach *new* properties. To this end,
+    ** ### we'll have a "give me a list of the props you define", a way
+    ** ### to check for a prop's existence, a way to validate a set/remove
+    ** ### of a prop, and a way to execute/commit/rollback that change.
+    */
+
+    /*
+    ** Validate that the live property can be assigned a value, and that
+    ** the provided value is valid.
+    **
+    ** elem will point to the XML element that names the property. For
+    ** example:
+    **     <lp1:executable>T</lp1:executable>
+    **
+    ** The provider can access the cdata fields and the child elements
+    ** to extract the relevant pieces.
+    **
+    ** operation is one of DAV_PROP_OP_SET or _DELETE.
+    **
+    ** The provider may return a value in *context which will be passed
+    ** to each of the exec/commit/rollback functions. For example, this
+    ** may contain an internal value which has been processed from the
+    ** input element.
+    **
+    ** The provider must set defer_to_dead to true (non-zero) or false.
+    ** If true, then the set/remove is deferred to the dead property
+    ** database. Note: it will be set to zero on entry.
+    */
+    dav_error * (*patch_validate)(const dav_resource *resource,
+                                  const apr_xml_elem *elem,
+                                  int operation,
+                                  void **context,
+                                  int *defer_to_dead);
+
+    /* ### doc... */
+    dav_error * (*patch_exec)(const dav_resource *resource,
+                              const apr_xml_elem *elem,
+                              int operation,
+                              void *context,
+                              dav_liveprop_rollback **rollback_ctx);
+
+    /* ### doc... */
+    void (*patch_commit)(const dav_resource *resource,
+                         int operation,
+                         void *context,
+                         dav_liveprop_rollback *rollback_ctx);
+
+    /* ### doc... */
+    dav_error * (*patch_rollback)(const dav_resource *resource,
+                                  int operation,
+                                  void *context,
+                                  dav_liveprop_rollback *rollback_ctx);
+
+    /*
+    ** If a provider needs a context to associate with this hooks structure,
+    ** then this field may be used. In most cases, it will just be NULL.
+    */
+    void *ctx;
+};
+
+/*
+** dav_liveprop_spec: specify a live property
+**
+** This structure is used as a standard way to determine if a particular
+** property is a live property. Its use is not part of the mandated liveprop
+** interface, but can be used by liveprop providers in conjunction with the
+** utility routines below.
+**
+** spec->name == NULL is the defined end-sentinel for a list of specs.
+*/
+typedef struct {
+    int ns;             /* provider-local namespace index */
+    const char *name;   /* name of the property */
+
+    int propid;         /* provider-local property ID */
+
+    int is_writable;    /* is the property writable? */
+
+} dav_liveprop_spec;
+
+/*
+** dav_liveprop_group: specify a group of liveprops
+**
+** This structure specifies a group of live properties, their namespaces,
+** and how to handle them.
+*/
+typedef struct {
+    const dav_liveprop_spec *specs;
+    const char * const *namespace_uris;
+    const dav_hooks_liveprop *hooks;
+
+} dav_liveprop_group;
+
+/* ### docco */
+DAV_DECLARE(int) dav_do_find_liveprop(const char *ns_uri, const char *name,
+                                      const dav_liveprop_group *group,
+                                      const dav_hooks_liveprop **hooks);
+
+/* ### docco */
+DAV_DECLARE(long) dav_get_liveprop_info(int propid,
+                                        const dav_liveprop_group *group,
+                                        const dav_liveprop_spec **info);
+
+/* ### docco */
+DAV_DECLARE(void) dav_register_liveprop_group(apr_pool_t *pool,
+                                              const dav_liveprop_group *group);
+
+/* ### docco */
+DAV_DECLARE(long) dav_get_liveprop_ns_index(const char *uri);
+
+/* ### docco */
+DAV_DECLARE(long) dav_get_liveprop_ns_count(void);
+
+/* ### docco */
+DAV_DECLARE(void) dav_add_all_liveprop_xmlns(apr_pool_t *p,
+                                             apr_text_header *phdr);
+
+/*
+** The following three functions are part of mod_dav's internal handling
+** for the core WebDAV properties. They are not part of mod_dav's API.
+*/
+DAV_DECLARE_NONSTD(int) dav_core_find_liveprop(
+    const dav_resource *resource,
+    const char *ns_uri,
+    const char *name,
+    const dav_hooks_liveprop **hooks);
+DAV_DECLARE_NONSTD(void) dav_core_insert_all_liveprops(
+    request_rec *r,
+    const dav_resource *resource,
+    dav_prop_insert what,
+    apr_text_header *phdr);
+DAV_DECLARE_NONSTD(void) dav_core_register_uris(apr_pool_t *p);
+
+
+/*
+** Standard WebDAV Property Identifiers
+**
+** A live property provider does not need to use these; they are simply
+** provided for convenience.
+**
+** Property identifiers need to be unique within a given provider, but not
+** *across* providers (note: this uniqueness constraint was different in
+** older versions of mod_dav).
+**
+** The identifiers start at 20000 to make it easier for providers to avoid
+** conflicts with the standard properties. The properties are arranged
+** alphabetically, and may be reordered from time to time (as properties
+** are introduced).
+**
+** NOTE: there is no problem with reordering (e.g. binary compat) since the
+** identifiers are only used within a given provider, which would pick up
+** the entire set of changes upon a recompile.
+*/
+enum {
+    DAV_PROPID_BEGIN = 20000,
+
+    /* Standard WebDAV properties (RFC 2518) */
+    DAV_PROPID_creationdate,
+    DAV_PROPID_displayname,
+    DAV_PROPID_getcontentlanguage,
+    DAV_PROPID_getcontentlength,
+    DAV_PROPID_getcontenttype,
+    DAV_PROPID_getetag,
+    DAV_PROPID_getlastmodified,
+    DAV_PROPID_lockdiscovery,
+    DAV_PROPID_resourcetype,
+    DAV_PROPID_source,
+    DAV_PROPID_supportedlock,
+
+    /* DeltaV properties (from the I-D (#14)) */
+    DAV_PROPID_activity_checkout_set,
+    DAV_PROPID_activity_set,
+    DAV_PROPID_activity_version_set,
+    DAV_PROPID_auto_merge_set,
+    DAV_PROPID_auto_version,
+    DAV_PROPID_baseline_collection,
+    DAV_PROPID_baseline_controlled_collection,
+    DAV_PROPID_baseline_controlled_collection_set,
+    DAV_PROPID_checked_in,
+    DAV_PROPID_checked_out,
+    DAV_PROPID_checkin_fork,
+    DAV_PROPID_checkout_fork,
+    DAV_PROPID_checkout_set,
+    DAV_PROPID_comment,
+    DAV_PROPID_creator_displayname,
+    DAV_PROPID_current_activity_set,
+    DAV_PROPID_current_workspace_set,
+    DAV_PROPID_default_variant,
+    DAV_PROPID_eclipsed_set,
+    DAV_PROPID_label_name_set,
+    DAV_PROPID_merge_set,
+    DAV_PROPID_precursor_set,
+    DAV_PROPID_predecessor_set,
+    DAV_PROPID_root_version,
+    DAV_PROPID_subactivity_set,
+    DAV_PROPID_subbaseline_set,
+    DAV_PROPID_successor_set,
+    DAV_PROPID_supported_method_set,
+    DAV_PROPID_supported_live_property_set,
+    DAV_PROPID_supported_report_set,
+    DAV_PROPID_unreserved,
+    DAV_PROPID_variant_set,
+    DAV_PROPID_version_controlled_binding_set,
+    DAV_PROPID_version_controlled_configuration,
+    DAV_PROPID_version_history,
+    DAV_PROPID_version_name,
+    DAV_PROPID_workspace,
+    DAV_PROPID_workspace_checkout_set,
+
+    DAV_PROPID_END
+};
+
+/*
+** Property Identifier Registration
+**
+** At the moment, mod_dav requires live property providers to ensure that
+** each property returned has a unique value. For now, this is done through
+** central registration (there are no known providers other than the default,
+** so this remains manageable).
+**
+** WARNING: the TEST ranges should never be "shipped".
+*/
+#define DAV_PROPID_CORE         10000   /* ..10099. defined by mod_dav */
+#define DAV_PROPID_FS           10100   /* ..10299.
+                                           mod_dav filesystem provider. */
+#define DAV_PROPID_TEST1        10300   /* ..10399 */
+#define DAV_PROPID_TEST2        10400   /* ..10499 */
+#define DAV_PROPID_TEST3        10500   /* ..10599 */
+/* Next: 10600 */
+
+
+/* --------------------------------------------------------------------
+**
+** DATABASE FUNCTIONS
+*/
+
+typedef struct dav_db dav_db;
+typedef struct dav_namespace_map dav_namespace_map;
+typedef struct dav_deadprop_rollback dav_deadprop_rollback;
+
+typedef struct {
+    const char *ns;     /* "" signals "no namespace" */
+    const char *name;
+} dav_prop_name;
+
+/* hook functions to enable pluggable databases */
+struct dav_hooks_propdb
+{
+    dav_error * (*open)(apr_pool_t *p, const dav_resource *resource, int ro,
+                        dav_db **pdb);
+    void (*close)(dav_db *db);
+
+    /*
+    ** In bulk, define any namespaces that the values and their name
+    ** elements may need.
+    **
+    ** Note: sometimes mod_dav will defer calling this until output_value
+    ** returns found==1. If the output process needs the dav_xmlns_info
+    ** filled for its work, then it will need to fill it on demand rather
+    ** than depending upon this hook to fill in the structure.
+    **
+    ** Note: this will *always* be called during an output sequence. Thus,
+    ** the provider may rely solely on using this to fill the xmlns info.
+    */
+    dav_error * (*define_namespaces)(dav_db *db, dav_xmlns_info *xi);
+
+    /*
+    ** Output the value from the database (i.e. add an element name and
+    ** the value into *phdr). Set *found based on whether the name/value
+    ** was found in the propdb.
+    **
+    ** Note: it is NOT an error for the key/value pair to not exist.
+    **
+    ** The dav_xmlns_info passed to define_namespaces() is also passed to
+    ** each output_value() call so that namespaces can be added on-demand.
+    ** It can also be used to look up prefixes or URIs during the output
+    ** process.
+    */
+    dav_error * (*output_value)(dav_db *db, const dav_prop_name *name,
+                                dav_xmlns_info *xi,
+                                apr_text_header *phdr, int *found);
+
+    /*
+    ** Build a mapping from "global" namespaces (stored in apr_xml_*)
+    ** into provider-local namespace identifiers.
+    **
+    ** This mapping should be done once per set of namespaces, and the
+    ** resulting mapping should be passed into the store() hook function.
+    **
+    ** Note: usually, there is just a single document/namespaces for all
+    ** elements passed. However, the generality of creating multiple
+    ** mappings and passing them to store() is provided here.
+    **
+    ** Note: this is only in preparation for a series of store() calls.
+    ** As a result, the propdb must be open for read/write access when
+    ** this function is called.
+    */
+    dav_error * (*map_namespaces)(dav_db *db,
+                                  const apr_array_header_t *namespaces,
+                                  dav_namespace_map **mapping);
+
+    /*
+    ** Store a property value for a given name. The value->combined field
+    ** MUST be set for this call.
+    **
+    ** ### WARNING: current providers will quote the text within ELEM.
+    ** ### this implies you can call this function only once with a given
+    ** ### element structure (a second time will quote it again).
+    */
+    dav_error * (*store)(dav_db *db, const dav_prop_name *name,
+                         const apr_xml_elem *elem,
+                         dav_namespace_map *mapping);
+
+    /* remove a given property */
+    dav_error * (*remove)(dav_db *db, const dav_prop_name *name);
+
+    /* returns 1 if the record specified by "key" exists; 0 otherwise */
+    int (*exists)(dav_db *db, const dav_prop_name *name);
+
+    /*
+    ** Iterate over the property names in the database.
+    **
+    ** iter->name.ns == iter->name.name == NULL when there are no more names.
+    **
+    ** Note: only one iteration may occur over the propdb at a time.
+    */
+    dav_error * (*first_name)(dav_db *db, dav_prop_name *pname);
+    dav_error * (*next_name)(dav_db *db, dav_prop_name *pname);
+
+    /*
+    ** Rollback support: get rollback context, and apply it.
+    **
+    ** struct dav_deadprop_rollback is a provider-private structure; it
+    ** should remember the name, and the name's old value (or the fact that
+    ** the value was not present, and should be deleted if a rollback occurs).
+    */
+    dav_error * (*get_rollback)(dav_db *db, const dav_prop_name *name,
+                                dav_deadprop_rollback **prollback);
+    dav_error * (*apply_rollback)(dav_db *db,
+                                  dav_deadprop_rollback *rollback);
+
+    /*
+    ** If a provider needs a context to associate with this hooks structure,
+    ** then this field may be used. In most cases, it will just be NULL.
+    */
+    void *ctx;
+};
+
+
+/* --------------------------------------------------------------------
+**
+** LOCK FUNCTIONS
+*/
+
+/* Used to represent a Timeout header of "Infinity" */
+#define DAV_TIMEOUT_INFINITE 0
+
+DAV_DECLARE(time_t) dav_get_timeout(request_rec *r);
+
+/*
+** Opaque, provider-specific information for a lock database.
+*/
+typedef struct dav_lockdb_private dav_lockdb_private;
+
+/*
+** Opaque, provider-specific information for a lock record.
+*/
+typedef struct dav_lock_private dav_lock_private;
+
+/*
+** Lock database type. Lock providers are urged to implement a "lazy" open, so
+** doing an "open" is cheap until something is actually needed from the DB.
+*/
+typedef struct
+{
+    const dav_hooks_locks *hooks;   /* the hooks used for this lockdb */
+    int ro;                         /* was it opened readonly? */
+
+    dav_lockdb_private *info;
+
+} dav_lockdb;
+
+typedef enum {
+    DAV_LOCKSCOPE_UNKNOWN,
+    DAV_LOCKSCOPE_EXCLUSIVE,
+    DAV_LOCKSCOPE_SHARED
+} dav_lock_scope;
+
+typedef enum {
+    DAV_LOCKTYPE_UNKNOWN,
+    DAV_LOCKTYPE_WRITE
+} dav_lock_type;
+
+typedef enum {
+    DAV_LOCKREC_DIRECT,             /* lock asserted on this resource */
+    DAV_LOCKREC_INDIRECT,           /* lock inherited from a parent */
+    DAV_LOCKREC_INDIRECT_PARTIAL    /* most info is not filled in */
+} dav_lock_rectype;
+
+/*
+** dav_lock: hold information about a lock on a resource.
+**
+** This structure is used for both direct and indirect locks. A direct lock
+** is a lock applied to a specific resource by the client. An indirect lock
+** is one that is inherited from a parent resource by virtue of a non-zero
+** Depth: header when the lock was applied.
+**
+** mod_dav records both types of locks in the lock database, managing their
+** addition/removal as resources are moved about the namespace.
+**
+** Note that the lockdb is free to marshal this structure in any form that
+** it likes.
+**
+** For a "partial" lock, the <rectype> and <locktoken> fields must be filled
+** in. All other (user) fields should be zeroed. The lock provider will
+** usually fill in the <info> field, and the <next> field may be used to
+** construct a list of partial locks.
+**
+** The lock provider MUST use the info field to store a value such that a
+** dav_lock structure can locate itself in the underlying lock database.
+** This requirement is needed for refreshing: when an indirect dav_lock is
+** refreshed, its reference to the direct lock does not specify the direct's
+** resource, so the only way to locate the (refreshed, direct) lock in the
+** database is to use the info field.
+**
+** Note that <is_locknull> only refers to the resource where this lock was
+** found.
+** ### hrm. that says the abstraction is wrong. is_locknull may disappear.
+*/
+typedef struct dav_lock
+{
+    dav_lock_rectype rectype;   /* type of lock record */
+    int is_locknull;            /* lock establishes a locknull resource */
+
+    /* ### put the resource in here? */
+
+    dav_lock_scope scope;       /* scope of the lock */
+    dav_lock_type type;         /* type of lock */
+    int depth;                  /* depth of the lock */
+    time_t timeout;             /* when the lock will timeout */
+
+    const dav_locktoken *locktoken;  /* the token that was issued */
+
+    const char *owner;          /* (XML) owner of the lock */
+    const char *auth_user;      /* auth'd username owning lock */
+
+    dav_lock_private *info;     /* private to the lockdb */
+
+    struct dav_lock *next;      /* for managing a list of locks */
+} dav_lock;
+
+/* Property-related public lock functions */
+DAV_DECLARE(const char *)dav_lock_get_activelock(request_rec *r,
+                                                 dav_lock *locks,
+                                                 dav_buffer *pbuf);
+
+/* LockDB-related public lock functions */
+DAV_DECLARE(dav_error *) dav_lock_parse_lockinfo(request_rec *r,
+                                                 const dav_resource *resrouce,
+                                                 dav_lockdb *lockdb,
+                                                 const apr_xml_doc *doc,
+                                                 dav_lock **lock_request);
+DAV_DECLARE(int) dav_unlock(request_rec *r,
+                            const dav_resource *resource,
+                            const dav_locktoken *locktoken);
+DAV_DECLARE(dav_error *) dav_add_lock(request_rec *r,
+                                      const dav_resource *resource,
+                                      dav_lockdb *lockdb, dav_lock *request,
+                                      dav_response **response);
+DAV_DECLARE(dav_error *) dav_notify_created(request_rec *r,
+                                            dav_lockdb *lockdb,
+                                            const dav_resource *resource,
+                                            int resource_state,
+                                            int depth);
+
+DAV_DECLARE(dav_error*) dav_lock_query(dav_lockdb *lockdb,
+                                       const dav_resource *resource,
+                                       dav_lock **locks);
+
+DAV_DECLARE(dav_error *) dav_validate_request(request_rec *r,
+                                              dav_resource *resource,
+                                              int depth,
+                                              dav_locktoken *locktoken,
+                                              dav_response **response,
+                                              int flags,
+                                              dav_lockdb *lockdb);
+/*
+** flags:
+**    0x0F -- reserved for <dav_lock_scope> values
+**
+**    other flags, detailed below
+*/
+#define DAV_VALIDATE_RESOURCE   0x0010  /* validate just the resource */
+#define DAV_VALIDATE_PARENT     0x0020  /* validate resource AND its parent */
+#define DAV_VALIDATE_ADD_LD     0x0040  /* add DAV:lockdiscovery into
+                                           the 424 DAV:response */
+#define DAV_VALIDATE_USE_424    0x0080  /* return 424 status, not 207 */
+#define DAV_VALIDATE_IS_PARENT  0x0100  /* for internal use */
+#define DAV_VALIDATE_NO_MODIFY  0x0200  /* resource is not being modified
+                                           so allow even if lock token
+                                           is not provided */
+
+/* Lock-null related public lock functions */
+DAV_DECLARE(int) dav_get_resource_state(request_rec *r,
+                                        const dav_resource *resource);
+
+/* Lock provider hooks. Locking is optional, so there may be no
+ * lock provider for a given repository.
+ */
+struct dav_hooks_locks
+{
+    /* Return the supportedlock property for a resource */
+    const char * (*get_supportedlock)(
+        const dav_resource *resource
+    );
+
+    /* Parse a lock token URI, returning a lock token object allocated
+     * in the given pool.
+     */
+    dav_error * (*parse_locktoken)(
+        apr_pool_t *p,
+        const char *char_token,
+        dav_locktoken **locktoken_p
+    );
+
+    /* Format a lock token object into a URI string, allocated in
+     * the given pool.
+     *
+     * Always returns non-NULL.
+     */
+    const char * (*format_locktoken)(
+        apr_pool_t *p,
+        const dav_locktoken *locktoken
+    );
+
+    /* Compare two lock tokens.
+     *
+     * Result < 0  => lt1 < lt2
+     * Result == 0 => lt1 == lt2
+     * Result > 0  => lt1 > lt2
+     */
+    int (*compare_locktoken)(
+        const dav_locktoken *lt1,
+        const dav_locktoken *lt2
+    );
+
+    /* Open the provider's lock database.
+     *
+     * The provider may or may not use a "real" database for locks
+     * (a lock could be an attribute on a resource, for example).
+     *
+     * The provider may choose to use the value of the DAVLockDB directive
+     * (as returned by dav_get_lockdb_path()) to decide where to place
+     * any storage it may need.
+     *
+     * The request storage pool should be associated with the lockdb,
+     * so it can be used in subsequent operations.
+     *
+     * If ro != 0, only readonly operations will be performed.
+     * If force == 0, the open can be "lazy"; no subsequent locking operations
+     * may occur.
+     * If force != 0, locking operations will definitely occur.
+     */
+    dav_error * (*open_lockdb)(
+        request_rec *r,
+        int ro,
+        int force,
+        dav_lockdb **lockdb
+    );
+
+    /* Indicates completion of locking operations */
+    void (*close_lockdb)(
+        dav_lockdb *lockdb
+    );
+
+    /* Take a resource out of the lock-null state. */
+    dav_error * (*remove_locknull_state)(
+        dav_lockdb *lockdb,
+        const dav_resource *resource
+    );
+
+    /*
+    ** Create a (direct) lock structure for the given resource. A locktoken
+    ** will be created.
+    **
+    ** The lock provider may store private information into lock->info.
+    */
+    dav_error * (*create_lock)(dav_lockdb *lockdb,
+                               const dav_resource *resource,
+                               dav_lock **lock);
+
+    /*
+    ** Get the locks associated with the specified resource.
+    **
+    ** If resolve_locks is true (non-zero), then any indirect locks are
+    ** resolved to their actual, direct lock (i.e. the reference to followed
+    ** to the original lock).
+    **
+    ** The locks, if any, are returned as a linked list in no particular
+    ** order. If no locks are present, then *locks will be NULL.
+    */
+    dav_error * (*get_locks)(dav_lockdb *lockdb,
+                             const dav_resource *resource,
+                             int calltype,
+                             dav_lock **locks);
+
+#define DAV_GETLOCKS_RESOLVED   0    /* resolve indirects to directs */
+#define DAV_GETLOCKS_PARTIAL    1    /* leave indirects partially filled */
+#define DAV_GETLOCKS_COMPLETE   2    /* fill out indirect locks */
+
+    /*
+    ** Find a particular lock on a resource (specified by its locktoken).
+    **
+    ** *lock will be set to NULL if the lock is not found.
+    **
+    ** Note that the provider can optimize the unmarshalling -- only one
+    ** lock (or none) must be constructed and returned.
+    **
+    ** If partial_ok is true (non-zero), then an indirect lock can be
+    ** partially filled in. Otherwise, another lookup is done and the
+    ** lock structure will be filled out as a DAV_LOCKREC_INDIRECT.
+    */
+    dav_error * (*find_lock)(dav_lockdb *lockdb,
+                             const dav_resource *resource,
+                             const dav_locktoken *locktoken,
+                             int partial_ok,
+                             dav_lock **lock);
+
+    /*
+    ** Quick test to see if the resource has *any* locks on it.
+    **
+    ** This is typically used to determine if a non-existent resource
+    ** has a lock and is (therefore) a locknull resource.
+    **
+    ** WARNING: this function may return TRUE even when timed-out locks
+    **          exist (i.e. it may not perform timeout checks).
+    */
+    dav_error * (*has_locks)(dav_lockdb *lockdb,
+                             const dav_resource *resource,
+                             int *locks_present);
+
+    /*
+    ** Append the specified lock(s) to the set of locks on this resource.
+    **
+    ** If "make_indirect" is true (non-zero), then the specified lock(s)
+    ** should be converted to an indirect lock (if it is a direct lock)
+    ** before appending. Note that the conversion to an indirect lock does
+    ** not alter the passed-in lock -- the change is internal the
+    ** append_locks function.
+    **
+    ** Multiple locks are specified using the lock->next links.
+    */
+    dav_error * (*append_locks)(dav_lockdb *lockdb,
+                                const dav_resource *resource,
+                                int make_indirect,
+                                const dav_lock *lock);
+
+    /*
+    ** Remove any lock that has the specified locktoken.
+    **
+    ** If locktoken == NULL, then ALL locks are removed.
+    */
+    dav_error * (*remove_lock)(dav_lockdb *lockdb,
+                               const dav_resource *resource,
+                               const dav_locktoken *locktoken);
+
+    /*
+    ** Refresh all locks, found on the specified resource, which has a
+    ** locktoken in the provided list.
+    **
+    ** If the lock is indirect, then the direct lock is referenced and
+    ** refreshed.
+    **
+    ** Each lock that is updated is returned in the <locks> argument.
+    ** Note that the locks will be fully resolved.
+    */
+    dav_error * (*refresh_locks)(dav_lockdb *lockdb,
+                                 const dav_resource *resource,
+                                 const dav_locktoken_list *ltl,
+                                 time_t new_time,
+                                 dav_lock **locks);
+
+    /*
+    ** Look up the resource associated with a particular locktoken.
+    **
+    ** The search begins at the specified <start_resource> and the lock
+    ** specified by <locktoken>.
+    **
+    ** If the resource/token specifies an indirect lock, then the direct
+    ** lock will be looked up, and THAT resource will be returned. In other
+    ** words, this function always returns the resource where a particular
+    ** lock (token) was asserted.
+    **
+    ** NOTE: this function pointer is allowed to be NULL, indicating that
+    **       the provider does not support this type of functionality. The
+    **       caller should then traverse up the repository hierarchy looking
+    **       for the resource defining a lock with this locktoken.
+    */
+    dav_error * (*lookup_resource)(dav_lockdb *lockdb,
+                                   const dav_locktoken *locktoken,
+                                   const dav_resource *start_resource,
+                                   const dav_resource **resource);
+
+    /*
+    ** If a provider needs a context to associate with this hooks structure,
+    ** then this field may be used. In most cases, it will just be NULL.
+    */
+    void *ctx;
+};
+
+/* what types of resources can be discovered by dav_get_resource_state() */
+#define DAV_RESOURCE_LOCK_NULL  10    /* resource lock-null */
+#define DAV_RESOURCE_NULL       11    /* resource null */
+#define DAV_RESOURCE_EXISTS     12    /* resource exists */
+#define DAV_RESOURCE_ERROR      13    /* an error occurred */
+
+
+/* --------------------------------------------------------------------
+**
+** PROPERTY HANDLING
+*/
+
+typedef struct dav_propdb dav_propdb;
+
+
+DAV_DECLARE(dav_error *) dav_open_propdb(
+    request_rec *r,
+    dav_lockdb *lockdb,
+    const dav_resource *resource,
+    int ro,
+    apr_array_header_t *ns_xlate,
+    dav_propdb **propdb);
+
+DAV_DECLARE(void) dav_close_propdb(dav_propdb *db);
+
+DAV_DECLARE(dav_get_props_result) dav_get_props(
+    dav_propdb *db,
+    apr_xml_doc *doc);
+
+DAV_DECLARE(dav_get_props_result) dav_get_allprops(
+    dav_propdb *db,
+    dav_prop_insert what);
+
+DAV_DECLARE(void) dav_get_liveprop_supported(
+    dav_propdb *propdb,
+    const char *ns_uri,
+    const char *propname,
+    apr_text_header *body);
+
+/*
+** 3-phase property modification.
+**
+**   1) validate props. readable? unlocked? ACLs allow access?
+**   2) execute operation (set/delete)
+**   3) commit or rollback
+**
+** ### eventually, auth must be available. a ref to the request_rec (which
+** ### contains the auth info) should be in the shared context struct.
+**
+** Each function may alter the error values and information contained within
+** the context record. This should be done as an "increasing" level of
+** error, rather than overwriting any previous error.
+**
+** Note that commit() cannot generate errors. It should simply free the
+** rollback information.
+**
+** rollback() may generate additional errors because the rollback operation
+** can sometimes fail(!).
+**
+** The caller should allocate an array of these, one per operation. It should
+** be zero-initialized, then the db, operation, and prop fields should be
+** filled in before calling dav_prop_validate. Note that the set/delete
+** operations are order-dependent. For a given (logical) context, the same
+** pointer must be passed to each phase.
+**
+** error_type is an internal value, but will have the same numeric value
+** for each possible "desc" value. This allows the caller to group the
+** descriptions via the error_type variable, rather than through string
+** comparisons. Note that "status" does not provide enough granularity to
+** differentiate/group the "desc" values.
+**
+** Note that the propdb will maintain some (global) context across all
+** of the property change contexts. This implies that you can have only
+** one open transaction per propdb.
+*/
+typedef struct dav_prop_ctx
+{
+    dav_propdb *propdb;
+
+    apr_xml_elem *prop;             /* property to affect */
+
+    int operation;
+#define DAV_PROP_OP_SET        1    /* set a property value */
+#define DAV_PROP_OP_DELETE     2    /* delete a prop value */
+/* ### add a GET? */
+
+    /* private items to the propdb */
+    int is_liveprop;
+    void *liveprop_ctx;
+    struct dav_rollback_item *rollback;  /* optional rollback info */
+
+    dav_error *err;                 /* error (if any) */
+
+    /* private to mod_dav.c */
+    request_rec *r;
+
+} dav_prop_ctx;
+
+DAV_DECLARE_NONSTD(void) dav_prop_validate(dav_prop_ctx *ctx);
+DAV_DECLARE_NONSTD(void) dav_prop_exec(dav_prop_ctx *ctx);
+DAV_DECLARE_NONSTD(void) dav_prop_commit(dav_prop_ctx *ctx);
+DAV_DECLARE_NONSTD(void) dav_prop_rollback(dav_prop_ctx *ctx);
+
+#define DAV_PROP_CTX_HAS_ERR(dpc)  ((dpc).err && (dpc).err->status >= 300)
+
+
+/* --------------------------------------------------------------------
+**
+** WALKER STRUCTURE
+*/
+
+enum {
+    DAV_CALLTYPE_MEMBER = 1,    /* called for a member resource */
+    DAV_CALLTYPE_COLLECTION,    /* called for a collection */
+    DAV_CALLTYPE_LOCKNULL       /* called for a locknull resource */
+};
+
+typedef struct
+{
+    /* the client-provided context */
+    void *walk_ctx;
+
+    /* pool to use for allocations in the callback */
+    apr_pool_t *pool;
+
+    /* the current resource */
+    const dav_resource *resource;
+
+    /* OUTPUT: add responses to this */
+    dav_response *response;
+
+} dav_walk_resource;
+
+typedef struct
+{
+    int walk_type;
+#define DAV_WALKTYPE_AUTH       0x0001  /* limit to authorized files */
+#define DAV_WALKTYPE_NORMAL     0x0002  /* walk normal files */
+#define DAV_WALKTYPE_LOCKNULL   0x0004  /* walk locknull resources */
+
+    /* callback function and a client context for the walk */
+    dav_error * (*func)(dav_walk_resource *wres, int calltype);
+    void *walk_ctx;
+
+    /* what pool to use for allocations needed by walk logic */
+    apr_pool_t *pool;
+
+    /* beginning root of the walk */
+    const dav_resource *root;
+
+    /* lock database to enable walking LOCKNULL resources */
+    dav_lockdb *lockdb;
+
+} dav_walk_params;
+
+/* directory tree walking context */
+typedef struct dav_walker_ctx
+{
+    /* input: */
+    dav_walk_params w;
+
+
+    /* ### client data... phasing out this big glom */
+
+    /* this brigade buffers data being sent to r->output_filters */
+    apr_bucket_brigade *bb;
+
+    /* a scratch pool, used to stream responses and iteratively cleared. */
+    apr_pool_t *scratchpool;
+
+    request_rec *r;                 /* original request */
+
+    /* for PROPFIND operations */
+    apr_xml_doc *doc;
+    int propfind_type;
+#define DAV_PROPFIND_IS_ALLPROP     1
+#define DAV_PROPFIND_IS_PROPNAME    2
+#define DAV_PROPFIND_IS_PROP        3
+
+    apr_text *propstat_404;         /* (cached) propstat giving a 404 error */
+
+    const dav_if_header *if_header; /* for validation */
+    const dav_locktoken *locktoken; /* for UNLOCK */
+    const dav_lock *lock;           /* for LOCK */
+    int skip_root;                  /* for dav_inherit_locks() */
+
+    int flags;
+
+    dav_buffer work_buf;            /* for dav_validate_request() */
+
+} dav_walker_ctx;
+
+DAV_DECLARE(void) dav_add_response(dav_walk_resource *wres,
+                                   int status,
+                                   dav_get_props_result *propstats);
+
+
+/* --------------------------------------------------------------------
+**
+** "STREAM" STRUCTURE
+**
+** mod_dav uses this abstraction for interacting with the repository
+** while fetching/storing resources. mod_dav views resources as a stream
+** of bytes.
+**
+** Note that the structure is opaque -- it is private to the repository
+** that created the stream in the repository's "open" function.
+**
+** ### THIS STUFF IS GOING AWAY ... GET/read requests are handled by
+** ### having the provider jam stuff straight into the filter stack.
+** ### this is only left for handling PUT/write requests.
+*/
+
+typedef struct dav_stream dav_stream;
+
+typedef enum {
+    DAV_MODE_WRITE_TRUNC,      /* truncate and open for writing */
+    DAV_MODE_WRITE_SEEKABLE    /* open for writing; random access */
+} dav_stream_mode;
+
+
+/* --------------------------------------------------------------------
+**
+** REPOSITORY FUNCTIONS
+*/
+
+/* Repository provider hooks */
+struct dav_hooks_repository
+{
+    /* Flag for whether repository requires special GET handling.
+     * If resources in the repository are not visible in the
+     * filesystem location which URLs map to, then special handling
+     * is required to first fetch a resource from the repository,
+     * respond to the GET request, then free the resource copy.
+     */
+    int handle_get;
+
+    /* Get a resource descriptor for the URI in a request. A descriptor
+     * should always be returned even if the resource does not exist. This
+     * repository has been identified as handling the resource given by
+     * the URI, so an answer must be given. If there is a problem with the
+     * URI or accessing the resource or whatever, then an error should be
+     * returned.
+     *
+     * root_dir:
+     *   the root of the directory for which this repository is configured.
+     *
+     * label:
+     *   if a Label: header is present (and allowed), this is the label
+     *   to use to identify a version resource from the resource's
+     *   corresponding version history. Otherwise, it will be NULL.
+     *
+     * use_checked_in:
+     *   use the DAV:checked-in property of the resource identified by the
+     *   Request-URI to identify and return a version resource
+     *
+     * The provider may associate the request storage pool with the resource
+     * (in the resource->pool field), to use in other operations on that
+     * resource.
+     */
+    dav_error * (*get_resource)(
+        request_rec *r,
+        const char *root_dir,
+        const char *label,
+        int use_checked_in,
+        dav_resource **resource
+    );
+
+    /* Get a resource descriptor for the parent of the given resource.
+     * The resources need not exist.  NULL is returned if the resource
+     * is the root collection.
+     *
+     * An error should be returned only if there is a fatal error in
+     * fetching information about the parent resource.
+     */
+    dav_error * (*get_parent_resource)(
+        const dav_resource *resource,
+        dav_resource **parent_resource
+    );
+
+    /* Determine whether two resource descriptors refer to the same resource.
+    *
+     * Result != 0 => the resources are the same.
+     */
+    int (*is_same_resource)(
+        const dav_resource *res1,
+        const dav_resource *res2
+    );
+
+    /* Determine whether one resource is a parent (immediate or otherwise)
+     * of another.
+     *
+     * Result != 0 => res1 is a parent of res2.
+     */
+    int (*is_parent_resource)(
+        const dav_resource *res1,
+        const dav_resource *res2
+    );
+
+    /*
+    ** Open a stream for this resource, using the specified mode. The
+    ** stream will be returned in *stream.
+    */
+    dav_error * (*open_stream)(const dav_resource *resource,
+                               dav_stream_mode mode,
+                               dav_stream **stream);
+
+    /*
+    ** Close the specified stream.
+    **
+    ** mod_dav will (ideally) make sure to call this. For safety purposes,
+    ** a provider should (ideally) register a cleanup function with the
+    ** request pool to get this closed and cleaned up.
+    **
+    ** Note the possibility of an error from the close -- it is entirely
+    ** feasible that the close does a "commit" of some kind, which can
+    ** produce an error.
+    **
+    ** commit should be TRUE (non-zero) or FALSE (0) if the stream was
+    ** opened for writing. This flag states whether to retain the file
+    ** or not.
+    ** Note: the commit flag is ignored for streams opened for reading.
+    */
+    dav_error * (*close_stream)(dav_stream *stream, int commit);
+
+    /*
+    ** Write data to the stream.
+    **
+    ** All of the bytes must be written, or an error should be returned.
+    */
+    dav_error * (*write_stream)(dav_stream *stream,
+                                const void *buf, apr_size_t bufsize);
+
+    /*
+    ** Seek to an absolute position in the stream. This is used to support
+    ** Content-Range in a GET/PUT.
+    **
+    ** NOTE: if this function is NULL (which is allowed), then any
+    **       operations using Content-Range will be refused.
+    */
+    dav_error * (*seek_stream)(dav_stream *stream, apr_off_t abs_position);
+
+    /*
+    ** If a GET is processed using a stream (open_stream, read_stream)
+    ** rather than via a sub-request (on get_pathname), then this function
+    ** is used to provide the repository with a way to set the headers
+    ** in the response.
+    **
+    ** This function may be called without a following deliver(), to
+    ** handle a HEAD request.
+    **
+    ** This may be NULL if handle_get is FALSE.
+    */
+    dav_error * (*set_headers)(request_rec *r,
+                               const dav_resource *resource);
+
+    /*
+    ** The provider should deliver the resource into the specified filter.
+    ** Basically, this is the response to the GET method.
+    **
+    ** Note that this is called for all resources, including collections.
+    ** The provider should determine what has content to deliver or not.
+    **
+    ** set_headers will be called prior to this function, allowing the
+    ** provider to set the appropriate response headers.
+    **
+    ** This may be NULL if handle_get is FALSE.
+    ** ### maybe toss handle_get and just use this function as the marker
+    */
+    dav_error * (*deliver)(const dav_resource *resource,
+                           ap_filter_t *output);
+
+    /* Create a collection resource. The resource must not already exist.
+     *
+     * Result == NULL if the collection was created successfully. Also, the
+     * resource object is updated to reflect that the resource exists, and
+     * is a collection.
+     */
+    dav_error * (*create_collection)(
+        dav_resource *resource
+    );
+
+    /* Copy one resource to another. The destination may exist, if it is
+     * versioned.
+     * Handles both files and collections. Properties are copied as well.
+     * If the destination exists and is versioned, the provider must update
+     * the destination to have identical content to the source,
+     * recursively for collections.
+     * The depth argument is ignored for a file, and can be either 0 or
+     * DAV_INFINITY for a collection.
+     * If an error occurs in a child resource, then the return value is
+     * non-NULL, and *response is set to a multistatus response.
+     * If the copy is successful, the dst resource object is
+     * updated to reflect that the resource exists.
+     */
+    dav_error * (*copy_resource)(
+        const dav_resource *src,
+        dav_resource *dst,
+        int depth,
+        dav_response **response
+    );
+
+    /* Move one resource to another. The destination must not exist.
+     * Handles both files and collections. Properties are moved as well.
+     * If an error occurs in a child resource, then the return value is
+     * non-NULL, and *response is set to a multistatus response.
+     * If the move is successful, the src and dst resource objects are
+     * updated to reflect that the source no longer exists, and the
+     * destination does.
+     */
+    dav_error * (*move_resource)(
+        dav_resource *src,
+        dav_resource *dst,
+        dav_response **response
+    );
+
+    /* Remove a resource. Handles both files and collections.
+     * Removes any associated properties as well.
+     * If an error occurs in a child resource, then the return value is
+     * non-NULL, and *response is set to a multistatus response.
+     * If the delete is successful, the resource object is updated to
+     * reflect that the resource no longer exists.
+     */
+    dav_error * (*remove_resource)(
+        dav_resource *resource,
+        dav_response **response
+    );
+
+    /* Walk a resource hierarchy.
+     *
+     * Iterates over the resource hierarchy specified by params->root.
+     * Control of the walk and the callback are specified by 'params'.
+     *
+     * An error may be returned. *response will contain multistatus
+     * responses (if any) suitable for the body of the error. It is also
+     * possible to return NULL, yet still have multistatus responses.
+     * In this case, typically the caller should return a 207 (Multistatus)
+     * and the responses (in the body) as the HTTP response.
+     */
+    dav_error * (*walk)(const dav_walk_params *params, int depth,
+                        dav_response **response);
+
+    /* Get the entity tag for a resource */
+    const char * (*getetag)(const dav_resource *resource);
+
+    /*
+    ** If a provider needs a context to associate with this hooks structure,
+    ** then this field may be used. In most cases, it will just be NULL.
+    */
+    void *ctx;
+
+    /* Get the request rec for a resource */
+    request_rec * (*get_request_rec)(const dav_resource *resource);
+
+    /* Get the pathname for a resource */
+    const char * (*get_pathname)(const dav_resource *resource);
+};
+
+
+/* --------------------------------------------------------------------
+**
+** VERSIONING FUNCTIONS
+*/
+
+
+/* dav_add_vary_header
+ *
+ * If there were any headers in the request which require a Vary header
+ * in the response, add it.
+ */
+DAV_DECLARE(void) dav_add_vary_header(request_rec *in_req,
+                                      request_rec *out_req,
+                                      const dav_resource *resource);
+
+/*
+** Flags specifying auto-versioning behavior, returned by
+** the auto_versionable hook. The value returned depends
+** on both the state of the resource and the value of the
+** DAV:auto-versioning property for the resource.
+**
+** If the resource does not exist (null or lock-null),
+** DAV_AUTO_VERSION_ALWAYS causes creation of a new version-controlled resource
+**
+** If the resource is checked in,
+** DAV_AUTO_VERSION_ALWAYS causes it to be checked out always,
+** DAV_AUTO_VERSION_LOCKED causes it to be checked out only when locked
+**
+** If the resource is checked out,
+** DAV_AUTO_VERSION_ALWAYS causes it to be checked in always,
+** DAV_AUTO_VERSION_LOCKED causes it to be checked in when unlocked
+** (note: a provider should allow auto-checkin only for resources which
+** were automatically checked out)
+**
+** In all cases, DAV_AUTO_VERSION_NEVER results in no auto-versioning behavior.
+*/
+typedef enum {
+    DAV_AUTO_VERSION_NEVER,
+    DAV_AUTO_VERSION_ALWAYS,
+    DAV_AUTO_VERSION_LOCKED
+} dav_auto_version;
+
+/*
+** This structure is used to record what auto-versioning operations
+** were done to make a resource writable, so that they can be undone
+** at the end of a request.
+*/
+typedef struct {
+    int resource_versioned;             /* 1 => resource was auto-version-controlled */
+    int resource_checkedout;            /* 1 => resource was auto-checked-out */
+    int parent_checkedout;              /* 1 => parent was auto-checked-out */
+    dav_resource *parent_resource;      /* parent resource, if it was needed */
+} dav_auto_version_info;
+
+/* Ensure that a resource is writable. If there is no versioning
+ * provider, then this is essentially a no-op. Versioning repositories
+ * require explicit resource creation and checkout before they can
+ * be written to. If a new resource is to be created, or an existing
+ * resource deleted, the parent collection must be checked out as well.
+ *
+ * Set the parent_only flag to only make the parent collection writable.
+ * Otherwise, both parent and child are made writable as needed. If the
+ * child does not exist, then a new versioned resource is created and
+ * checked out.
+ *
+ * If auto-versioning is not enabled for a versioned resource, then an error is
+ * returned, since the resource cannot be modified.
+ *
+ * The dav_auto_version_info structure is filled in with enough information
+ * to restore both parent and child resources to the state they were in
+ * before the auto-versioning operations occurred.
+ */
+DAV_DECLARE(dav_error *) dav_auto_checkout(
+    request_rec *r,
+    dav_resource *resource,
+    int parent_only,
+    dav_auto_version_info *av_info);
+
+/* Revert the writability of resources back to what they were
+ * before they were modified. If undo == 0, then the resource
+ * modifications are maintained (i.e. they are checked in).
+ * If undo != 0, then resource modifications are discarded
+ * (i.e. they are unchecked out).
+ *
+ * Set the unlock flag to indicate that the resource is about
+ * to be unlocked; it will be checked in if the resource
+ * auto-versioning property indicates it should be. In this case,
+ * av_info is ignored, so it can be NULL.
+ *
+ * The resource argument may be NULL if only the parent resource
+ * was checked out (i.e. the parent_only was != 0 in the
+ * dav_auto_checkout call).
+ */
+DAV_DECLARE(dav_error *) dav_auto_checkin(
+    request_rec *r,
+    dav_resource *resource,
+    int undo,
+    int unlock,
+    dav_auto_version_info *av_info);
+
+/*
+** This structure is used to describe available reports
+**
+** "nmspace" should be valid XML and URL-quoted. mod_dav will place
+** double-quotes around it and use it in an xmlns declaration.
+*/
+typedef struct {
+    const char *nmspace;        /* namespace of the XML report element */
+    const char *name;           /* element name for the XML report */
+} dav_report_elem;
+
+
+/* Versioning provider hooks */
+struct dav_hooks_vsn
+{
+    /*
+    ** MANDATORY HOOKS
+    ** The following hooks are mandatory for all versioning providers;
+    ** they define the functionality needed to implement "core" versioning.
+    */
+
+    /* Return supported versioning options.
+     * Each dav_text item in the list will be returned as a separate
+     * DAV header. Providers are advised to limit the length of an
+     * individual text item to 63 characters, to conform to the limit
+     * used by MS Web Folders.
+     */
+    void (*get_vsn_options)(apr_pool_t *p, apr_text_header *phdr);
+
+    /* Get the value of a specific option for an OPTIONS request.
+     * The option being requested is given by the parsed XML
+     * element object "elem". The value of the option should be
+     * appended to the "option" text object.
+     */
+    dav_error * (*get_option)(const dav_resource *resource,
+                              const apr_xml_elem *elem,
+                              apr_text_header *option);
+
+    /* Determine whether a non-versioned (or non-existent) resource
+     * is versionable. Returns != 0 if resource can be versioned.
+     */
+    int (*versionable)(const dav_resource *resource);
+
+    /* Determine whether auto-versioning is enabled for a resource
+     * (which may not exist, or may not be versioned). If the resource
+     * is a checked-out resource, the provider must only enable
+     * auto-checkin if the resource was automatically checked out.
+     *
+     * The value returned depends on both the state of the resource
+     * and the value of its DAV:auto-version property. See the description
+     * of the dav_auto_version enumeration above for the details.
+     */
+    dav_auto_version (*auto_versionable)(const dav_resource *resource);
+
+    /* Put a resource under version control. If the resource already
+     * exists unversioned, then it becomes the initial version of the
+     * new version history, and it is replaced by a version selector
+     * which targets the new version.
+     *
+     * If the resource does not exist, then a new version-controlled
+     * resource is created which either targets an existing version (if the
+     * "target" argument is not NULL), or the initial, empty version
+     * in a new history resource (if the "target" argument is NULL).
+     *
+     * If successful, the resource object state is updated appropriately
+     * (that is, changed to refer to the new version-controlled resource).
+     */
+    dav_error * (*vsn_control)(dav_resource *resource,
+                               const char *target);
+
+    /* Checkout a resource. If successful, the resource
+     * object state is updated appropriately.
+     *
+     * The auto_checkout flag will be set if this checkout is being
+     * done automatically, as part of some method which modifies
+     * the resource. The provider must remember that the resource
+     * was automatically checked out, so it can determine whether it
+     * can be automatically checked in. (Auto-checkin should only be
+     * enabled for resources which were automatically checked out.)
+     *
+     * If the working resource has a different URL from the
+     * target resource, a dav_resource descriptor is returned
+     * for the new working resource. Otherwise, the original
+     * resource descriptor will refer to the working resource.
+     * The working_resource argument can be NULL if the caller
+     * is not interested in the working resource.
+     *
+     * If the client has specified DAV:unreserved or DAV:fork-ok in the
+     * checkout request, then the corresponding flags are set. If
+     * DAV:activity-set has been specified, then create_activity is set
+     * if DAV:new was specified; otherwise, the DAV:href elements' CDATA
+     * (the actual href text) is passed in the "activities" array (each
+     * element of the array is a const char *). activities will be NULL
+     * no DAV:activity-set was provided or when create_activity is set.
+     */
+    dav_error * (*checkout)(dav_resource *resource,
+                            int auto_checkout,
+                            int is_unreserved, int is_fork_ok,
+                            int create_activity,
+                            apr_array_header_t *activities,
+                            dav_resource **working_resource);
+
+    /* Uncheckout a checked-out resource. If successful, the resource
+     * object state is updated appropriately.
+     */
+    dav_error * (*uncheckout)(dav_resource *resource);
+
+    /* Checkin a checked-out resource. If successful, the resource
+     * object state is updated appropriately, and the
+     * version_resource descriptor will refer to the new version.
+     * The version_resource argument can be NULL if the caller
+     * is not interested in the new version resource.
+     *
+     * If the client has specified DAV:keep-checked-out in the checkin
+     * request, then the keep_checked_out flag is set. The provider
+     * should create a new version, but keep the resource in the
+     * checked-out state.
+     */
+    dav_error * (*checkin)(dav_resource *resource,
+                           int keep_checked_out,
+                           dav_resource **version_resource);
+
+    /*
+    ** Return the set of reports available at this resource.
+    **
+    ** An array of report elements should be returned, with an end-marker
+    ** element containing namespace==NULL. The value of the
+    ** DAV:supported-report-set property will be constructed and
+    ** returned.
+    */
+    dav_error * (*avail_reports)(const dav_resource *resource,
+                                 const dav_report_elem **reports);
+
+    /*
+    ** Determine whether a Label header can be used
+    ** with a particular report. The dav_xml_doc structure
+    ** contains the parsed report request body.
+    ** Returns 0 if the Label header is not allowed.
+    */
+    int (*report_label_header_allowed)(const apr_xml_doc *doc);
+
+    /*
+    ** Generate a report on a resource. Since a provider is free
+    ** to define its own reports, and the value of request headers
+    ** may affect the interpretation of a report, the request record
+    ** must be passed to this routine.
+    **
+    ** The dav_xml_doc structure contains the parsed report request
+    ** body. The report response should be generated into the specified
+    ** output filter.
+    **
+    ** If an error occurs, and a response has not yet been generated,
+    ** then an error can be returned from this function. mod_dav will
+    ** construct an appropriate error response. Once some output has
+    ** been placed into the filter, however, the provider should not
+    ** return an error -- there is no way that mod_dav can deliver it
+    ** properly.
+    **
+    ** ### maybe we need a way to signal an error anyways, and then
+    ** ### apache can abort the connection?
+    */
+    dav_error * (*deliver_report)(request_rec *r,
+                                  const dav_resource *resource,
+                                  const apr_xml_doc *doc,
+                                  ap_filter_t *output);
+
+    /*
+    ** OPTIONAL HOOKS
+    ** The following hooks are optional; if not defined, then the
+    ** corresponding protocol methods will be unsupported.
+    */
+
+    /*
+    ** Set the state of a checked-in version-controlled resource.
+    **
+    ** If the request specified a version, the version resource
+    ** represents that version. If the request specified a label,
+    ** then "version" is NULL, and "label" is the label.
+    **
+    ** The depth argument is ignored for a file, and can be 0, 1, or
+    ** DAV_INFINITY for a collection. The depth argument only applies
+    ** with a label, not a version.
+    **
+    ** If an error occurs in a child resource, then the return value is
+    ** non-NULL, and *response is set to a multistatus response.
+    **
+    ** This hook is optional; if not defined, then the UPDATE method
+    ** will not be supported.
+    */
+    dav_error * (*update)(const dav_resource *resource,
+                          const dav_resource *version,
+                          const char *label,
+                          int depth,
+                          dav_response **response);
+
+    /*
+    ** Add a label to a version. The resource is either a specific
+    ** version, or a version selector, in which case the label should
+    ** be added to the current target of the version selector. The
+    ** version selector cannot be checked out.
+    **
+    ** If replace != 0, any existing label by the same name is
+    ** effectively deleted first. Otherwise, it is an error to
+    ** attempt to add a label which already exists on some version
+    ** of the same history resource.
+    **
+    ** This hook is optional; if not defined, then the LABEL method
+    ** will not be supported. If it is defined, then the remove_label
+    ** hook must be defined also.
+    */
+    dav_error * (*add_label)(const dav_resource *resource,
+                             const char *label,
+                             int replace);
+
+    /*
+    ** Remove a label from a version. The resource is either a specific
+    ** version, or a version selector, in which case the label should
+    ** be added to the current target of the version selector. The
+    ** version selector cannot be checked out.
+    **
+    ** It is an error if no such label exists on the specified version.
+    **
+    ** This hook is optional, but if defined, the add_label hook
+    ** must be defined also.
+    */
+    dav_error * (*remove_label)(const dav_resource *resource,
+                                const char *label);
+
+    /*
+    ** Determine whether a null resource can be created as a workspace.
+    ** The provider may restrict workspaces to certain locations.
+    ** Returns 0 if the resource cannot be a workspace.
+    **
+    ** This hook is optional; if the provider does not support workspaces,
+    ** it should be set to NULL.
+    */
+    int (*can_be_workspace)(const dav_resource *resource);
+
+    /*
+    ** Create a workspace resource. The resource must not already
+    ** exist. Any <DAV:mkworkspace> element is passed to the provider
+    ** in the "doc" structure; it may be empty.
+    **
+    ** If workspace creation is successful, the state of the resource
+    ** object is updated appropriately.
+    **
+    ** This hook is optional; if the provider does not support workspaces,
+    ** it should be set to NULL.
+    */
+    dav_error * (*make_workspace)(dav_resource *resource,
+                                  apr_xml_doc *doc);
+
+    /*
+    ** Determine whether a null resource can be created as an activity.
+    ** The provider may restrict activities to certain locations.
+    ** Returns 0 if the resource cannot be an activity.
+    **
+    ** This hook is optional; if the provider does not support activities,
+    ** it should be set to NULL.
+    */
+    int (*can_be_activity)(const dav_resource *resource);
+
+    /*
+    ** Create an activity resource. The resource must not already
+    ** exist.
+    **
+    ** If activity creation is successful, the state of the resource
+    ** object is updated appropriately.
+    **
+    ** This hook is optional; if the provider does not support activities,
+    ** it should be set to NULL.
+    */
+    dav_error * (*make_activity)(dav_resource *resource);
+
+    /*
+    ** Merge a resource (tree) into target resource (tree).
+    **
+    ** ### more doc...
+    **
+    ** This hook is optional; if the provider does not support merging,
+    ** then this should be set to NULL.
+    */
+    dav_error * (*merge)(dav_resource *target, dav_resource *source,
+                         int no_auto_merge, int no_checkout,
+                         apr_xml_elem *prop_elem,
+                         ap_filter_t *output);
+
+    /*
+    ** If a provider needs a context to associate with this hooks structure,
+    ** then this field may be used. In most cases, it will just be NULL.
+    */
+    void *ctx;
+};
+
+
+/* --------------------------------------------------------------------
+**
+** BINDING FUNCTIONS
+*/
+
+/* binding provider hooks */
+struct dav_hooks_binding {
+
+    /* Determine whether a resource can be the target of a binding.
+     * Returns 0 if the resource cannot be a binding target.
+     */
+    int (*is_bindable)(const dav_resource *resource);
+
+    /* Create a binding to a resource.
+     * The resource argument is the target of the binding;
+     * the binding argument must be a resource which does not already
+     * exist.
+     */
+    dav_error * (*bind_resource)(const dav_resource *resource,
+                                 dav_resource *binding);
+
+    /*
+    ** If a provider needs a context to associate with this hooks structure,
+    ** then this field may be used. In most cases, it will just be NULL.
+    */
+    void *ctx;
+
+};
+
+
+/* --------------------------------------------------------------------
+**
+** SEARCH(DASL) FUNCTIONS
+*/
+
+/* search provider hooks */
+struct dav_hooks_search {
+    /* Set header for a OPTION method
+     * An error may be returned.
+     * To set a hadder, this function might call
+     * apr_table_setn(r->headers_out, "DASL", dasl_optin1);
+     *
+     * Examples:
+     * DASL: <DAV:basicsearch>
+     * DASL: <http://foo.bar.com/syntax1>
+     * DASL: <http://akuma.com/syntax2>
+     */
+    dav_error * (*set_option_head)(request_rec *r);
+
+    /* Search resources
+     * An error may be returned. *response will contain multistatus
+     * responses (if any) suitable for the body of the error. It is also
+     * possible to return NULL, yet still have multistatus responses.
+     * In this case, typically the caller should return a 207 (Multistatus)
+     * and the responses (in the body) as the HTTP response.
+     */
+    dav_error * (*search_resource)(request_rec *r,
+                                   dav_response **response);
+
+    /*
+    ** If a provider needs a context to associate with this hooks structure,
+    ** then this field may be used. In most cases, it will just be NULL.
+    */
+    void *ctx;
+
+};
+
+
+/* --------------------------------------------------------------------
+**
+** MISCELLANEOUS STUFF
+*/
+
+typedef struct {
+    int propid;                          /* live property ID */
+    const dav_hooks_liveprop *provider;  /* the provider defining this prop */
+} dav_elem_private;
+
+/* --------------------------------------------------------------------
+**
+** DAV OPTIONS
+*/
+#define DAV_OPTIONS_EXTENSION_GROUP "dav_options"
+
+typedef struct dav_options_provider
+{
+    dav_error* (*dav_header)(request_rec *r,
+                             const dav_resource *resource,
+                             apr_text_header *phdr);
+
+    dav_error* (*dav_method)(request_rec *r,
+                             const dav_resource *resource,
+                             apr_text_header *phdr);
+
+    void *ctx;
+} dav_options_provider;
+
+extern DAV_DECLARE(const dav_options_provider *) dav_get_options_providers(const char *name);
+
+extern DAV_DECLARE(void) dav_options_provider_register(apr_pool_t *p,
+                               const char *name,
+                               const dav_options_provider *provider);
+
+/* --------------------------------------------------------------------
+**
+** DAV RESOURCE TYPE HOOKS
+*/
+
+typedef struct dav_resource_type_provider
+{
+    int (*get_resource_type)(const dav_resource *resource,
+                  const char **name,
+                  const char **uri);
+} dav_resource_type_provider;
+
+#define DAV_RESOURCE_TYPE_GROUP "dav_resource_type"
+
+DAV_DECLARE(void) dav_resource_type_provider_register(apr_pool_t *p,
+                                        const char *name,
+                                    const dav_resource_type_provider *provider);
+
+DAV_DECLARE(const dav_resource_type_provider *) dav_get_resource_type_providers(const char *name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MOD_DAV_H_ */
+/** @} */
+
diff --git a/modules/dav/main/mod_dav.mak b/modules/dav/main/mod_dav.mak
new file mode 100644
index 0000000..a107e22
--- /dev/null
+++ b/modules/dav/main/mod_dav.mak
@@ -0,0 +1,406 @@
+# Microsoft Developer Studio Generated NMAKE File, Based on mod_dav.dsp
+!IF "$(CFG)" == ""
+CFG=mod_dav - Win32 Release
+!MESSAGE No configuration specified. Defaulting to mod_dav - Win32 Release.
+!ENDIF 
+
+!IF "$(CFG)" != "mod_dav - Win32 Release" && "$(CFG)" != "mod_dav - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "mod_dav.mak" CFG="mod_dav - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "mod_dav - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "mod_dav - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+
+!IF  "$(CFG)" == "mod_dav - Win32 Release"
+
+OUTDIR=.\Release
+INTDIR=.\Release
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+# Begin Custom Macros
+OutDir=.\Release
+# End Custom Macros
+
+!IF "$(RECURSE)" == "0" 
+
+ALL : "$(OUTDIR)\mod_dav.so" "$(DS_POSTBUILD_DEP)"
+
+!ELSE 
+
+ALL : "libhttpd - Win32 Release" "libaprutil - Win32 Release" "libapr - Win32 Release" "$(OUTDIR)\mod_dav.so" "$(DS_POSTBUILD_DEP)"
+
+!ENDIF 
+
+!IF "$(RECURSE)" == "1" 
+CLEAN :"libapr - Win32 ReleaseCLEAN" "libaprutil - Win32 ReleaseCLEAN" "libhttpd - Win32 ReleaseCLEAN" 
+!ELSE 
+CLEAN :
+!ENDIF 
+	-@erase "$(INTDIR)\liveprop.obj"
+	-@erase "$(INTDIR)\mod_dav.obj"
+	-@erase "$(INTDIR)\mod_dav.res"
+	-@erase "$(INTDIR)\mod_dav_src.idb"
+	-@erase "$(INTDIR)\mod_dav_src.pdb"
+	-@erase "$(INTDIR)\props.obj"
+	-@erase "$(INTDIR)\providers.obj"
+	-@erase "$(INTDIR)\std_liveprop.obj"
+	-@erase "$(INTDIR)\util.obj"
+	-@erase "$(INTDIR)\util_lock.obj"
+	-@erase "$(OUTDIR)\mod_dav.exp"
+	-@erase "$(OUTDIR)\mod_dav.lib"
+	-@erase "$(OUTDIR)\mod_dav.pdb"
+	-@erase "$(OUTDIR)\mod_dav.so"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+CPP_PROJ=/nologo /MD /W3 /Zi /O2 /Oy- /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "DAV_DECLARE_EXPORT" /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\mod_dav_src" /FD /c 
+
+.c{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.c{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+MTL=midl.exe
+MTL_PROJ=/nologo /D "NDEBUG" /mktyplib203 /win32 
+RSC=rc.exe
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)\mod_dav.res" /i "../../../include" /i "../../../srclib/apr/include" /d "NDEBUG" /d BIN_NAME="mod_dav.so" /d LONG_NAME="dav_module for Apache" 
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\mod_dav.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+LINK32_FLAGS=kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /pdb:"$(OUTDIR)\mod_dav.pdb" /debug /out:"$(OUTDIR)\mod_dav.so" /implib:"$(OUTDIR)\mod_dav.lib" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav.so /opt:ref 
+LINK32_OBJS= \
+	"$(INTDIR)\liveprop.obj" \
+	"$(INTDIR)\mod_dav.obj" \
+	"$(INTDIR)\props.obj" \
+	"$(INTDIR)\providers.obj" \
+	"$(INTDIR)\std_liveprop.obj" \
+	"$(INTDIR)\util.obj" \
+	"$(INTDIR)\util_lock.obj" \
+	"$(INTDIR)\mod_dav.res" \
+	"..\..\..\srclib\apr\Release\libapr-1.lib" \
+	"..\..\..\srclib\apr-util\Release\libaprutil-1.lib" \
+	"..\..\..\Release\libhttpd.lib"
+
+"$(OUTDIR)\mod_dav.so" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+TargetPath=.\Release\mod_dav.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+
+# Begin Custom Macros
+OutDir=.\Release
+# End Custom Macros
+
+"$(DS_POSTBUILD_DEP)" : "$(OUTDIR)\mod_dav.so"
+   if exist .\Release\mod_dav.so.manifest mt.exe -manifest .\Release\mod_dav.so.manifest -outputresource:.\Release\mod_dav.so;2
+	echo Helper for Post-build step > "$(DS_POSTBUILD_DEP)"
+
+!ELSEIF  "$(CFG)" == "mod_dav - Win32 Debug"
+
+OUTDIR=.\Debug
+INTDIR=.\Debug
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+# Begin Custom Macros
+OutDir=.\Debug
+# End Custom Macros
+
+!IF "$(RECURSE)" == "0" 
+
+ALL : "$(OUTDIR)\mod_dav.so" "$(DS_POSTBUILD_DEP)"
+
+!ELSE 
+
+ALL : "libhttpd - Win32 Debug" "libaprutil - Win32 Debug" "libapr - Win32 Debug" "$(OUTDIR)\mod_dav.so" "$(DS_POSTBUILD_DEP)"
+
+!ENDIF 
+
+!IF "$(RECURSE)" == "1" 
+CLEAN :"libapr - Win32 DebugCLEAN" "libaprutil - Win32 DebugCLEAN" "libhttpd - Win32 DebugCLEAN" 
+!ELSE 
+CLEAN :
+!ENDIF 
+	-@erase "$(INTDIR)\liveprop.obj"
+	-@erase "$(INTDIR)\mod_dav.obj"
+	-@erase "$(INTDIR)\mod_dav.res"
+	-@erase "$(INTDIR)\mod_dav_src.idb"
+	-@erase "$(INTDIR)\mod_dav_src.pdb"
+	-@erase "$(INTDIR)\props.obj"
+	-@erase "$(INTDIR)\providers.obj"
+	-@erase "$(INTDIR)\std_liveprop.obj"
+	-@erase "$(INTDIR)\util.obj"
+	-@erase "$(INTDIR)\util_lock.obj"
+	-@erase "$(OUTDIR)\mod_dav.exp"
+	-@erase "$(OUTDIR)\mod_dav.lib"
+	-@erase "$(OUTDIR)\mod_dav.pdb"
+	-@erase "$(OUTDIR)\mod_dav.so"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+CPP_PROJ=/nologo /MDd /W3 /Zi /Od /I "../../../include" /I "../../../srclib/apr/include" /I "../../../srclib/apr-util/include" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "DAV_DECLARE_EXPORT" /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\mod_dav_src" /FD /EHsc /c 
+
+.c{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.c{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(INTDIR)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+MTL=midl.exe
+MTL_PROJ=/nologo /D "_DEBUG" /mktyplib203 /win32 
+RSC=rc.exe
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)\mod_dav.res" /i "../../../include" /i "../../../srclib/apr/include" /d "_DEBUG" /d BIN_NAME="mod_dav.so" /d LONG_NAME="dav_module for Apache" 
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\mod_dav.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+LINK32_FLAGS=kernel32.lib ws2_32.lib mswsock.lib /nologo /subsystem:windows /dll /incremental:no /pdb:"$(OUTDIR)\mod_dav.pdb" /debug /out:"$(OUTDIR)\mod_dav.so" /implib:"$(OUTDIR)\mod_dav.lib" /base:@..\..\..\os\win32\BaseAddr.ref,mod_dav.so 
+LINK32_OBJS= \
+	"$(INTDIR)\liveprop.obj" \
+	"$(INTDIR)\mod_dav.obj" \
+	"$(INTDIR)\props.obj" \
+	"$(INTDIR)\providers.obj" \
+	"$(INTDIR)\std_liveprop.obj" \
+	"$(INTDIR)\util.obj" \
+	"$(INTDIR)\util_lock.obj" \
+	"$(INTDIR)\mod_dav.res" \
+	"..\..\..\srclib\apr\Debug\libapr-1.lib" \
+	"..\..\..\srclib\apr-util\Debug\libaprutil-1.lib" \
+	"..\..\..\Debug\libhttpd.lib"
+
+"$(OUTDIR)\mod_dav.so" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+TargetPath=.\Debug\mod_dav.so
+SOURCE="$(InputPath)"
+PostBuild_Desc=Embed .manifest
+DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep
+
+# Begin Custom Macros
+OutDir=.\Debug
+# End Custom Macros
+
+"$(DS_POSTBUILD_DEP)" : "$(OUTDIR)\mod_dav.so"
+   if exist .\Debug\mod_dav.so.manifest mt.exe -manifest .\Debug\mod_dav.so.manifest -outputresource:.\Debug\mod_dav.so;2
+	echo Helper for Post-build step > "$(DS_POSTBUILD_DEP)"
+
+!ENDIF 
+
+
+!IF "$(NO_EXTERNAL_DEPS)" != "1"
+!IF EXISTS("mod_dav.dep")
+!INCLUDE "mod_dav.dep"
+!ELSE 
+!MESSAGE Warning: cannot find "mod_dav.dep"
+!ENDIF 
+!ENDIF 
+
+
+!IF "$(CFG)" == "mod_dav - Win32 Release" || "$(CFG)" == "mod_dav - Win32 Debug"
+SOURCE=.\liveprop.c
+
+"$(INTDIR)\liveprop.obj" : $(SOURCE) "$(INTDIR)"
+
+
+SOURCE=.\mod_dav.c
+
+"$(INTDIR)\mod_dav.obj" : $(SOURCE) "$(INTDIR)"
+
+
+SOURCE=.\props.c
+
+"$(INTDIR)\props.obj" : $(SOURCE) "$(INTDIR)"
+
+
+SOURCE=.\providers.c
+
+"$(INTDIR)\providers.obj" : $(SOURCE) "$(INTDIR)"
+
+
+SOURCE=.\std_liveprop.c
+
+"$(INTDIR)\std_liveprop.obj" : $(SOURCE) "$(INTDIR)"
+
+
+SOURCE=.\util.c
+
+"$(INTDIR)\util.obj" : $(SOURCE) "$(INTDIR)"
+
+
+SOURCE=.\util_lock.c
+
+"$(INTDIR)\util_lock.obj" : $(SOURCE) "$(INTDIR)"
+
+
+!IF  "$(CFG)" == "mod_dav - Win32 Release"
+
+"libapr - Win32 Release" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Release" 
+   cd "..\..\modules\dav\main"
+
+"libapr - Win32 ReleaseCLEAN" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Release" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\main"
+
+!ELSEIF  "$(CFG)" == "mod_dav - Win32 Debug"
+
+"libapr - Win32 Debug" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Debug" 
+   cd "..\..\modules\dav\main"
+
+"libapr - Win32 DebugCLEAN" : 
+   cd ".\..\..\..\srclib\apr"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Debug" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\main"
+
+!ENDIF 
+
+!IF  "$(CFG)" == "mod_dav - Win32 Release"
+
+"libaprutil - Win32 Release" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Release" 
+   cd "..\..\modules\dav\main"
+
+"libaprutil - Win32 ReleaseCLEAN" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Release" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\main"
+
+!ELSEIF  "$(CFG)" == "mod_dav - Win32 Debug"
+
+"libaprutil - Win32 Debug" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Debug" 
+   cd "..\..\modules\dav\main"
+
+"libaprutil - Win32 DebugCLEAN" : 
+   cd ".\..\..\..\srclib\apr-util"
+   $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Debug" RECURSE=1 CLEAN 
+   cd "..\..\modules\dav\main"
+
+!ENDIF 
+
+!IF  "$(CFG)" == "mod_dav - Win32 Release"
+
+"libhttpd - Win32 Release" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Release" 
+   cd ".\modules\dav\main"
+
+"libhttpd - Win32 ReleaseCLEAN" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Release" RECURSE=1 CLEAN 
+   cd ".\modules\dav\main"
+
+!ELSEIF  "$(CFG)" == "mod_dav - Win32 Debug"
+
+"libhttpd - Win32 Debug" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Debug" 
+   cd ".\modules\dav\main"
+
+"libhttpd - Win32 DebugCLEAN" : 
+   cd ".\..\..\.."
+   $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Debug" RECURSE=1 CLEAN 
+   cd ".\modules\dav\main"
+
+!ENDIF 
+
+SOURCE=..\..\..\build\win32\httpd.rc
+
+!IF  "$(CFG)" == "mod_dav - Win32 Release"
+
+
+"$(INTDIR)\mod_dav.res" : $(SOURCE) "$(INTDIR)"
+	$(RSC) /l 0x409 /fo"$(INTDIR)\mod_dav.res" /i "../../../include" /i "../../../srclib/apr/include" /i "../../../build\win32" /d "NDEBUG" /d BIN_NAME="mod_dav.so" /d LONG_NAME="dav_module for Apache" $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mod_dav - Win32 Debug"
+
+
+"$(INTDIR)\mod_dav.res" : $(SOURCE) "$(INTDIR)"
+	$(RSC) /l 0x409 /fo"$(INTDIR)\mod_dav.res" /i "../../../include" /i "../../../srclib/apr/include" /i "../../../build\win32" /d "_DEBUG" /d BIN_NAME="mod_dav.so" /d LONG_NAME="dav_module for Apache" $(SOURCE)
+
+
+!ENDIF 
+
+
+!ENDIF 
+
diff --git a/modules/dav/main/props.c b/modules/dav/main/props.c
new file mode 100644
index 0000000..f64878e
--- /dev/null
+++ b/modules/dav/main/props.c
@@ -0,0 +1,1125 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+** DAV extension module for Apache 2.0.*
+**  - Property database handling (repository-independent)
+**
+** NOTES:
+**
+**   PROPERTY DATABASE
+**
+**   This version assumes that there is a per-resource database provider
+**   to record properties. The database provider decides how and where to
+**   store these databases.
+**
+**   The DBM keys for the properties have the following form:
+**
+**     namespace ":" propname
+**
+**   For example: 5:author
+**
+**   The namespace provides an integer index into the namespace table
+**   (see below). propname is simply the property name, without a namespace
+**   prefix.
+**
+**   A special case exists for properties that had a prefix starting with
+**   "xml". The XML Specification reserves these for future use. mod_dav
+**   stores and retrieves them unchanged. The keys for these properties
+**   have the form:
+**
+**     ":" propname
+**
+**   The propname will contain the prefix and the property name. For
+**   example, a key might be ":xmlfoo:name"
+**
+**   The ":name" style will also be used for properties that do not
+**   exist within a namespace.
+**
+**   The DBM values consist of two null-terminated strings, appended
+**   together (the null-terms are retained and stored in the database).
+**   The first string is the xml:lang value for the property. An empty
+**   string signifies that a lang value was not in context for the value.
+**   The second string is the property value itself.
+**
+**
+**   NAMESPACE TABLE
+**
+**   The namespace table is an array that lists each of the namespaces
+**   that are in use by the properties in the given propdb. Each entry
+**   in the array is a simple URI.
+**
+**   For example: http://www.foo.bar/standards/props/
+**
+**   The prefix used for the property is stripped and the URI for it
+**   is entered into the namespace table. Also, any namespaces used
+**   within the property value will be entered into the table (and
+**   stripped from the child elements).
+**
+**   The namespaces are stored in the DBM database under the "METADATA" key.
+**
+**
+**   STRIPPING NAMESPACES
+**
+**   Within the property values, the namespace declarations (xmlns...)
+**   are stripped. Each element and attribute will have its prefix removed
+**   and a new prefix inserted.
+**
+**   This must be done so that we can return multiple properties in a
+**   PROPFIND which may have (originally) used conflicting prefixes. For
+**   that case, we must bind all property value elements to new namespace
+**   values.
+**
+**   This implies that clients must NOT be sensitive to the namespace
+**   prefix used for their properties. It WILL change when the properties
+**   are returned (we return them as "ns<index>", e.g. "ns5"). Also, the
+**   property value can contain ONLY XML elements and CDATA. PI and comment
+**   elements will be stripped. CDATA whitespace will be preserved, but
+**   whitespace within element tags will be altered. Attribute ordering
+**   may be altered. Element and CDATA ordering will be preserved.
+**
+**
+**   ATTRIBUTES ON PROPERTY NAME ELEMENTS
+**
+**   When getting/setting properties, the XML used looks like:
+**
+**     <prop>
+**       <propname1>value</propname1>
+**       <propname2>value</propname1>
+**     </prop>
+**
+**   This implementation (mod_dav) DOES NOT save any attributes that are
+**   associated with the <propname1> element. The property value is deemed
+**   to be only the contents ("value" in the above example).
+**
+**   We do store the xml:lang value (if any) that applies to the context
+**   of the <propname1> element. Whether the xml:lang attribute is on
+**   <propname1> itself, or from a higher level element, we will store it
+**   with the property value.
+**
+**
+**   VERSIONING
+**
+**   The DBM db contains a key named "METADATA" that holds database-level
+**   information, such as the namespace table. The record also contains the
+**   db's version number as the very first 16-bit value. This first number
+**   is actually stored as two single bytes: the first byte is a "major"
+**   version number. The second byte is a "minor" number.
+**
+**   If the major number is not what mod_dav expects, then the db is closed
+**   immediately and an error is returned. A minor number change is
+**   acceptable -- it is presumed that old/new dav_props.c can deal with
+**   the database format. For example, a newer dav_props might update the
+**   minor value and append information to the end of the metadata record
+**   (which would be ignored by previous versions).
+**
+**
+** ISSUES:
+**
+**   At the moment, for the dav_get_allprops() and dav_get_props() functions,
+**   we must return a set of xmlns: declarations for ALL known namespaces
+**   in the file. There isn't a way to filter this because we don't know
+**   which are going to be used or not. Examining property names is not
+**   sufficient because the property values could use entirely different
+**   namespaces.
+**
+**   ==> we must devise a scheme where we can "garbage collect" the namespace
+**       entries from the property database.
+*/
+
+#include "apr.h"
+#include "apr_strings.h"
+
+#define APR_WANT_STDIO
+#define APR_WANT_BYTEFUNC
+#include "apr_want.h"
+
+#include "mod_dav.h"
+
+#include "http_log.h"
+#include "http_request.h"
+
+/*
+** There is some rough support for writable DAV:getcontenttype and
+** DAV:getcontentlanguage properties. If this #define is (1), then
+** this support is disabled.
+**
+** We are disabling it because of a lack of support in GET and PUT
+** operations. For GET, it would be "expensive" to look for a propdb,
+** open it, and attempt to extract the Content-Type and Content-Language
+** values for the response.
+** (Handling the PUT would not be difficult, though)
+*/
+#define DAV_DISABLE_WRITABLE_PROPS     1
+
+#define DAV_EMPTY_VALUE                "\0"    /* TWO null terms */
+
+struct dav_propdb {
+    apr_pool_t *p;                /* the pool we should use */
+    request_rec *r;               /* the request record */
+
+    const dav_resource *resource; /* the target resource */
+
+    int deferred;                 /* open of db has been deferred */
+    dav_db *db;                   /* underlying database containing props */
+
+    apr_array_header_t *ns_xlate; /* translation of an elem->ns to URI */
+    dav_namespace_map *mapping;   /* namespace mapping */
+
+    dav_lockdb *lockdb;           /* the lock database */
+
+    dav_buffer wb_lock;           /* work buffer for lockdiscovery property */
+
+    /* if we ever run a GET subreq, it will be stored here */
+    request_rec *subreq;
+
+    /* hooks we should use for processing (based on the target resource) */
+    const dav_hooks_db *db_hooks;
+};
+
+/* NOTE: dav_core_props[] and the following enum must stay in sync. */
+/* ### move these into a "core" liveprop provider? */
+static const char * const dav_core_props[] =
+{
+    "getcontenttype",
+    "getcontentlanguage",
+    "lockdiscovery",
+    "supportedlock",
+
+    NULL        /* sentinel */
+};
+enum {
+    DAV_PROPID_CORE_getcontenttype = DAV_PROPID_CORE,
+    DAV_PROPID_CORE_getcontentlanguage,
+    DAV_PROPID_CORE_lockdiscovery,
+    DAV_PROPID_CORE_supportedlock,
+
+    DAV_PROPID_CORE_UNKNOWN
+};
+
+/*
+** This structure is used to track information needed for a rollback.
+*/
+typedef struct dav_rollback_item {
+    /* select one of the two rollback context structures based on the
+       value of dav_prop_ctx.is_liveprop */
+    dav_deadprop_rollback *deadprop;
+    dav_liveprop_rollback *liveprop;
+
+} dav_rollback_item;
+
+
+static int dav_find_liveprop_provider(dav_propdb *propdb,
+                                      const char *ns_uri,
+                                      const char *propname,
+                                      const dav_hooks_liveprop **provider)
+{
+    int propid;
+
+    *provider = NULL;
+
+    if (ns_uri == NULL) {
+        /* policy: liveprop providers cannot define no-namespace properties */
+        return DAV_PROPID_CORE_UNKNOWN;
+    }
+
+    /* check liveprop providers first, so they can define core properties */
+    propid = dav_run_find_liveprop(propdb->resource, ns_uri, propname,
+                                   provider);
+    if (propid != 0) {
+        return propid;
+    }
+
+    /* check for core property */
+    if (strcmp(ns_uri, "DAV:") == 0) {
+        const char * const *p = dav_core_props;
+
+        for (propid = DAV_PROPID_CORE; *p != NULL; ++p, ++propid)
+            if (strcmp(propname, *p) == 0) {
+                return propid;
+            }
+    }
+
+    /* no provider for this property */
+    return DAV_PROPID_CORE_UNKNOWN;
+}
+
+static void dav_find_liveprop(dav_propdb *propdb, apr_xml_elem *elem)
+{
+    const char *ns_uri;
+    dav_elem_private *priv = elem->priv;
+    const dav_hooks_liveprop *hooks;
+
+
+    if (elem->ns == APR_XML_NS_NONE)
+        ns_uri = NULL;
+    else if (elem->ns == APR_XML_NS_DAV_ID)
+        ns_uri = "DAV:";
+    else
+        ns_uri = APR_XML_GET_URI_ITEM(propdb->ns_xlate, elem->ns);
+
+    priv->propid = dav_find_liveprop_provider(propdb, ns_uri, elem->name,
+                                              &hooks);
+
+    /* ### this test seems redundant... */
+    if (priv->propid != DAV_PROPID_CORE_UNKNOWN) {
+        priv->provider = hooks;
+    }
+}
+
+/* is the live property read/write? */
+static int dav_rw_liveprop(dav_propdb *propdb, dav_elem_private *priv)
+{
+    int propid = priv->propid;
+
+    /*
+    ** Check the liveprop provider (if this is a provider-defined prop)
+    */
+    if (priv->provider != NULL) {
+        return (*priv->provider->is_writable)(propdb->resource, propid);
+    }
+
+    /* these are defined as read-only */
+    if (propid == DAV_PROPID_CORE_lockdiscovery
+#if DAV_DISABLE_WRITABLE_PROPS
+        || propid == DAV_PROPID_CORE_getcontenttype
+        || propid == DAV_PROPID_CORE_getcontentlanguage
+#endif
+        || propid == DAV_PROPID_CORE_supportedlock
+        ) {
+
+        return 0;
+    }
+
+    /* these are defined as read/write */
+    if (propid == DAV_PROPID_CORE_getcontenttype
+        || propid == DAV_PROPID_CORE_getcontentlanguage
+        || propid == DAV_PROPID_CORE_UNKNOWN) {
+
+        return 1;
+    }
+
+    /*
+    ** We don't recognize the property, so it must be dead (and writable)
+    */
+    return 1;
+}
+
+/* do a sub-request to fetch properties for the target resource's URI. */
+static void dav_do_prop_subreq(dav_propdb *propdb)
+{
+    /* need to escape the uri that's in the resource struct because during
+     * the property walker it's not encoded. */
+    const char *e_uri = ap_escape_uri(propdb->resource->pool,
+                                      propdb->resource->uri);
+
+    /* perform a "GET" on the resource's URI (note that the resource
+       may not correspond to the current request!). */
+    propdb->subreq = ap_sub_req_lookup_uri(e_uri, propdb->r, NULL);
+}
+
+static dav_error * dav_insert_coreprop(dav_propdb *propdb,
+                                       int propid, const char *name,
+                                       dav_prop_insert what,
+                                       apr_text_header *phdr,
+                                       dav_prop_insert *inserted)
+{
+    const char *value = NULL;
+    dav_error *err;
+
+    *inserted = DAV_PROP_INSERT_NOTDEF;
+
+    /* fast-path the common case */
+    if (propid == DAV_PROPID_CORE_UNKNOWN)
+        return NULL;
+
+    switch (propid) {
+
+    case DAV_PROPID_CORE_lockdiscovery:
+        if (propdb->lockdb != NULL) {
+            dav_lock *locks;
+
+            if ((err = dav_lock_query(propdb->lockdb, propdb->resource,
+                                      &locks)) != NULL) {
+                return dav_push_error(propdb->p, err->status, 0,
+                                      "DAV:lockdiscovery could not be "
+                                      "determined due to a problem fetching "
+                                      "the locks for this resource.",
+                                      err);
+            }
+
+            /* fast-path the no-locks case */
+            if (locks == NULL) {
+                value = "";
+            }
+            else {
+                /*
+                ** This may modify the buffer. value may point to
+                ** wb_lock.pbuf or a string constant.
+                */
+                value = dav_lock_get_activelock(propdb->r, locks,
+                                                &propdb->wb_lock);
+
+                /* make a copy to isolate it from changes to wb_lock */
+                value = apr_pstrdup(propdb->p, propdb->wb_lock.buf);
+            }
+        }
+        break;
+
+    case DAV_PROPID_CORE_supportedlock:
+        if (propdb->lockdb != NULL) {
+            value = (*propdb->lockdb->hooks->get_supportedlock)(propdb->resource);
+        }
+        break;
+
+    case DAV_PROPID_CORE_getcontenttype:
+        if (propdb->subreq == NULL) {
+            dav_do_prop_subreq(propdb);
+        }
+        if (propdb->subreq->content_type != NULL) {
+            value = propdb->subreq->content_type;
+        }
+        break;
+
+    case DAV_PROPID_CORE_getcontentlanguage:
+    {
+        const char *lang;
+
+        if (propdb->subreq == NULL) {
+            dav_do_prop_subreq(propdb);
+        }
+        if ((lang = apr_table_get(propdb->subreq->headers_out,
+                                 "Content-Language")) != NULL) {
+            value = lang;
+        }
+        break;
+    }
+
+    default:
+        /* fall through to interpret as a dead property */
+        break;
+    }
+
+    /* if something was supplied, then insert it */
+    if (value != NULL) {
+        const char *s;
+
+        if (what == DAV_PROP_INSERT_SUPPORTED) {
+            /* use D: prefix to refer to the DAV: namespace URI,
+             * and let the namespace attribute default to "DAV:"
+             */
+            s = apr_psprintf(propdb->p,
+                            "<D:supported-live-property D:name=\"%s\"/>" DEBUG_CR,
+                            name);
+        }
+        else if (what == DAV_PROP_INSERT_VALUE && *value != '\0') {
+            /* use D: prefix to refer to the DAV: namespace URI */
+            s = apr_psprintf(propdb->p, "<D:%s>%s</D:%s>" DEBUG_CR,
+                            name, value, name);
+        }
+        else {
+            /* use D: prefix to refer to the DAV: namespace URI */
+            s = apr_psprintf(propdb->p, "<D:%s/>" DEBUG_CR, name);
+        }
+        apr_text_append(propdb->p, phdr, s);
+
+        *inserted = what;
+    }
+
+    return NULL;
+}
+
+static dav_error * dav_insert_liveprop(dav_propdb *propdb,
+                                       const apr_xml_elem *elem,
+                                       dav_prop_insert what,
+                                       apr_text_header *phdr,
+                                       dav_prop_insert *inserted)
+{
+    dav_elem_private *priv = elem->priv;
+
+    *inserted = DAV_PROP_INSERT_NOTDEF;
+
+    if (priv->provider == NULL) {
+        /* this is a "core" property that we define */
+        return dav_insert_coreprop(propdb, priv->propid, elem->name,
+                                   what, phdr, inserted);
+    }
+
+    /* ask the provider (that defined this prop) to insert the prop */
+    *inserted = (*priv->provider->insert_prop)(propdb->resource, priv->propid,
+                                               what, phdr);
+
+    return NULL;
+}
+
+static void dav_output_prop_name(apr_pool_t *pool,
+                                 const dav_prop_name *name,
+                                 dav_xmlns_info *xi,
+                                 apr_text_header *phdr)
+{
+    const char *s;
+
+    if (*name->ns == '\0')
+        s = apr_psprintf(pool, "<%s/>" DEBUG_CR, name->name);
+    else {
+        const char *prefix = dav_xmlns_add_uri(xi, name->ns);
+
+        s = apr_psprintf(pool, "<%s:%s/>" DEBUG_CR, prefix, name->name);
+    }
+
+    apr_text_append(pool, phdr, s);
+}
+
+static void dav_insert_xmlns(apr_pool_t *p, const char *pre_prefix, long ns,
+                             const char *ns_uri, apr_text_header *phdr)
+{
+    const char *s;
+
+    s = apr_psprintf(p, " xmlns:%s%ld=\"%s\"", pre_prefix, ns, ns_uri);
+    apr_text_append(p, phdr, s);
+}
+
+static dav_error *dav_really_open_db(dav_propdb *propdb, int ro)
+{
+    dav_error *err;
+
+    /* we're trying to open the db; turn off the 'deferred' flag */
+    propdb->deferred = 0;
+
+    /* ask the DB provider to open the thing */
+    err = (*propdb->db_hooks->open)(propdb->p, propdb->resource, ro,
+                                    &propdb->db);
+    if (err != NULL) {
+        return dav_push_error(propdb->p, HTTP_INTERNAL_SERVER_ERROR,
+                              DAV_ERR_PROP_OPENING,
+                              "Could not open the property database.",
+                              err);
+    }
+
+    /*
+    ** NOTE: propdb->db could be NULL if we attempted to open a readonly
+    **       database that doesn't exist. If we require read/write
+    **       access, then a database was created and opened.
+    */
+
+    return NULL;
+}
+
+DAV_DECLARE(dav_error *)dav_open_propdb(request_rec *r, dav_lockdb *lockdb,
+                                        const dav_resource *resource,
+                                        int ro,
+                                        apr_array_header_t * ns_xlate,
+                                        dav_propdb **p_propdb)
+{
+    dav_propdb *propdb = apr_pcalloc(r->pool, sizeof(*propdb));
+
+    *p_propdb = NULL;
+
+#if DAV_DEBUG
+    if (resource->uri == NULL) {
+        return dav_new_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                             "INTERNAL DESIGN ERROR: resource must define "
+                             "its URI.");
+    }
+#endif
+
+    propdb->r = r;
+    apr_pool_create(&propdb->p, r->pool);
+    propdb->resource = resource;
+    propdb->ns_xlate = ns_xlate;
+
+    propdb->db_hooks = DAV_GET_HOOKS_PROPDB(r);
+
+    propdb->lockdb = lockdb;
+
+    /* always defer actual open, to avoid expense of accessing db
+     * when only live properties are involved
+     */
+    propdb->deferred = 1;
+
+    /* ### what to do about closing the propdb on server failure? */
+
+    *p_propdb = propdb;
+    return NULL;
+}
+
+DAV_DECLARE(void) dav_close_propdb(dav_propdb *propdb)
+{
+    if (propdb->db != NULL) {
+        (*propdb->db_hooks->close)(propdb->db);
+    }
+
+    /* Currently, mod_dav's pool usage doesn't allow clearing this pool. */
+#if 0
+    apr_pool_destroy(propdb->p);
+#endif
+}
+
+DAV_DECLARE(dav_get_props_result) dav_get_allprops(dav_propdb *propdb,
+                                                   dav_prop_insert what)
+{
+    const dav_hooks_db *db_hooks = propdb->db_hooks;
+    apr_text_header hdr = { 0 };
+    apr_text_header hdr_ns = { 0 };
+    dav_get_props_result result = { 0 };
+    int found_contenttype = 0;
+    int found_contentlang = 0;
+    dav_prop_insert unused_inserted;
+
+    /* if not just getting supported live properties,
+     * scan all properties in the dead prop database
+     */
+    if (what != DAV_PROP_INSERT_SUPPORTED) {
+        if (propdb->deferred) {
+            /* ### what to do with db open error? */
+            (void) dav_really_open_db(propdb, 1 /*ro*/);
+        }
+
+        /* initialize the result with some start tags... */
+        apr_text_append(propdb->p, &hdr,
+                        "<D:propstat>" DEBUG_CR
+                        "<D:prop>" DEBUG_CR);
+
+        /* if there ARE properties, then scan them */
+        if (propdb->db != NULL) {
+            dav_xmlns_info *xi = dav_xmlns_create(propdb->p);
+            dav_prop_name name;
+            dav_error *err;
+
+            /* define (up front) any namespaces the db might need */
+            (void) (*db_hooks->define_namespaces)(propdb->db, xi);
+
+            /* get the first property name, beginning the scan */
+            err = (*db_hooks->first_name)(propdb->db, &name);
+            while (!err && name.ns) {
+
+                /*
+                ** We also look for <DAV:getcontenttype> and
+                ** <DAV:getcontentlanguage>. If they are not stored as dead
+                ** properties, then we need to perform a subrequest to get
+                ** their values (if any).
+                */
+                if (*name.ns == 'D' && strcmp(name.ns, "DAV:") == 0
+                    && *name.name == 'g') {
+                    if (strcmp(name.name, "getcontenttype") == 0) {
+                        found_contenttype = 1;
+                    }
+                    else if (strcmp(name.name, "getcontentlanguage") == 0) {
+                        found_contentlang = 1;
+                    }
+                }
+
+                if (what == DAV_PROP_INSERT_VALUE) {
+                    int found;
+
+                    if ((err = (*db_hooks->output_value)(propdb->db, &name,
+                                                         xi, &hdr,
+                                                         &found)) != NULL) {
+                        /* ### anything better to do? */
+                        /* ### probably should enter a 500 error */
+                        goto next_key;
+                    }
+                    /* assert: found == 1 */
+                }
+                else {
+                    /* the value was not requested, so just add an empty
+                       tag specifying the property name. */
+                    dav_output_prop_name(propdb->p, &name, xi, &hdr);
+                }
+
+              next_key:
+                err = (*db_hooks->next_name)(propdb->db, &name);
+            }
+
+            /* all namespaces have been entered into xi. generate them into
+               the output now. */
+            dav_xmlns_generate(xi, &hdr_ns);
+
+        } /* propdb->db != NULL */
+
+        /* add namespaces for all the liveprop providers */
+        dav_add_all_liveprop_xmlns(propdb->p, &hdr_ns);
+    }
+
+    /* ask the liveprop providers to insert their properties */
+    dav_run_insert_all_liveprops(propdb->r, propdb->resource, what, &hdr);
+
+    /* insert the standard properties */
+    /* ### should be handling the return errors here */
+    (void)dav_insert_coreprop(propdb,
+                              DAV_PROPID_CORE_supportedlock, "supportedlock",
+                              what, &hdr, &unused_inserted);
+    (void)dav_insert_coreprop(propdb,
+                              DAV_PROPID_CORE_lockdiscovery, "lockdiscovery",
+                              what, &hdr, &unused_inserted);
+
+    /* if we didn't find these, then do the whole subreq thing. */
+    if (!found_contenttype) {
+        /* ### should be handling the return error here */
+        (void)dav_insert_coreprop(propdb,
+                                  DAV_PROPID_CORE_getcontenttype,
+                                  "getcontenttype",
+                                  what, &hdr, &unused_inserted);
+    }
+    if (!found_contentlang) {
+        /* ### should be handling the return error here */
+        (void)dav_insert_coreprop(propdb,
+                                  DAV_PROPID_CORE_getcontentlanguage,
+                                  "getcontentlanguage",
+                                  what, &hdr, &unused_inserted);
+    }
+
+    /* if not just reporting on supported live props,
+     * terminate the result */
+    if (what != DAV_PROP_INSERT_SUPPORTED) {
+        apr_text_append(propdb->p, &hdr,
+                        "</D:prop>" DEBUG_CR
+                        "<D:status>HTTP/1.1 200 OK</D:status>" DEBUG_CR
+                        "</D:propstat>" DEBUG_CR);
+    }
+
+    result.propstats = hdr.first;
+    result.xmlns = hdr_ns.first;
+    return result;
+}
+
+DAV_DECLARE(dav_get_props_result) dav_get_props(dav_propdb *propdb,
+                                                apr_xml_doc *doc)
+{
+    const dav_hooks_db *db_hooks = propdb->db_hooks;
+    apr_xml_elem *elem = dav_find_child(doc->root, "prop");
+    apr_text_header hdr_good = { 0 };
+    apr_text_header hdr_bad = { 0 };
+    apr_text_header hdr_ns = { 0 };
+    int have_good = 0;
+    dav_get_props_result result = { 0 };
+    char *marks_liveprop;
+    dav_xmlns_info *xi;
+    int xi_filled = 0;
+
+    /* ### NOTE: we should pass in TWO buffers -- one for keys, one for
+       the marks */
+
+    /* we will ALWAYS provide a "good" result, even if it is EMPTY */
+    apr_text_append(propdb->p, &hdr_good,
+                   "<D:propstat>" DEBUG_CR
+                   "<D:prop>" DEBUG_CR);
+
+    /* ### the marks should be in a buffer! */
+    /* allocate zeroed-memory for the marks. These marks indicate which
+       liveprop namespaces we've generated into the output xmlns buffer */
+
+    /* same for the liveprops */
+    marks_liveprop = apr_pcalloc(propdb->p, dav_get_liveprop_ns_count() + 1);
+
+    xi = dav_xmlns_create(propdb->p);
+
+    for (elem = elem->first_child; elem; elem = elem->next) {
+        dav_elem_private *priv;
+        dav_error *err;
+        dav_prop_insert inserted;
+        dav_prop_name name;
+
+        /*
+        ** First try live property providers; if they don't handle
+        ** the property, then try looking it up in the propdb.
+        */
+
+        if (elem->priv == NULL) {
+            elem->priv = apr_pcalloc(propdb->p, sizeof(*priv));
+        }
+        priv = elem->priv;
+
+        /* cache the propid; dav_get_props() could be called many times */
+        if (priv->propid == 0)
+            dav_find_liveprop(propdb, elem);
+
+        if (priv->propid != DAV_PROPID_CORE_UNKNOWN) {
+
+            /* insert the property. returns 1 if an insertion was done. */
+            if ((err = dav_insert_liveprop(propdb, elem, DAV_PROP_INSERT_VALUE,
+                                           &hdr_good, &inserted)) != NULL) {
+                /* ### need to propagate the error to the caller... */
+                /* ### skip it for now, as if nothing was inserted */
+            }
+            if (inserted == DAV_PROP_INSERT_VALUE) {
+                have_good = 1;
+
+                /*
+                ** Add the liveprop's namespace URIs. Note that provider==NULL
+                ** for core properties.
+                */
+                if (priv->provider != NULL) {
+                    const char * const * scan_ns_uri;
+
+                    for (scan_ns_uri = priv->provider->namespace_uris;
+                         *scan_ns_uri != NULL;
+                         ++scan_ns_uri) {
+                        long ns;
+
+                        ns = dav_get_liveprop_ns_index(*scan_ns_uri);
+                        if (marks_liveprop[ns])
+                            continue;
+                        marks_liveprop[ns] = 1;
+
+                        dav_insert_xmlns(propdb->p, "lp", ns, *scan_ns_uri,
+                                         &hdr_ns);
+                    }
+                }
+
+                /* property added. move on to the next property. */
+                continue;
+            }
+            else if (inserted == DAV_PROP_INSERT_NOTDEF) {
+                /* nothing to do. fall thru to allow property to be handled
+                   as a dead property */
+            }
+#if DAV_DEBUG
+            else {
+#if 0
+                /* ### need to change signature to return an error */
+                return dav_new_error(propdb->p, HTTP_INTERNAL_SERVER_ERROR, 0,
+                                     0,
+                                     "INTERNAL DESIGN ERROR: insert_liveprop "
+                                     "did not insert what was asked for.");
+#endif
+            }
+#endif
+        }
+
+        /* The property wasn't a live property, so look in the dead property
+           database. */
+
+        /* make sure propdb is really open */
+        if (propdb->deferred) {
+            /* ### what to do with db open error? */
+            (void) dav_really_open_db(propdb, 1 /*ro*/);
+        }
+
+        if (elem->ns == APR_XML_NS_NONE)
+            name.ns = "";
+        else
+            name.ns = APR_XML_GET_URI_ITEM(propdb->ns_xlate, elem->ns);
+        name.name = elem->name;
+
+        /* only bother to look if a database exists */
+        if (propdb->db != NULL) {
+            int found;
+
+            if ((err = (*db_hooks->output_value)(propdb->db, &name,
+                                                 xi, &hdr_good,
+                                                 &found)) != NULL) {
+                /* ### what to do? continue doesn't seem right... */
+                continue;
+            }
+
+            if (found) {
+                have_good = 1;
+
+                /* if we haven't added the db's namespaces, then do so... */
+                if (!xi_filled) {
+                    (void) (*db_hooks->define_namespaces)(propdb->db, xi);
+                    xi_filled = 1;
+                }
+                continue;
+            }
+        }
+
+        /* not found as a live OR dead property. add a record to the "bad"
+           propstats */
+
+        /* make sure we've started our "bad" propstat */
+        if (hdr_bad.first == NULL) {
+            apr_text_append(propdb->p, &hdr_bad,
+                            "<D:propstat>" DEBUG_CR
+                            "<D:prop>" DEBUG_CR);
+        }
+
+        /* output this property's name (into the bad propstats) */
+        dav_output_prop_name(propdb->p, &name, xi, &hdr_bad);
+    }
+
+    apr_text_append(propdb->p, &hdr_good,
+                    "</D:prop>" DEBUG_CR
+                    "<D:status>HTTP/1.1 200 OK</D:status>" DEBUG_CR
+                    "</D:propstat>" DEBUG_CR);
+
+    /* default to start with the good */
+    result.propstats = hdr_good.first;
+
+    /* we may not have any "bad" results */
+    if (hdr_bad.first != NULL) {
+        /* "close" the bad propstat */
+        apr_text_append(propdb->p, &hdr_bad,
+                        "</D:prop>" DEBUG_CR
+                        "<D:status>HTTP/1.1 404 Not Found</D:status>" DEBUG_CR
+                        "</D:propstat>" DEBUG_CR);
+
+        /* if there are no good props, then just return the bad */
+        if (!have_good) {
+            result.propstats = hdr_bad.first;
+        }
+        else {
+            /* hook the bad propstat to the end of the good one */
+            hdr_good.last->next = hdr_bad.first;
+        }
+    }
+
+    /* add in all the various namespaces, and return them */
+    dav_xmlns_generate(xi, &hdr_ns);
+    result.xmlns = hdr_ns.first;
+
+    return result;
+}
+
+DAV_DECLARE(void) dav_get_liveprop_supported(dav_propdb *propdb,
+                                             const char *ns_uri,
+                                             const char *propname,
+                                             apr_text_header *body)
+{
+    int propid;
+    const dav_hooks_liveprop *hooks;
+
+    propid = dav_find_liveprop_provider(propdb, ns_uri, propname, &hooks);
+
+    if (propid != DAV_PROPID_CORE_UNKNOWN) {
+        if (hooks == NULL) {
+            /* this is a "core" property that we define */
+            dav_prop_insert unused_inserted;
+            dav_insert_coreprop(propdb, propid, propname,
+                                DAV_PROP_INSERT_SUPPORTED, body, &unused_inserted);
+        }
+        else {
+            (*hooks->insert_prop)(propdb->resource, propid,
+                                  DAV_PROP_INSERT_SUPPORTED, body);
+        }
+    }
+}
+
+DAV_DECLARE_NONSTD(void) dav_prop_validate(dav_prop_ctx *ctx)
+{
+    dav_propdb *propdb = ctx->propdb;
+    apr_xml_elem *prop = ctx->prop;
+    dav_elem_private *priv;
+
+    priv = ctx->prop->priv = apr_pcalloc(propdb->p, sizeof(*priv));
+
+    /*
+    ** Check to see if this is a live property, and fill the fields
+    ** in the XML elem, as appropriate.
+    **
+    ** Verify that the property is read/write. If not, then it cannot
+    ** be SET or DELETEd.
+    */
+    if (priv->propid == 0) {
+        dav_find_liveprop(propdb, prop);
+
+        /* it's a liveprop if a provider was found */
+        /* ### actually the "core" props should really be liveprops, but
+           ### there is no "provider" for those and the r/w props are
+           ### treated as dead props anyhow */
+        ctx->is_liveprop = priv->provider != NULL;
+    }
+
+    if (!dav_rw_liveprop(propdb, priv)) {
+        ctx->err = dav_new_error(propdb->p, HTTP_CONFLICT,
+                                 DAV_ERR_PROP_READONLY, 0,
+                                 "Property is read-only.");
+        return;
+    }
+
+    if (ctx->is_liveprop) {
+        int defer_to_dead = 0;
+
+        ctx->err = (*priv->provider->patch_validate)(propdb->resource,
+                                                     prop, ctx->operation,
+                                                     &ctx->liveprop_ctx,
+                                                     &defer_to_dead);
+        if (ctx->err != NULL || !defer_to_dead)
+            return;
+
+        /* clear is_liveprop -- act as a dead prop now */
+        ctx->is_liveprop = 0;
+    }
+
+    /*
+    ** The property is supposed to be stored into the dead-property
+    ** database. Make sure the thing is truly open (and writable).
+    */
+    if (propdb->deferred
+        && (ctx->err = dav_really_open_db(propdb, 0 /* ro */)) != NULL) {
+        return;
+    }
+
+    /*
+    ** There should be an open, writable database in here!
+    **
+    ** Note: the database would be NULL if it was opened readonly and it
+    **       did not exist.
+    */
+    if (propdb->db == NULL) {
+        ctx->err = dav_new_error(propdb->p, HTTP_INTERNAL_SERVER_ERROR,
+                                 DAV_ERR_PROP_NO_DATABASE, 0,
+                                 "Attempted to set/remove a property "
+                                 "without a valid, open, read/write "
+                                 "property database.");
+        return;
+    }
+
+    if (ctx->operation == DAV_PROP_OP_SET) {
+        /*
+        ** Prep the element => propdb namespace index mapping, inserting
+        ** namespace URIs into the propdb that don't exist.
+        */
+        (void) (*propdb->db_hooks->map_namespaces)(propdb->db,
+                                                   propdb->ns_xlate,
+                                                   &propdb->mapping);
+    }
+    else if (ctx->operation == DAV_PROP_OP_DELETE) {
+        /*
+        ** There are no checks to perform here. If a property exists, then
+        ** we will delete it. If it does not exist, then it does not matter
+        ** (see S12.13.1).
+        **
+        ** Note that if a property does not exist, that does not rule out
+        ** that a SET will occur during this PROPPATCH (thusly creating it).
+        */
+    }
+}
+
+DAV_DECLARE_NONSTD(void) dav_prop_exec(dav_prop_ctx *ctx)
+{
+    dav_propdb *propdb = ctx->propdb;
+    dav_error *err = NULL;
+    dav_elem_private *priv = ctx->prop->priv;
+
+    ctx->rollback = apr_pcalloc(propdb->p, sizeof(*ctx->rollback));
+
+    if (ctx->is_liveprop) {
+        err = (*priv->provider->patch_exec)(propdb->resource,
+                                            ctx->prop, ctx->operation,
+                                            ctx->liveprop_ctx,
+                                            &ctx->rollback->liveprop);
+    }
+    else {
+        dav_prop_name name;
+
+        if (ctx->prop->ns == APR_XML_NS_NONE)
+            name.ns = "";
+        else
+            name.ns = APR_XML_GET_URI_ITEM(propdb->ns_xlate, ctx->prop->ns);
+        name.name = ctx->prop->name;
+
+        /* save the old value so that we can do a rollback. */
+        if ((err = (*propdb->db_hooks
+                    ->get_rollback)(propdb->db, &name,
+                                    &ctx->rollback->deadprop)) != NULL)
+            goto error;
+
+        if (ctx->operation == DAV_PROP_OP_SET) {
+
+            /* Note: propdb->mapping was set in dav_prop_validate() */
+            err = (*propdb->db_hooks->store)(propdb->db, &name, ctx->prop,
+                                             propdb->mapping);
+
+            /*
+            ** If an error occurred, then assume that we didn't change the
+            ** value. Remove the rollback item so that we don't try to set
+            ** its value during the rollback.
+            */
+            /* ### euh... where is the removal? */
+        }
+        else if (ctx->operation == DAV_PROP_OP_DELETE) {
+
+            /*
+            ** Delete the property. Ignore errors -- the property is there, or
+            ** we are deleting it for a second time.
+            */
+            /* ### but what about other errors? */
+            (void) (*propdb->db_hooks->remove)(propdb->db, &name);
+        }
+    }
+
+  error:
+    /* push a more specific error here */
+    if (err != NULL) {
+        /*
+        ** Use HTTP_INTERNAL_SERVER_ERROR because we shouldn't have seen
+        ** any errors at this point.
+        */
+        ctx->err = dav_push_error(propdb->p, HTTP_INTERNAL_SERVER_ERROR,
+                                  DAV_ERR_PROP_EXEC,
+                                  "Could not execute PROPPATCH.", err);
+    }
+}
+
+DAV_DECLARE_NONSTD(void) dav_prop_commit(dav_prop_ctx *ctx)
+{
+    dav_elem_private *priv = ctx->prop->priv;
+
+    /*
+    ** Note that a commit implies ctx->err is NULL. The caller should assume
+    ** a status of HTTP_OK for this case.
+    */
+
+    if (ctx->is_liveprop) {
+        (*priv->provider->patch_commit)(ctx->propdb->resource,
+                                        ctx->operation,
+                                        ctx->liveprop_ctx,
+                                        ctx->rollback->liveprop);
+    }
+}
+
+DAV_DECLARE_NONSTD(void) dav_prop_rollback(dav_prop_ctx *ctx)
+{
+    dav_error *err = NULL;
+    dav_elem_private *priv = ctx->prop->priv;
+
+    /* do nothing if there is no rollback information. */
+    if (ctx->rollback == NULL)
+        return;
+
+    /*
+    ** ### if we have an error, and a rollback occurs, then the namespace
+    ** ### mods should not happen at all. Basically, the namespace management
+    ** ### is simply a bitch.
+    */
+
+    if (ctx->is_liveprop) {
+        err = (*priv->provider->patch_rollback)(ctx->propdb->resource,
+                                                ctx->operation,
+                                                ctx->liveprop_ctx,
+                                                ctx->rollback->liveprop);
+    }
+    else {
+        err = (*ctx->propdb->db_hooks
+               ->apply_rollback)(ctx->propdb->db, ctx->rollback->deadprop);
+    }
+
+    if (err != NULL) {
+        if (ctx->err == NULL)
+            ctx->err = err;
+        else {
+            dav_error *scan = err;
+
+            /* hook previous errors at the end of the rollback error */
+            while (scan->prev != NULL)
+                scan = scan->prev;
+            scan->prev = ctx->err;
+            ctx->err = err;
+        }
+    }
+}
diff --git a/modules/dav/main/providers.c b/modules/dav/main/providers.c
new file mode 100644
index 0000000..44870fd
--- /dev/null
+++ b/modules/dav/main/providers.c
@@ -0,0 +1,58 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr_pools.h"
+#include "apr_hash.h"
+#include "ap_provider.h"
+#include "mod_dav.h"
+
+#define DAV_PROVIDER_GROUP "dav"
+
+DAV_DECLARE(void) dav_register_provider(apr_pool_t *p, const char *name,
+                                        const dav_provider *provider)
+{
+    ap_register_provider(p, DAV_PROVIDER_GROUP, name, "0", provider);
+}
+
+DAV_DECLARE(const dav_provider *) dav_lookup_provider(const char *name)
+{
+    return ap_lookup_provider(DAV_PROVIDER_GROUP, name, "0");
+}
+
+DAV_DECLARE(void) dav_options_provider_register(apr_pool_t *p,
+                        const char *name,
+                        const dav_options_provider *provider)
+{
+    ap_register_provider(p, DAV_OPTIONS_EXTENSION_GROUP, name, "0", provider);
+}
+
+DAV_DECLARE(const dav_options_provider *) dav_get_options_providers(const char *name)
+{
+    return ap_lookup_provider(DAV_OPTIONS_EXTENSION_GROUP, name, "0");
+}
+
+
+DAV_DECLARE(void) dav_resource_type_provider_register(apr_pool_t *p,
+                          const char *name,
+                          const dav_resource_type_provider *provider)
+{
+    ap_register_provider(p, DAV_RESOURCE_TYPE_GROUP, name, "0", provider);
+}
+
+DAV_DECLARE(const dav_resource_type_provider *) dav_get_resource_type_providers(const char *name)
+{
+    return ap_lookup_provider(DAV_RESOURCE_TYPE_GROUP, name, "0");
+}
diff --git a/modules/dav/main/std_liveprop.c b/modules/dav/main/std_liveprop.c
new file mode 100644
index 0000000..e760c65
--- /dev/null
+++ b/modules/dav/main/std_liveprop.c
@@ -0,0 +1,226 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "httpd.h"
+#include "util_xml.h"
+#include "apr_strings.h"
+#include "ap_provider.h"
+
+#include "mod_dav.h"
+
+/* forward-declare */
+static const dav_hooks_liveprop dav_core_hooks_liveprop;
+
+/*
+** The namespace URIs that we use. There will only ever be "DAV:".
+*/
+static const char * const dav_core_namespace_uris[] =
+{
+    "DAV:",
+    NULL        /* sentinel */
+};
+
+/*
+** Define each of the core properties that this provider will handle.
+** Note that all of them are in the DAV: namespace, which has a
+** provider-local index of 0.
+*/
+static const dav_liveprop_spec dav_core_props[] =
+{
+    { 0, "comment",              DAV_PROPID_comment,              1 },
+    { 0, "creator-displayname",  DAV_PROPID_creator_displayname,  1 },
+    { 0, "displayname",          DAV_PROPID_displayname,          1 },
+    { 0, "resourcetype",         DAV_PROPID_resourcetype,         0 },
+    { 0, "source",               DAV_PROPID_source,               1 },
+
+    { 0 }        /* sentinel */
+};
+
+static const dav_liveprop_group dav_core_liveprop_group =
+{
+    dav_core_props,
+    dav_core_namespace_uris,
+    &dav_core_hooks_liveprop
+};
+
+static dav_prop_insert dav_core_insert_prop(const dav_resource *resource,
+                                            int propid, dav_prop_insert what,
+                                            apr_text_header *phdr)
+{
+    const char *value = NULL;
+    const char *s;
+    apr_pool_t *p = resource->pool;
+    const dav_liveprop_spec *info;
+    long global_ns;
+
+    switch (propid)
+    {
+    case DAV_PROPID_resourcetype:
+        { /* additional type info provided by external modules ? */
+            int i;
+
+            apr_array_header_t *extensions =
+                ap_list_provider_names(p, DAV_RESOURCE_TYPE_GROUP, "0");
+            ap_list_provider_names_t *entry =
+                (ap_list_provider_names_t *)extensions->elts;
+
+            for (i = 0; i < extensions->nelts; i++, entry++) {
+                const dav_resource_type_provider *res_hooks =
+                    dav_get_resource_type_providers(entry->provider_name);
+                const char *name = NULL, *uri = NULL;
+
+                if (!res_hooks || !res_hooks->get_resource_type)
+                    continue;
+
+                if (!res_hooks->get_resource_type(resource, &name, &uri) &&
+                    name) {
+
+                    if (!uri || !strcasecmp(uri, "DAV:"))
+                        value = apr_pstrcat(p, value ? value : "",
+                                            "<D:", name, "/>", NULL);
+                    else
+                        value = apr_pstrcat(p, value ? value : "",
+                                            "<x:", name,
+                                            " xmlns:x=\"", uri,
+                                            "\"/>", NULL);
+                }
+            }
+        }
+        switch (resource->type) {
+        case DAV_RESOURCE_TYPE_VERSION:
+            if (resource->baselined) {
+                value = apr_pstrcat(p, value ? value : "", "<D:baseline/>", NULL);
+                break;
+            }
+            /* fall through */
+        case DAV_RESOURCE_TYPE_REGULAR:
+        case DAV_RESOURCE_TYPE_WORKING:
+            if (resource->collection) {
+                value = apr_pstrcat(p, value ? value : "", "<D:collection/>", NULL);
+            }
+            else {
+                /* ### should we denote lock-null resources? */
+                if (value == NULL) {
+                    value = "";        /* becomes: <D:resourcetype/> */
+                }
+            }
+            break;
+        case DAV_RESOURCE_TYPE_HISTORY:
+            value = apr_pstrcat(p, value ? value : "", "<D:version-history/>", NULL);
+            break;
+        case DAV_RESOURCE_TYPE_WORKSPACE:
+            value = apr_pstrcat(p, value ? value : "", "<D:collection/>", NULL);
+            break;
+        case DAV_RESOURCE_TYPE_ACTIVITY:
+            value = apr_pstrcat(p, value ? value : "", "<D:activity/>", NULL);
+            break;
+
+        default:
+            /* ### bad juju */
+            return DAV_PROP_INSERT_NOTDEF;
+        }
+        break;
+
+    case DAV_PROPID_comment:
+    case DAV_PROPID_creator_displayname:
+    case DAV_PROPID_displayname:
+    case DAV_PROPID_source:
+    default:
+        /*
+        ** This property is known, but not defined as a liveprop. However,
+        ** it may be a dead property.
+        */
+        return DAV_PROP_INSERT_NOTDEF;
+    }
+
+    /* assert: value != NULL */
+
+    /* get the information and global NS index for the property */
+    global_ns = dav_get_liveprop_info(propid, &dav_core_liveprop_group, &info);
+
+    /* assert: info != NULL && info->name != NULL */
+
+    if (what == DAV_PROP_INSERT_SUPPORTED) {
+        s = apr_psprintf(p,
+                         "<D:supported-live-property D:name=\"%s\" "
+                         "D:namespace=\"%s\"/>" DEBUG_CR,
+                         info->name, dav_core_namespace_uris[info->ns]);
+    }
+    else if (what == DAV_PROP_INSERT_VALUE && *value != '\0') {
+        s = apr_psprintf(p, "<lp%ld:%s>%s</lp%ld:%s>" DEBUG_CR,
+                         global_ns, info->name, value, global_ns, info->name);
+    }
+    else {
+        s = apr_psprintf(p, "<lp%ld:%s/>" DEBUG_CR, global_ns, info->name);
+    }
+    apr_text_append(p, phdr, s);
+
+    /* we inserted what was asked for */
+    return what;
+}
+
+static int dav_core_is_writable(const dav_resource *resource, int propid)
+{
+    const dav_liveprop_spec *info;
+
+    (void) dav_get_liveprop_info(propid, &dav_core_liveprop_group, &info);
+    return info->is_writable;
+}
+
+static dav_error * dav_core_patch_validate(const dav_resource *resource,
+                                           const apr_xml_elem *elem,
+                                           int operation, void **context,
+                                           int *defer_to_dead)
+{
+    /* all of our writable props go in the dead prop database */
+    *defer_to_dead = 1;
+
+    return NULL;
+}
+
+static const dav_hooks_liveprop dav_core_hooks_liveprop = {
+    dav_core_insert_prop,
+    dav_core_is_writable,
+    dav_core_namespace_uris,
+    dav_core_patch_validate,
+    NULL,       /* patch_exec */
+    NULL,       /* patch_commit */
+    NULL,       /* patch_rollback */
+};
+
+DAV_DECLARE_NONSTD(int) dav_core_find_liveprop(
+    const dav_resource *resource,
+    const char *ns_uri, const char *name,
+    const dav_hooks_liveprop **hooks)
+{
+    return dav_do_find_liveprop(ns_uri, name, &dav_core_liveprop_group, hooks);
+}
+
+DAV_DECLARE_NONSTD(void) dav_core_insert_all_liveprops(
+    request_rec *r,
+    const dav_resource *resource,
+    dav_prop_insert what,
+    apr_text_header *phdr)
+{
+    (void) dav_core_insert_prop(resource, DAV_PROPID_resourcetype,
+                                what, phdr);
+}
+
+DAV_DECLARE_NONSTD(void) dav_core_register_uris(apr_pool_t *p)
+{
+    /* register the namespace URIs */
+    dav_register_liveprop_group(p, &dav_core_liveprop_group);
+}
diff --git a/modules/dav/main/util.c b/modules/dav/main/util.c
new file mode 100644
index 0000000..9f24604
--- /dev/null
+++ b/modules/dav/main/util.c
@@ -0,0 +1,2152 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+** DAV extension module for Apache 2.0.*
+**  - various utilities, repository-independent
+*/
+
+#include "apr_strings.h"
+#include "apr_lib.h"
+
+#define APR_WANT_STRFUNC
+#include "apr_want.h"
+
+#include "mod_dav.h"
+
+#include "http_request.h"
+#include "http_config.h"
+#include "http_vhost.h"
+#include "http_log.h"
+#include "http_protocol.h"
+
+DAV_DECLARE(dav_error*) dav_new_error(apr_pool_t *p, int status, int error_id,
+                                      apr_status_t aprerr, const char *desc)
+{
+    dav_error *err = apr_pcalloc(p, sizeof(*err));
+
+    /* DBG3("dav_new_error: %d %d %s", status, error_id, desc ? desc : "(no desc)"); */
+
+    err->status = status;
+    err->error_id = error_id;
+    err->desc = desc;
+    err->aprerr = aprerr;
+
+    return err;
+}
+
+DAV_DECLARE(dav_error*) dav_new_error_tag(apr_pool_t *p, int status,
+                                          int error_id, apr_status_t aprerr,
+                                          const char *desc,
+                                          const char *namespace,
+                                          const char *tagname)
+{
+    dav_error *err = dav_new_error(p, status, error_id, aprerr, desc);
+
+    err->tagname = tagname;
+    err->namespace = namespace;
+
+    return err;
+}
+
+
+DAV_DECLARE(dav_error*) dav_push_error(apr_pool_t *p, int status,
+                                       int error_id, const char *desc,
+                                       dav_error *prev)
+{
+    dav_error *err = apr_pcalloc(p, sizeof(*err));
+
+    err->status = status;
+    err->error_id = error_id;
+    err->desc = desc;
+    err->prev = prev;
+
+    return err;
+}
+
+DAV_DECLARE(dav_error*) dav_join_error(dav_error *dest, dav_error *src)
+{
+    dav_error *curr = dest;
+
+    /* src error doesn't exist so nothing to join just return dest */
+    if (src == NULL) {
+        return dest;
+    }
+
+    /* dest error doesn't exist so nothing to join just return src */
+    if (curr == NULL) {
+        return src;
+    }
+
+    /* find last error in dest stack */
+    while (curr->prev != NULL) {
+        curr = curr->prev;
+    }
+
+    /* add the src error onto end of dest stack and return it */
+    curr->prev = src;
+    return dest;
+}
+
+DAV_DECLARE(void) dav_check_bufsize(apr_pool_t * p, dav_buffer *pbuf,
+                                    apr_size_t extra_needed)
+{
+    /* grow the buffer if necessary */
+    if (pbuf->cur_len + extra_needed > pbuf->alloc_len) {
+        char *newbuf;
+
+        pbuf->alloc_len += extra_needed + DAV_BUFFER_PAD;
+        newbuf = apr_palloc(p, pbuf->alloc_len);
+        memcpy(newbuf, pbuf->buf, pbuf->cur_len);
+        pbuf->buf = newbuf;
+    }
+}
+
+DAV_DECLARE(void) dav_set_bufsize(apr_pool_t * p, dav_buffer *pbuf,
+                                  apr_size_t size)
+{
+    /* NOTE: this does not retain prior contents */
+
+    /* NOTE: this function is used to init the first pointer, too, since
+       the PAD will be larger than alloc_len (0) for zeroed structures */
+
+    /* grow if we don't have enough for the requested size plus padding */
+    if (size + DAV_BUFFER_PAD > pbuf->alloc_len) {
+        /* set the new length; min of MINSIZE */
+        pbuf->alloc_len = size + DAV_BUFFER_PAD;
+        if (pbuf->alloc_len < DAV_BUFFER_MINSIZE)
+            pbuf->alloc_len = DAV_BUFFER_MINSIZE;
+
+        pbuf->buf = apr_palloc(p, pbuf->alloc_len);
+    }
+    pbuf->cur_len = size;
+}
+
+
+/* initialize a buffer and copy the specified (null-term'd) string into it */
+DAV_DECLARE(void) dav_buffer_init(apr_pool_t *p, dav_buffer *pbuf,
+                                  const char *str)
+{
+    dav_set_bufsize(p, pbuf, strlen(str));
+    memcpy(pbuf->buf, str, pbuf->cur_len + 1);
+}
+
+/* append a string to the end of the buffer, adjust length */
+DAV_DECLARE(void) dav_buffer_append(apr_pool_t *p, dav_buffer *pbuf,
+                                    const char *str)
+{
+    apr_size_t len = strlen(str);
+
+    dav_check_bufsize(p, pbuf, len + 1);
+    memcpy(pbuf->buf + pbuf->cur_len, str, len + 1);
+    pbuf->cur_len += len;
+}
+
+/* place a string on the end of the buffer, do NOT adjust length */
+DAV_DECLARE(void) dav_buffer_place(apr_pool_t *p, dav_buffer *pbuf,
+                                   const char *str)
+{
+    apr_size_t len = strlen(str);
+
+    dav_check_bufsize(p, pbuf, len + 1);
+    memcpy(pbuf->buf + pbuf->cur_len, str, len + 1);
+}
+
+/* place some memory on the end of a buffer; do NOT adjust length */
+DAV_DECLARE(void) dav_buffer_place_mem(apr_pool_t *p, dav_buffer *pbuf,
+                                       const void *mem, apr_size_t amt,
+                                       apr_size_t pad)
+{
+    dav_check_bufsize(p, pbuf, amt + pad);
+    memcpy(pbuf->buf + pbuf->cur_len, mem, amt);
+}
+
+/*
+** dav_lookup_uri()
+**
+** Extension for ap_sub_req_lookup_uri() which can't handle absolute
+** URIs properly.
+**
+** If NULL is returned, then an error occurred with parsing the URI or
+** the URI does not match the current server.
+*/
+DAV_DECLARE(dav_lookup_result) dav_lookup_uri(const char *uri,
+                                              request_rec * r,
+                                              int must_be_absolute)
+{
+    dav_lookup_result result = { 0 };
+    const char *scheme;
+    apr_port_t port;
+    apr_uri_t comp;
+    char *new_file;
+    const char *domain;
+
+    /* first thing to do is parse the URI into various components */
+    if (apr_uri_parse(r->pool, uri, &comp) != APR_SUCCESS) {
+        result.err.status = HTTP_BAD_REQUEST;
+        result.err.desc = "Invalid syntax in Destination URI.";
+        return result;
+    }
+
+    /* the URI must be an absoluteURI (WEBDAV S9.3) */
+    if (comp.scheme == NULL && must_be_absolute) {
+        result.err.status = HTTP_BAD_REQUEST;
+        result.err.desc = "Destination URI must be an absolute URI.";
+        return result;
+    }
+
+    /* the URI must not have a query (args) or a fragment */
+    if (comp.query != NULL || comp.fragment != NULL) {
+        result.err.status = HTTP_BAD_REQUEST;
+        result.err.desc =
+            "Destination URI contains invalid components "
+            "(a query or a fragment).";
+        return result;
+    }
+
+    /* If the scheme or port was provided, then make sure that it matches
+       the scheme/port of this request. If the request must be absolute,
+       then require the (explicit/implicit) scheme/port be matching.
+
+       ### hmm. if a port wasn't provided (does the parse return port==0?),
+       ### but we're on a non-standard port, then we won't detect that the
+       ### URI's port implies the wrong one.
+    */
+    if (comp.scheme != NULL || comp.port != 0 || must_be_absolute)
+    {
+        /* ### not sure this works if the current request came in via https: */
+        scheme = r->parsed_uri.scheme;
+        if (scheme == NULL)
+            scheme = ap_http_scheme(r);
+
+        /* insert a port if the URI did not contain one */
+        if (comp.port == 0)
+            comp.port = apr_uri_port_of_scheme(comp.scheme);
+
+        /* now, verify that the URI uses the same scheme as the current.
+           request. the port must match our port.
+        */
+        port = r->connection->local_addr->port;
+        if (strcasecmp(comp.scheme, scheme) != 0
+#ifdef APACHE_PORT_HANDLING_IS_BUSTED
+            || comp.port != port
+#endif
+            ) {
+            result.err.status = HTTP_BAD_GATEWAY;
+            result.err.desc = apr_psprintf(r->pool,
+                                           "Destination URI refers to "
+                                           "different scheme or port "
+                                           "(%s://hostname:%d)" APR_EOL_STR
+                                           "(want: %s://hostname:%d)",
+                                           comp.scheme ? comp.scheme : scheme,
+                                           comp.port ? comp.port : port,
+                                           scheme, port);
+            return result;
+        }
+    }
+
+    /* we have verified the scheme, port, and general structure */
+
+    /*
+    ** Hrm.  IE5 will pass unqualified hostnames for both the
+    ** Host: and Destination: headers.  This breaks the
+    ** http_vhost.c::matches_aliases function.
+    **
+    ** For now, qualify unqualified comp.hostnames with
+    ** r->server->server_hostname.
+    **
+    ** ### this is a big hack. Apache should provide a better way.
+    ** ### maybe the admin should list the unqualified hosts in a
+    ** ### <ServerAlias> block?
+    */
+    if (comp.hostname != NULL
+        && strrchr(comp.hostname, '.') == NULL
+        && (domain = strchr(r->server->server_hostname, '.')) != NULL) {
+        comp.hostname = apr_pstrcat(r->pool, comp.hostname, domain, NULL);
+    }
+
+    /* now, if a hostname was provided, then verify that it represents the
+       same server as the current connection. note that we just use our
+       port, since we've verified the URI matches ours */
+#ifdef APACHE_PORT_HANDLING_IS_BUSTED
+    if (comp.hostname != NULL &&
+        !ap_matches_request_vhost(r, comp.hostname, port)) {
+        result.err.status = HTTP_BAD_GATEWAY;
+        result.err.desc = "Destination URI refers to a different server.";
+        return result;
+    }
+#endif
+
+    /* we have verified that the requested URI denotes the same server as
+       the current request. Therefore, we can use ap_sub_req_lookup_uri() */
+
+    /* reconstruct a URI as just the path */
+    new_file = apr_uri_unparse(r->pool, &comp, APR_URI_UNP_OMITSITEPART);
+
+    /*
+     * Lookup the URI and return the sub-request. Note that we use the
+     * same HTTP method on the destination. This allows the destination
+     * to apply appropriate restrictions (e.g. readonly).
+     */
+    result.rnew = ap_sub_req_method_uri(r->method, new_file, r, NULL);
+
+    return result;
+}
+
+/* ---------------------------------------------------------------
+**
+** XML UTILITY FUNCTIONS
+*/
+
+/* validate that the root element uses a given DAV: tagname (TRUE==valid) */
+DAV_DECLARE(int) dav_validate_root(const apr_xml_doc *doc,
+                                   const char *tagname)
+{
+    return doc->root &&
+        doc->root->ns == APR_XML_NS_DAV_ID &&
+        strcmp(doc->root->name, tagname) == 0;
+}
+
+/* find and return the (unique) child with a given DAV: tagname */
+DAV_DECLARE(apr_xml_elem *) dav_find_child(const apr_xml_elem *elem,
+                                           const char *tagname)
+{
+    apr_xml_elem *child = elem->first_child;
+
+    for (; child; child = child->next)
+        if (child->ns == APR_XML_NS_DAV_ID && !strcmp(child->name, tagname))
+            return child;
+    return NULL;
+}
+
+/* gather up all the CDATA into a single string */
+DAV_DECLARE(const char *) dav_xml_get_cdata(const apr_xml_elem *elem, apr_pool_t *pool,
+                              int strip_white)
+{
+    apr_size_t len = 0;
+    apr_text *scan;
+    const apr_xml_elem *child;
+    char *cdata;
+    char *s;
+    apr_size_t tlen;
+    const char *found_text = NULL; /* initialize to avoid gcc warning */
+    int found_count = 0;
+
+    for (scan = elem->first_cdata.first; scan != NULL; scan = scan->next) {
+        found_text = scan->text;
+        ++found_count;
+        len += strlen(found_text);
+    }
+
+    for (child = elem->first_child; child != NULL; child = child->next) {
+        for (scan = child->following_cdata.first;
+             scan != NULL;
+             scan = scan->next) {
+            found_text = scan->text;
+            ++found_count;
+            len += strlen(found_text);
+        }
+    }
+
+    /* some fast-path cases:
+     * 1) zero-length cdata
+     * 2) a single piece of cdata with no whitespace to strip
+     */
+    if (len == 0)
+        return "";
+    if (found_count == 1) {
+        if (!strip_white
+            || (!apr_isspace(*found_text)
+                && !apr_isspace(found_text[len - 1])))
+            return found_text;
+    }
+
+    cdata = s = apr_palloc(pool, len + 1);
+
+    for (scan = elem->first_cdata.first; scan != NULL; scan = scan->next) {
+        tlen = strlen(scan->text);
+        memcpy(s, scan->text, tlen);
+        s += tlen;
+    }
+
+    for (child = elem->first_child; child != NULL; child = child->next) {
+        for (scan = child->following_cdata.first;
+             scan != NULL;
+             scan = scan->next) {
+            tlen = strlen(scan->text);
+            memcpy(s, scan->text, tlen);
+            s += tlen;
+        }
+    }
+
+    *s = '\0';
+
+    if (strip_white) {
+        /* trim leading whitespace */
+        while (apr_isspace(*cdata)) {     /* assume: return false for '\0' */
+            ++cdata;
+            --len;
+        }
+
+        /* trim trailing whitespace */
+        while (len-- > 0 && apr_isspace(cdata[len]))
+            continue;
+        cdata[len + 1] = '\0';
+    }
+
+    return cdata;
+}
+
+DAV_DECLARE(dav_xmlns_info *) dav_xmlns_create(apr_pool_t *pool)
+{
+    dav_xmlns_info *xi = apr_pcalloc(pool, sizeof(*xi));
+
+    xi->pool = pool;
+    xi->uri_prefix = apr_hash_make(pool);
+    xi->prefix_uri = apr_hash_make(pool);
+
+    return xi;
+}
+
+DAV_DECLARE(void) dav_xmlns_add(dav_xmlns_info *xi,
+                                const char *prefix, const char *uri)
+{
+    /* this "should" not overwrite a prefix mapping */
+    apr_hash_set(xi->prefix_uri, prefix, APR_HASH_KEY_STRING, uri);
+
+    /* note: this may overwrite an existing URI->prefix mapping, but it
+       doesn't matter -- any prefix is usable to specify the URI. */
+    apr_hash_set(xi->uri_prefix, uri, APR_HASH_KEY_STRING, prefix);
+}
+
+DAV_DECLARE(const char *) dav_xmlns_add_uri(dav_xmlns_info *xi,
+                                            const char *uri)
+{
+    const char *prefix;
+
+    if ((prefix = apr_hash_get(xi->uri_prefix, uri,
+                               APR_HASH_KEY_STRING)) != NULL)
+        return prefix;
+
+    prefix = apr_psprintf(xi->pool, "g%d", xi->count++);
+    dav_xmlns_add(xi, prefix, uri);
+    return prefix;
+}
+
+DAV_DECLARE(const char *) dav_xmlns_get_uri(dav_xmlns_info *xi,
+                                            const char *prefix)
+{
+    return apr_hash_get(xi->prefix_uri, prefix, APR_HASH_KEY_STRING);
+}
+
+DAV_DECLARE(const char *) dav_xmlns_get_prefix(dav_xmlns_info *xi,
+                                               const char *uri)
+{
+    return apr_hash_get(xi->uri_prefix, uri, APR_HASH_KEY_STRING);
+}
+
+DAV_DECLARE(void) dav_xmlns_generate(dav_xmlns_info *xi,
+                                     apr_text_header *phdr)
+{
+    apr_hash_index_t *hi = apr_hash_first(xi->pool, xi->prefix_uri);
+
+    for (; hi != NULL; hi = apr_hash_next(hi)) {
+        const void *prefix;
+        void *uri;
+        const char *s;
+
+        apr_hash_this(hi, &prefix, NULL, &uri);
+
+        s = apr_psprintf(xi->pool, " xmlns:%s=\"%s\"",
+                         (const char *)prefix, (const char *)uri);
+        apr_text_append(xi->pool, phdr, s);
+    }
+}
+
+/* ---------------------------------------------------------------
+**
+** Timeout header processing
+**
+*/
+
+/* dav_get_timeout:  If the Timeout: header exists, return a time_t
+ *    when this lock is expected to expire.  Otherwise, return
+ *    a time_t of DAV_TIMEOUT_INFINITE.
+ *
+ *    It's unclear if DAV clients are required to understand
+ *    Seconds-xxx and Infinity time values.  We assume that they do.
+ *    In addition, for now, that's all we understand, too.
+ */
+DAV_DECLARE(time_t) dav_get_timeout(request_rec *r)
+{
+    time_t now, expires = DAV_TIMEOUT_INFINITE;
+
+    const char *timeout_const = apr_table_get(r->headers_in, "Timeout");
+    const char *timeout = apr_pstrdup(r->pool, timeout_const), *val;
+
+    if (timeout == NULL)
+        return DAV_TIMEOUT_INFINITE;
+
+    /* Use the first thing we understand, or infinity if
+     * we don't understand anything.
+     */
+
+    while ((val = ap_getword_white(r->pool, &timeout)) && strlen(val)) {
+        if (!strncmp(val, "Infinite", 8)) {
+            return DAV_TIMEOUT_INFINITE;
+        }
+
+        if (!strncmp(val, "Second-", 7)) {
+            val += 7;
+            /* ### We need to handle overflow better:
+             * ### timeout will be <= 2^32 - 1
+             */
+            expires = atol(val);
+            now     = time(NULL);
+            return now + expires;
+        }
+    }
+
+    return DAV_TIMEOUT_INFINITE;
+}
+
+/* ---------------------------------------------------------------
+**
+** If Header processing
+**
+*/
+
+/* add_if_resource returns a new if_header, linking it to next_ih.
+ */
+static dav_if_header *dav_add_if_resource(apr_pool_t *p, dav_if_header *next_ih,
+                                          const char *uri, apr_size_t uri_len)
+{
+    dav_if_header *ih;
+
+    if ((ih = apr_pcalloc(p, sizeof(*ih))) == NULL)
+        return NULL;
+
+    ih->uri = uri;
+    ih->uri_len = uri_len;
+    ih->next = next_ih;
+
+    return ih;
+}
+
+/* add_if_state adds a condition to an if_header.
+ */
+static dav_error * dav_add_if_state(apr_pool_t *p, dav_if_header *ih,
+                                    const char *state_token,
+                                    dav_if_state_type t, int condition,
+                                    const dav_hooks_locks *locks_hooks)
+{
+    dav_if_state_list *new_sl;
+
+    new_sl = apr_pcalloc(p, sizeof(*new_sl));
+
+    new_sl->condition = condition;
+    new_sl->type      = t;
+
+    if (t == dav_if_opaquelock) {
+        dav_error *err;
+
+        if ((err = (*locks_hooks->parse_locktoken)(p, state_token,
+                                                   &new_sl->locktoken)) != NULL) {
+            /* If the state token cannot be parsed, treat it as an
+             * unknown state; this will evaluate to "false" later
+             * during If header validation. */
+            if (err->error_id == DAV_ERR_LOCK_UNK_STATE_TOKEN) {
+                new_sl->type = dav_if_unknown;
+            }
+            else {
+                /* ### maybe add a higher-level description */
+                return err;
+            }
+        }
+    }
+    else
+        new_sl->etag = state_token;
+
+    new_sl->next = ih->state;
+    ih->state = new_sl;
+
+    return NULL;
+}
+
+/* fetch_next_token returns the substring from str+1
+ * to the next occurrence of char term, or \0, whichever
+ * occurs first.  Leading whitespace is ignored.
+ */
+static char *dav_fetch_next_token(char **str, char term)
+{
+    char *sp;
+    char *token;
+
+    token = *str + 1;
+
+    while (*token && (*token == ' ' || *token == '\t'))
+        token++;
+
+    if ((sp = strchr(token, term)) == NULL)
+        return NULL;
+
+    *sp = '\0';
+    *str = sp;
+    return token;
+}
+
+/* dav_process_if_header:
+ *
+ *   If NULL (no error) is returned, then **if_header points to the
+ *   "If" productions structure (or NULL if "If" is not present).
+ *
+ *   ### this part is bogus:
+ *   If an error is encountered, the error is logged.  Parent should
+ *   return err->status.
+ */
+static dav_error * dav_process_if_header(request_rec *r, dav_if_header **p_ih)
+{
+    dav_error *err;
+    char *str;
+    char *list;
+    const char *state_token;
+    const char *uri = NULL;        /* scope of current production; NULL=no-tag */
+    apr_size_t uri_len = 0;
+    apr_status_t rv;
+    dav_if_header *ih = NULL;
+    apr_uri_t parsed_uri;
+    const dav_hooks_locks *locks_hooks = DAV_GET_HOOKS_LOCKS(r);
+    enum {no_tagged, tagged, unknown} list_type = unknown;
+    int condition;
+
+    *p_ih = NULL;
+
+    if ((str = apr_pstrdup(r->pool, apr_table_get(r->headers_in, "If"))) == NULL)
+        return NULL;
+
+    while (*str) {
+        switch(*str) {
+        case '<':
+            /* Tagged-list production - following states apply to this uri */
+            if (list_type == no_tagged
+                || ((uri = dav_fetch_next_token(&str, '>')) == NULL)) {
+                return dav_new_error(r->pool, HTTP_BAD_REQUEST,
+                                     DAV_ERR_IF_TAGGED, 0,
+                                     "Invalid If-header: unclosed \"<\" or "
+                                     "unexpected tagged-list production.");
+            }
+
+            /* 2518 specifies this must be an absolute URI; just take the
+             * relative part for later comparison against r->uri */
+            if ((rv = apr_uri_parse(r->pool, uri, &parsed_uri)) != APR_SUCCESS
+                || !parsed_uri.path) {
+                return dav_new_error(r->pool, HTTP_BAD_REQUEST,
+                                     DAV_ERR_IF_TAGGED, rv,
+                                     "Invalid URI in tagged If-header.");
+            }
+            /* note that parsed_uri.path is allocated; we can trash it */
+
+            /* clean up the URI a bit */
+            ap_getparents(parsed_uri.path);
+
+            /* the resources we will compare to have unencoded paths */
+            if (ap_unescape_url(parsed_uri.path) != OK) {
+                return dav_new_error(r->pool, HTTP_BAD_REQUEST,
+                                     DAV_ERR_IF_TAGGED, rv,
+                                     "Invalid percent encoded URI in "
+                                     "tagged If-header.");
+            }
+
+            uri_len = strlen(parsed_uri.path);
+            if (uri_len > 1 && parsed_uri.path[uri_len - 1] == '/') {
+                parsed_uri.path[--uri_len] = '\0';
+            }
+
+            uri = parsed_uri.path;
+            list_type = tagged;
+            break;
+
+        case '(':
+            /* List production */
+
+            /* If a uri has not been encountered, this is a No-Tagged-List */
+            if (list_type == unknown)
+                list_type = no_tagged;
+
+            if ((list = dav_fetch_next_token(&str, ')')) == NULL) {
+                return dav_new_error(r->pool, HTTP_BAD_REQUEST,
+                                     DAV_ERR_IF_UNCLOSED_PAREN, 0,
+                                     "Invalid If-header: unclosed \"(\".");
+            }
+
+            if ((ih = dav_add_if_resource(r->pool, ih, uri, uri_len)) == NULL) {
+                /* ### dav_add_if_resource() should return an error for us! */
+                return dav_new_error(r->pool, HTTP_BAD_REQUEST,
+                                     DAV_ERR_IF_PARSE, 0,
+                                     "Internal server error parsing \"If:\" "
+                                     "header.");
+            }
+
+            condition = DAV_IF_COND_NORMAL;
+
+            while (*list) {
+                /* List is the entire production (in a uri scope) */
+
+                switch (*list) {
+                case '<':
+                    if ((state_token = dav_fetch_next_token(&list, '>')) == NULL) {
+                        /* ### add a description to this error */
+                        return dav_new_error(r->pool, HTTP_BAD_REQUEST,
+                                             DAV_ERR_IF_PARSE, 0, NULL);
+                    }
+
+                    if ((err = dav_add_if_state(r->pool, ih, state_token, dav_if_opaquelock,
+                                                condition, locks_hooks)) != NULL) {
+                        /* ### maybe add a higher level description */
+                        return err;
+                    }
+                    condition = DAV_IF_COND_NORMAL;
+                    break;
+
+                case '[':
+                    if ((state_token = dav_fetch_next_token(&list, ']')) == NULL) {
+                        /* ### add a description to this error */
+                        return dav_new_error(r->pool, HTTP_BAD_REQUEST,
+                                             DAV_ERR_IF_PARSE, 0, NULL);
+                    }
+
+                    if ((err = dav_add_if_state(r->pool, ih, state_token, dav_if_etag,
+                                                condition, locks_hooks)) != NULL) {
+                        /* ### maybe add a higher level description */
+                        return err;
+                    }
+                    condition = DAV_IF_COND_NORMAL;
+                    break;
+
+                case 'N':
+                    if (list[1] == 'o' && list[2] == 't') {
+                        if (condition != DAV_IF_COND_NORMAL) {
+                            return dav_new_error(r->pool, HTTP_BAD_REQUEST,
+                                                 DAV_ERR_IF_MULTIPLE_NOT, 0,
+                                                 "Invalid \"If:\" header: "
+                                                 "Multiple \"not\" entries "
+                                                 "for the same state.");
+                        }
+                        condition = DAV_IF_COND_NOT;
+                    }
+                    list += 2;
+                    break;
+
+                case ' ':
+                case '\t':
+                    break;
+
+                default:
+                    return dav_new_error(r->pool, HTTP_BAD_REQUEST,
+                                         DAV_ERR_IF_UNK_CHAR, 0,
+                                         apr_psprintf(r->pool,
+                                                     "Invalid \"If:\" "
+                                                     "header: Unexpected "
+                                                     "character encountered "
+                                                     "(0x%02x, '%c').",
+                                                     *list, *list));
+                }
+
+                list++;
+            }
+            break;
+
+        case ' ':
+        case '\t':
+            break;
+
+        default:
+            return dav_new_error(r->pool, HTTP_BAD_REQUEST,
+                                 DAV_ERR_IF_UNK_CHAR, 0,
+                                 apr_psprintf(r->pool,
+                                             "Invalid \"If:\" header: "
+                                             "Unexpected character "
+                                             "encountered (0x%02x, '%c').",
+                                             *str, *str));
+        }
+
+        str++;
+    }
+
+    *p_ih = ih;
+    return NULL;
+}
+
+static int dav_find_submitted_locktoken(const dav_if_header *if_header,
+                                        const dav_lock *lock_list,
+                                        const dav_hooks_locks *locks_hooks)
+{
+    for (; if_header != NULL; if_header = if_header->next) {
+        const dav_if_state_list *state_list;
+
+        for (state_list = if_header->state;
+             state_list != NULL;
+             state_list = state_list->next) {
+
+            if (state_list->type == dav_if_opaquelock) {
+                const dav_lock *lock;
+
+                /* given state_list->locktoken, match it */
+
+                /*
+                ** The resource will have one or more lock tokens. We only
+                ** need to match one of them against any token in the
+                ** If: header.
+                **
+                ** One token case: It is an exclusive or shared lock. Either
+                **                 way, we must find it.
+                **
+                ** N token case: They are shared locks. By policy, we need
+                **               to match only one. The resource's other
+                **               tokens may belong to somebody else (so we
+                **               shouldn't see them in the If: header anyway)
+                */
+                for (lock = lock_list; lock != NULL; lock = lock->next) {
+
+                    if (!(*locks_hooks->compare_locktoken)(state_list->locktoken, lock->locktoken)) {
+                        return 1;
+                    }
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+/* dav_validate_resource_state:
+ *    Returns NULL if path/uri meets if-header and lock requirements
+ */
+static dav_error * dav_validate_resource_state(apr_pool_t *p,
+                                               const dav_resource *resource,
+                                               dav_lockdb *lockdb,
+                                               const dav_if_header *if_header,
+                                               int flags,
+                                               dav_buffer *pbuf,
+                                               request_rec *r)
+{
+    dav_error *err;
+    const char *uri;
+    const char *etag;
+    const dav_hooks_locks *locks_hooks = (lockdb ? lockdb->hooks : NULL);
+    const dav_if_header *ifhdr_scan;
+    dav_if_state_list *state_list;
+    dav_lock *lock_list;
+    dav_lock *lock;
+    int num_matched;
+    int num_that_apply;
+    int seen_locktoken;
+    apr_size_t uri_len;
+    const char *reason = NULL;
+
+    /* DBG1("validate: <%s>", resource->uri); */
+
+    /*
+    ** The resource will have one of three states:
+    **
+    ** 1) No locks. We have no special requirements that the user supply
+    **    specific locktokens. One of the state lists must match, and
+    **    we're done.
+    **
+    ** 2) One exclusive lock. The locktoken must appear *anywhere* in the
+    **    If: header. Of course, asserting the token in a "Not" term will
+    **    quickly fail that state list :-). If the locktoken appears in
+    **    one of the state lists *and* one state list matches, then we're
+    **    done.
+    **
+    ** 3) One or more shared locks. One of the locktokens must appear
+    **    *anywhere* in the If: header. If one of the locktokens appears,
+    **    and we match one state list, then we are done.
+    **
+    ** The <seen_locktoken> variable determines whether we have seen one
+    ** of this resource's locktokens in the If: header.
+    */
+
+    /*
+    ** If this is a new lock request, <flags> will contain the requested
+    ** lock scope.  Three rules apply:
+    **
+    ** 1) Do not require a (shared) locktoken to be seen (when we are
+    **    applying another shared lock)
+    ** 2) If the scope is exclusive and we see any locks, fail.
+    ** 3) If the scope is shared and we see an exclusive lock, fail.
+    */
+
+    if (lockdb == NULL) {
+        /* we're in State 1. no locks. */
+        lock_list = NULL;
+    }
+    else {
+        /*
+        ** ### hrm... we don't need to have these fully
+        ** ### resolved since we're only looking at the
+        ** ### locktokens...
+        **
+        ** ### use get_locks w/ calltype=PARTIAL
+        */
+        if ((err = dav_lock_query(lockdb, resource, &lock_list)) != NULL) {
+            return dav_push_error(p,
+                                  HTTP_INTERNAL_SERVER_ERROR, 0,
+                                  "The locks could not be queried for "
+                                  "verification against a possible \"If:\" "
+                                  "header.",
+                                  err);
+        }
+
+        /* lock_list now determines whether we're in State 1, 2, or 3. */
+    }
+
+    /*
+    ** For a new, exclusive lock: if any locks exist, fail.
+    ** For a new, shared lock:    if an exclusive lock exists, fail.
+    **                            else, do not require a token to be seen.
+    */
+    if (flags & DAV_LOCKSCOPE_EXCLUSIVE) {
+        if (lock_list != NULL) {
+            return dav_new_error(p, HTTP_LOCKED, 0, 0,
+                                 "Existing lock(s) on the requested resource "
+                                 "prevent an exclusive lock.");
+        }
+
+        /*
+        ** There are no locks, so we can pretend that we've already met
+        ** any requirement to find the resource's locks in an If: header.
+        */
+        seen_locktoken = 1;
+    }
+    else if (flags & DAV_LOCKSCOPE_SHARED) {
+        /*
+        ** Strictly speaking, we don't need this loop. Either the first
+        ** (and only) lock will be EXCLUSIVE, or none of them will be.
+        */
+        for (lock = lock_list; lock != NULL; lock = lock->next) {
+            if (lock->scope == DAV_LOCKSCOPE_EXCLUSIVE) {
+                return dav_new_error(p, HTTP_LOCKED, 0, 0,
+                                     "The requested resource is already "
+                                     "locked exclusively.");
+            }
+        }
+
+        /*
+        ** The locks on the resource (if any) are all shared. Set the
+        ** <seen_locktoken> flag to indicate that we do not need to find
+        ** the locks in an If: header.
+        */
+        seen_locktoken = 1;
+    }
+    else {
+        /*
+        ** For methods other than LOCK:
+        **
+        ** If we have no locks or if the resource is not being modified
+        ** (per RFC 4918 the lock token is not required on resources
+        ** we are not changing), then <seen_locktoken> can be set to true --
+        ** pretending that we've already met the requirement of seeing one
+        ** of the resource's locks in the If: header.
+        **
+        ** Otherwise, it must be cleared and we'll look for one.
+        */
+        seen_locktoken = (lock_list == NULL
+                          || flags & DAV_VALIDATE_NO_MODIFY);
+    }
+
+    /*
+    ** If there is no If: header, then we can shortcut some logic:
+    **
+    ** 1) if we do not need to find a locktoken in the (non-existent) If:
+    **    header, then we are successful.
+    **
+    ** 2) if we must find a locktoken in the (non-existent) If: header, then
+    **    we fail.
+    */
+    if (if_header == NULL) {
+        if (seen_locktoken)
+            return NULL;
+
+        return dav_new_error(p, HTTP_LOCKED, 0, 0,
+                             "This resource is locked and an \"If:\" header "
+                             "was not supplied to allow access to the "
+                             "resource.");
+    }
+    /* the If: header is present */
+
+    /*
+    ** If a dummy header is present (because of a Lock-Token: header), then
+    ** we are required to find that token in this resource's set of locks.
+    ** If we have no locks, then we immediately fail.
+    **
+    ** This is a 400 (Bad Request) since they should only submit a locktoken
+    ** that actually exists.
+    **
+    ** Don't issue this response if we're talking about the parent resource.
+    ** It is okay for that resource to NOT have this locktoken.
+    ** (in fact, it certainly will not: a dummy_header only occurs for the
+    **  UNLOCK method, the parent is checked only for locknull resources,
+    **  and the parent certainly does not have the (locknull's) locktoken)
+    */
+    if (lock_list == NULL && if_header->dummy_header) {
+        if (flags & DAV_VALIDATE_IS_PARENT)
+            return NULL;
+        return dav_new_error(p, HTTP_BAD_REQUEST, 0, 0,
+                             "The locktoken specified in the \"Lock-Token:\" "
+                             "header is invalid because this resource has no "
+                             "outstanding locks.");
+    }
+
+    /*
+    ** Prepare the input URI. We want the URI to never have a trailing slash.
+    **
+    ** When URIs are placed into the dav_if_header structure, they are
+    ** guaranteed to never have a trailing slash. If the URIs are equivalent,
+    ** then it doesn't matter if they both lack a trailing slash -- they're
+    ** still equivalent.
+    **
+    ** Note: we could also ensure that a trailing slash is present on both
+    ** URIs, but the majority of URIs provided to us via a resource walk
+    ** will not contain that trailing slash.
+    */
+    uri = resource->uri;
+    uri_len = strlen(uri);
+    if (uri[uri_len - 1] == '/') {
+        dav_set_bufsize(p, pbuf, uri_len);
+        memcpy(pbuf->buf, uri, uri_len);
+        pbuf->buf[--uri_len] = '\0';
+        uri = pbuf->buf;
+    }
+
+    /* get the resource's etag; we may need it during the checks */
+    etag = (*resource->hooks->getetag)(resource);
+
+    /* how many state_lists apply to this URI? */
+    num_that_apply = 0;
+
+    /* If there are if-headers, fail if this resource
+     * does not match at least one state_list.
+     */
+    for (ifhdr_scan = if_header;
+         ifhdr_scan != NULL;
+         ifhdr_scan = ifhdr_scan->next) {
+
+        /* DBG2("uri=<%s>  if_uri=<%s>", uri, ifhdr_scan->uri ? ifhdr_scan->uri : "(no uri)"); */
+
+        if (ifhdr_scan->uri != NULL
+            && (uri_len != ifhdr_scan->uri_len
+                || memcmp(uri, ifhdr_scan->uri, uri_len) != 0)) {
+            /*
+            ** A tagged-list's URI doesn't match this resource's URI.
+            ** Skip to the next state_list to see if it will match.
+            */
+            continue;
+        }
+
+        /* this state_list applies to this resource */
+
+        /*
+        ** ### only one state_list should ever apply! a no-tag, or a tagged
+        ** ### where S9.4.2 states only one can match.
+        **
+        ** ### revamp this code to loop thru ifhdr_scan until we find the
+        ** ### matching state_list. process it. stop.
+        */
+        ++num_that_apply;
+
+        /* To succeed, resource must match *all* of the states
+         * specified in the state_list.
+         */
+        for (state_list = ifhdr_scan->state;
+             state_list != NULL;
+             state_list = state_list->next) {
+
+            switch(state_list->type) {
+            case dav_if_etag:
+            {
+                const char *given_etag, *current_etag;
+                int mismatch;
+
+                /* Do a weak entity comparison function as defined in
+                 * RFC 2616 13.3.3.
+                 */
+                if (state_list->etag[0] == 'W' &&
+                    state_list->etag[1] == '/') {
+                    given_etag = state_list->etag + 2;
+                }
+                else {
+                    given_etag = state_list->etag;
+                }
+                if (etag[0] == 'W' &&
+                    etag[1] == '/') {
+                    current_etag = etag + 2;
+                }
+                else {
+                    current_etag = etag;
+                }
+
+                mismatch = strcmp(given_etag, current_etag);
+
+                if (state_list->condition == DAV_IF_COND_NORMAL && mismatch) {
+                    /*
+                    ** The specified entity-tag does not match the
+                    ** entity-tag on the resource. This state_list is
+                    ** not going to match. Bust outta here.
+                    */
+                    reason =
+                        "an entity-tag was specified, but the resource's "
+                        "actual ETag does not match.";
+                    goto state_list_failed;
+                }
+                else if (state_list->condition == DAV_IF_COND_NOT
+                         && !mismatch) {
+                    /*
+                    ** The specified entity-tag DOES match the
+                    ** entity-tag on the resource. This state_list is
+                    ** not going to match. Bust outta here.
+                    */
+                    reason =
+                        "an entity-tag was specified using the \"Not\" form, "
+                        "but the resource's actual ETag matches the provided "
+                        "entity-tag.";
+                    goto state_list_failed;
+                }
+                break;
+            }
+
+            case dav_if_opaquelock:
+                if (lockdb == NULL) {
+                    if (state_list->condition == DAV_IF_COND_NOT) {
+                        /* the locktoken is definitely not there! (success) */
+                        continue;
+                    }
+
+                    /* condition == DAV_IF_COND_NORMAL */
+
+                    /*
+                    ** If no lockdb is provided, then validation fails for
+                    ** this state_list (NORMAL means we were supposed to
+                    ** find the token, which we obviously cannot do without
+                    ** a lock database).
+                    **
+                    ** Go and try the next state list.
+                    */
+                    reason =
+                        "a State-token was supplied, but a lock database "
+                        "is not available for to provide the required lock.";
+                    goto state_list_failed;
+                }
+
+                /* Resource validation 'fails' if:
+                 *    ANY  of the lock->locktokens match
+                 *         a NOT state_list->locktoken,
+                 * OR
+                 *    NONE of the lock->locktokens match
+                 *         a NORMAL state_list->locktoken.
+                 */
+                num_matched = 0;
+                for (lock = lock_list; lock != NULL; lock = lock->next) {
+
+                    /*
+                    DBG2("compare: rsrc=%s  ifhdr=%s",
+                         (*locks_hooks->format_locktoken)(p, lock->locktoken),
+                         (*locks_hooks->format_locktoken)(p, state_list->locktoken));
+                    */
+
+                    /* nothing to do if the locktokens do not match. */
+                    if ((*locks_hooks->compare_locktoken)(state_list->locktoken, lock->locktoken)) {
+                        continue;
+                    }
+
+                    /*
+                    ** We have now matched up one of the resource's locktokens
+                    ** to a locktoken in a State-token in the If: header.
+                    ** Note this fact, so that we can pass the overall
+                    ** requirement of seeing at least one of the resource's
+                    ** locktokens.
+                    */
+                    seen_locktoken = 1;
+
+                    if (state_list->condition == DAV_IF_COND_NOT) {
+                        /*
+                        ** This state requires that the specified locktoken
+                        ** is NOT present on the resource. But we just found
+                        ** it. There is no way this state-list can now
+                        ** succeed, so go try another one.
+                        */
+                        reason =
+                            "a State-token was supplied, which used a "
+                            "\"Not\" condition. The State-token was found "
+                            "in the locks on this resource";
+                        goto state_list_failed;
+                    }
+
+                    /* condition == DAV_IF_COND_NORMAL */
+
+                    /* Validate auth_user:  If an authenticated user created
+                    ** the lock, only the same user may submit that locktoken
+                    ** to manipulate a resource.
+                    */
+                    if (lock->auth_user &&
+                        (!r->user ||
+                         strcmp(lock->auth_user, r->user))) {
+                        const char *errmsg;
+
+                        errmsg = apr_pstrcat(p, "User \"",
+                                            r->user,
+                                            "\" submitted a locktoken created "
+                                            "by user \"",
+                                            lock->auth_user, "\".", NULL);
+                        return dav_new_error(p, HTTP_FORBIDDEN, 0, 0, errmsg);
+                    }
+
+                    /*
+                    ** We just matched a specified State-Token to one of the
+                    ** resource's locktokens.
+                    **
+                    ** Break out of the lock scan -- we only needed to find
+                    ** one match (actually, there shouldn't be any other
+                    ** matches in the lock list).
+                    */
+                    num_matched = 1;
+                    break;
+                }
+
+                if (num_matched == 0
+                    && state_list->condition == DAV_IF_COND_NORMAL) {
+                    /*
+                    ** We had a NORMAL state, meaning that we should have
+                    ** found the State-Token within the locks on this
+                    ** resource. We didn't, so this state_list must fail.
+                    */
+                    reason =
+                        "a State-token was supplied, but it was not found "
+                        "in the locks on this resource.";
+                    goto state_list_failed;
+                }
+
+                break;
+
+            case dav_if_unknown:
+                /* Request is predicated on some unknown state token,
+                 * which must be presumed to *not* match, so fail
+                 * unless this is a Not condition. */
+
+                if (state_list->condition == DAV_IF_COND_NORMAL) {
+                    reason =
+                        "an unknown state token was supplied";
+                    goto state_list_failed;
+                }
+                break;
+
+            } /* switch */
+        } /* foreach ( state_list ) */
+
+        /*
+        ** We've checked every state in this state_list and none of them
+        ** have failed. Since all of them succeeded, then we have a matching
+        ** state list and we may be done.
+        **
+        ** The next requirement is that we have seen one of the resource's
+        ** locktokens (if any). If we have, then we can just exit. If we
+        ** haven't, then we need to keep looking.
+        */
+        if (seen_locktoken) {
+            /* woo hoo! */
+            return NULL;
+        }
+
+        /*
+        ** Haven't seen one. Let's break out of the search and just look
+        ** for a matching locktoken.
+        */
+        break;
+
+        /*
+        ** This label is used when we detect that a state_list is not
+        ** going to match this resource. We bust out and try the next
+        ** state_list.
+        */
+      state_list_failed:
+        ;
+
+    } /* foreach ( ifhdr_scan ) */
+
+    /*
+    ** The above loop exits for one of two reasons:
+    **   1) a state_list matched and seen_locktoken is false.
+    **   2) all if_header structures were scanned, without (1) occurring
+    */
+
+    if (ifhdr_scan == NULL) {
+        /*
+        ** We finished the loop without finding any matching state lists.
+        */
+
+        /*
+        ** If none of the state_lists apply to this resource, then we
+        ** may have succeeded. Note that this scenario implies a
+        ** tagged-list with no matching state_lists. If the If: header
+        ** was a no-tag-list, then it would have applied to this resource.
+        **
+        ** S9.4.2 states that when no state_lists apply, then the header
+        ** should be ignored.
+        **
+        ** If we saw one of the resource's locktokens, then we're done.
+        ** If we did not see a locktoken, then we fail.
+        */
+        if (num_that_apply == 0) {
+            if (seen_locktoken)
+                return NULL;
+
+            /*
+            ** We may have aborted the scan before seeing the locktoken.
+            ** Rescan the If: header to see if we can find the locktoken
+            ** somewhere.
+            **
+            ** Note that seen_locktoken == 0 implies lock_list != NULL
+            ** which implies locks_hooks != NULL.
+            */
+            if (dav_find_submitted_locktoken(if_header, lock_list,
+                                             locks_hooks)) {
+                /*
+                ** We found a match! We're set... none of the If: header
+                ** assertions apply (implicit success), and the If: header
+                ** specified the locktoken somewhere. We're done.
+                */
+                return NULL;
+            }
+
+            return dav_new_error(p, HTTP_LOCKED, 0 /* error_id */, 0,
+                                 "This resource is locked and the \"If:\" "
+                                 "header did not specify one of the "
+                                 "locktokens for this resource's lock(s).");
+        }
+        /* else: one or more state_lists were applicable, but failed. */
+
+        /*
+        ** If the dummy_header did not match, then they specified an
+        ** incorrect token in the Lock-Token header. Forget whether the
+        ** If: statement matched or not... we'll tell them about the
+        ** bad Lock-Token first. That is considered a 400 (Bad Request).
+        */
+        if (if_header->dummy_header) {
+            return dav_new_error(p, HTTP_BAD_REQUEST, 0, 0,
+                                 "The locktoken specified in the "
+                                 "\"Lock-Token:\" header did not specify one "
+                                 "of this resource's locktoken(s).");
+        }
+
+        if (reason == NULL) {
+            return dav_new_error(p, HTTP_PRECONDITION_FAILED, 0, 0,
+                                 "The preconditions specified by the \"If:\" "
+                                 "header did not match this resource.");
+        }
+
+        return dav_new_error(p, HTTP_PRECONDITION_FAILED, 0, 0,
+                             apr_psprintf(p,
+                                         "The precondition(s) specified by "
+                                         "the \"If:\" header did not match "
+                                         "this resource. At least one "
+                                         "failure is because: %s", reason));
+    }
+
+    /* assert seen_locktoken == 0 */
+
+    /*
+    ** ifhdr_scan != NULL implies we found a matching state_list.
+    **
+    ** Since we're still here, it also means that we have not yet found
+    ** one the resource's locktokens in the If: header.
+    **
+    ** Scan all the if_headers and states looking for one of this
+    ** resource's locktokens. Note that we need to go back and scan them
+    ** all -- we may have aborted a scan with a failure before we saw a
+    ** matching token.
+    **
+    ** Note that seen_locktoken == 0 implies lock_list != NULL which implies
+    ** locks_hooks != NULL.
+    */
+    if (dav_find_submitted_locktoken(if_header, lock_list, locks_hooks)) {
+        /*
+        ** We found a match! We're set... we have a matching state list,
+        ** and the If: header specified the locktoken somewhere. We're done.
+        */
+        return NULL;
+    }
+
+    /*
+    ** We had a matching state list, but the user agent did not specify one
+    ** of this resource's locktokens. Tell them so.
+    **
+    ** Note that we need to special-case the message on whether a "dummy"
+    ** header exists. If it exists, yet we didn't see a needed locktoken,
+    ** then that implies the dummy header (Lock-Token header) did NOT
+    ** specify one of this resource's locktokens. (this implies something
+    ** in the real If: header matched)
+    **
+    ** We want to note the 400 (Bad Request) in favor of a 423 (Locked).
+    */
+    if (if_header->dummy_header) {
+        return dav_new_error(p, HTTP_BAD_REQUEST, 0, 0,
+                             "The locktoken specified in the "
+                             "\"Lock-Token:\" header did not specify one "
+                             "of this resource's locktoken(s).");
+    }
+
+    return dav_new_error(p, HTTP_LOCKED, 1 /* error_id */, 0,
+                         "This resource is locked and the \"If:\" header "
+                         "did not specify one of the "
+                         "locktokens for this resource's lock(s).");
+}
+
+/* dav_validate_walker:  Walker callback function to validate resource state */
+static dav_error * dav_validate_walker(dav_walk_resource *wres, int calltype)
+{
+    dav_walker_ctx *ctx = wres->walk_ctx;
+    dav_error *err;
+
+    if ((err = dav_validate_resource_state(ctx->w.pool, wres->resource,
+                                           ctx->w.lockdb,
+                                           ctx->if_header, ctx->flags,
+                                           &ctx->work_buf, ctx->r)) == NULL) {
+        /* There was no error, so just bug out. */
+        return NULL;
+    }
+
+    /*
+    ** If we have a serious server error, or if the request itself failed,
+    ** then just return error (not a multistatus).
+    */
+    if (ap_is_HTTP_SERVER_ERROR(err->status)
+        || (*wres->resource->hooks->is_same_resource)(wres->resource,
+                                                      ctx->w.root)) {
+        /* ### maybe push a higher-level description? */
+        return err;
+    }
+
+    /* associate the error with the current URI */
+    dav_add_response(wres, err->status, NULL);
+
+    return NULL;
+}
+
+/* If-* header checking */
+static int dav_meets_conditions(request_rec *r, int resource_state)
+{
+    const char *if_match, *if_none_match;
+    int retVal;
+
+    /* If-Match '*' fix. Resource existence not checked by ap_meets_conditions.
+     * If-Match '*' request should succeed only if the resource exists. */
+    if ((if_match = apr_table_get(r->headers_in, "If-Match")) != NULL) {
+        if (if_match[0] == '*' && resource_state != DAV_RESOURCE_EXISTS)
+            return HTTP_PRECONDITION_FAILED;
+    }
+
+    retVal = ap_meets_conditions(r);
+
+    /* If-None-Match '*' fix. If-None-Match '*' request should succeed
+     * if the resource does not exist. */
+    if (retVal == HTTP_PRECONDITION_FAILED) {
+        /* Note. If if_none_match != NULL, if_none_match is the culprit.
+         * Since, in presence of If-None-Match,
+         * other If-* headers are undefined. */
+        if ((if_none_match =
+            apr_table_get(r->headers_in, "If-None-Match")) != NULL) {
+            if (if_none_match[0] == '*'
+                && resource_state != DAV_RESOURCE_EXISTS) {
+                return OK;
+            }
+        }
+    }
+
+    return retVal;
+}
+
+/*
+** dav_validate_request:  Validate if-headers (and check for locks) on:
+**    (1) r->filename @ depth;
+**    (2) Parent of r->filename if check_parent == 1
+**
+** The check of parent should be done when it is necessary to verify that
+** the parent collection will accept a new member (ie current resource
+** state is null).
+**
+** Return OK on successful validation.
+** On error, return appropriate HTTP_* code, and log error. If a multi-stat
+** error is necessary, response will point to it, else NULL.
+*/
+DAV_DECLARE(dav_error *) dav_validate_request(request_rec *r,
+                                              dav_resource *resource,
+                                              int depth,
+                                              dav_locktoken *locktoken,
+                                              dav_response **response,
+                                              int flags,
+                                              dav_lockdb *lockdb)
+{
+    dav_error *err;
+    int result;
+    dav_if_header *if_header;
+    int lock_db_opened_locally = 0;
+    const dav_hooks_locks *locks_hooks = DAV_GET_HOOKS_LOCKS(r);
+    const dav_hooks_repository *repos_hooks = resource->hooks;
+    dav_buffer work_buf = { 0 };
+    dav_response *new_response;
+    int resource_state;
+    const char *etag;
+    int set_etag = 0;
+
+#if DAV_DEBUG
+    if (depth && response == NULL) {
+        /*
+        ** ### bleck. we can't return errors for other URIs unless we have
+        ** ### a "response" ptr.
+        */
+        return dav_new_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                             "DESIGN ERROR: dav_validate_request called "
+                             "with depth>0, but no response ptr.");
+    }
+#endif
+
+    if (response != NULL)
+        *response = NULL;
+
+    /* Set the ETag header required by dav_meets_conditions() */
+    etag = apr_table_get(r->headers_out, "ETag");
+    if (!etag) {
+        etag = (*resource->hooks->getetag)(resource);
+        if (etag && *etag) {
+            apr_table_set(r->headers_out, "ETag", etag);
+            set_etag = 1;
+        }
+    }
+    /* Do the standard checks for conditional requests using
+     * If-..-Since, If-Match etc */
+    resource_state = dav_get_resource_state(r, resource);
+    result = dav_meets_conditions(r, resource_state);
+    if (set_etag) {
+        /*
+         * If we have set an ETag to headers out above for
+         * dav_meets_conditions() revert this here as we do not want to set
+         * the ETag in responses to requests with methods where this might not
+         * be desired.
+         */
+        apr_table_unset(r->headers_out, "ETag");
+    }
+    if (result != OK) {
+        return dav_new_error(r->pool, result, 0, 0, NULL);
+    }
+
+    /* always parse (and later process) the If: header */
+    if ((err = dav_process_if_header(r, &if_header)) != NULL) {
+        /* ### maybe add higher-level description */
+        return err;
+    }
+
+    /* If a locktoken was specified, create a dummy if_header with which
+     * to validate resources.  In the interim, figure out why DAV uses
+     * locktokens in an if-header without a Lock-Token header to refresh
+     * locks, but a Lock-Token header without an if-header to remove them.
+     */
+    if (locktoken != NULL) {
+        dav_if_header *ifhdr_new;
+
+        ifhdr_new = apr_pcalloc(r->pool, sizeof(*ifhdr_new));
+        ifhdr_new->uri = resource->uri;
+        ifhdr_new->uri_len = strlen(resource->uri);
+        ifhdr_new->dummy_header = 1;
+
+        ifhdr_new->state = apr_pcalloc(r->pool, sizeof(*ifhdr_new->state));
+        ifhdr_new->state->type = dav_if_opaquelock;
+        ifhdr_new->state->condition = DAV_IF_COND_NORMAL;
+        ifhdr_new->state->locktoken = locktoken;
+
+        ifhdr_new->next = if_header;
+        if_header = ifhdr_new;
+    }
+
+    /*
+    ** If necessary, open the lock database (read-only, lazily);
+    ** the validation process may need to retrieve or update lock info.
+    ** Otherwise, assume provided lockdb is valid and opened rw.
+    */
+    if (lockdb == NULL) {
+        if (locks_hooks != NULL) {
+            if ((err = (*locks_hooks->open_lockdb)(r, 0, 0, &lockdb)) != NULL) {
+                /* ### maybe insert higher-level comment */
+                return err;
+            }
+            lock_db_opened_locally = 1;
+        }
+    }
+
+    /* (1) Validate the specified resource, at the specified depth.
+     * Avoid the walk there is no if_header and we aren't planning
+     * to modify this resource. */
+    if (resource->exists && depth > 0 && !(!if_header && flags & DAV_VALIDATE_NO_MODIFY)) {
+        dav_walker_ctx ctx = { { 0 } };
+        dav_response *multi_status;
+
+        ctx.w.walk_type = DAV_WALKTYPE_NORMAL;
+        ctx.w.func = dav_validate_walker;
+        ctx.w.walk_ctx = &ctx;
+        ctx.w.pool = r->pool;
+        ctx.w.root = resource;
+
+        ctx.if_header = if_header;
+        ctx.r = r;
+        ctx.flags = flags;
+
+        if (lockdb != NULL) {
+            ctx.w.lockdb = lockdb;
+            ctx.w.walk_type |= DAV_WALKTYPE_LOCKNULL;
+        }
+
+        err = (*repos_hooks->walk)(&ctx.w, DAV_INFINITY, &multi_status);
+        if (err == NULL) {
+            *response = multi_status;
+        }
+        /* else: implies a 5xx status code occurred. */
+    }
+    else {
+        err = dav_validate_resource_state(r->pool, resource, lockdb,
+                                          if_header, flags, &work_buf, r);
+    }
+
+    /* (2) Validate the parent resource if requested */
+    if (err == NULL && (flags & DAV_VALIDATE_PARENT)) {
+        dav_resource *parent_resource;
+
+        err = (*repos_hooks->get_parent_resource)(resource, &parent_resource);
+
+        if (err == NULL && parent_resource == NULL) {
+            err = dav_new_error(r->pool, HTTP_FORBIDDEN, 0, 0,
+                                "Cannot access parent of repository root.");
+        }
+        else if (err == NULL) {
+            err = dav_validate_resource_state(r->pool, parent_resource, lockdb,
+                                              if_header,
+                                              flags | DAV_VALIDATE_IS_PARENT,
+                                              &work_buf, r);
+
+            /*
+            ** This error occurred on the parent resource. This implies that
+            ** we have to create a multistatus response (to report the error
+            ** against a URI other than the Request-URI). "Convert" this error
+            ** into a multistatus response.
+            */
+            if (err != NULL) {
+                new_response = apr_pcalloc(r->pool, sizeof(*new_response));
+
+                new_response->href = parent_resource->uri;
+                new_response->status = err->status;
+                new_response->desc =
+                    "A validation error has occurred on the parent resource, "
+                    "preventing the operation on the resource specified by "
+                    "the Request-URI.";
+                if (err->desc != NULL) {
+                    new_response->desc = apr_pstrcat(r->pool,
+                                                    new_response->desc,
+                                                    " The error was: ",
+                                                    err->desc, NULL);
+                }
+
+                /* assert: DAV_VALIDATE_PARENT implies response != NULL */
+                new_response->next = *response;
+                *response = new_response;
+
+                err = NULL;
+            }
+        }
+    }
+
+    if (lock_db_opened_locally)
+        (*locks_hooks->close_lockdb)(lockdb);
+
+    /*
+    ** If we don't have a (serious) error, and we have multistatus responses,
+    ** then we need to construct an "error". This error will be the overall
+    ** status returned, and the multistatus responses will go into its body.
+    **
+    ** For certain methods, the overall error will be a 424. The default is
+    ** to construct a standard 207 response.
+    */
+    if (err == NULL && response != NULL && *response != NULL) {
+        apr_text *propstat = NULL;
+
+        if ((flags & DAV_VALIDATE_USE_424) != 0) {
+            /* manufacture a 424 error to hold the multistatus response(s) */
+            return dav_new_error(r->pool, HTTP_FAILED_DEPENDENCY, 0, 0,
+                                 "An error occurred on another resource, "
+                                 "preventing the requested operation on "
+                                 "this resource.");
+        }
+
+        /*
+        ** Whatever caused the error, the Request-URI should have a 424
+        ** associated with it since we cannot complete the method.
+        **
+        ** For a LOCK operation, insert an empty DAV:lockdiscovery property.
+        ** For other methods, return a simple 424.
+        */
+        if ((flags & DAV_VALIDATE_ADD_LD) != 0) {
+            propstat = apr_pcalloc(r->pool, sizeof(*propstat));
+            propstat->text =
+                "<D:propstat>" DEBUG_CR
+                "<D:prop><D:lockdiscovery/></D:prop>" DEBUG_CR
+                "<D:status>HTTP/1.1 424 Failed Dependency</D:status>" DEBUG_CR
+                "</D:propstat>" DEBUG_CR;
+        }
+
+        /* create the 424 response */
+        new_response = apr_pcalloc(r->pool, sizeof(*new_response));
+        new_response->href = resource->uri;
+        new_response->status = HTTP_FAILED_DEPENDENCY;
+        new_response->propresult.propstats = propstat;
+        new_response->desc =
+            "An error occurred on another resource, preventing the "
+            "requested operation on this resource.";
+
+        new_response->next = *response;
+        *response = new_response;
+
+        /* manufacture a 207 error for the multistatus response(s) */
+        return dav_new_error(r->pool, HTTP_MULTI_STATUS, 0, 0,
+                             "Error(s) occurred on resources during the "
+                             "validation process.");
+    }
+
+    return err;
+}
+
+/* dav_get_locktoken_list:
+ *
+ * Sets ltl to a locktoken_list of all positive locktokens in header,
+ * else NULL if no If-header, or no positive locktokens.
+ */
+DAV_DECLARE(dav_error *) dav_get_locktoken_list(request_rec *r,
+                                                dav_locktoken_list **ltl)
+{
+    dav_error *err;
+    dav_if_header *if_header;
+    dav_if_state_list *if_state;
+    dav_locktoken_list *lock_token = NULL;
+
+    *ltl = NULL;
+
+    if ((err = dav_process_if_header(r, &if_header)) != NULL) {
+        /* ### add a higher-level description? */
+        return err;
+    }
+
+    while (if_header != NULL) {
+        if_state = if_header->state;        /* Beginning of the if_state linked list */
+        while (if_state != NULL)        {
+            if (if_state->condition == DAV_IF_COND_NORMAL
+                && if_state->type == dav_if_opaquelock) {
+                lock_token = apr_pcalloc(r->pool, sizeof(dav_locktoken_list));
+                lock_token->locktoken = if_state->locktoken;
+                lock_token->next = *ltl;
+                *ltl = lock_token;
+            }
+            if_state = if_state->next;
+        }
+        if_header = if_header->next;
+    }
+    if (*ltl == NULL) {
+        /* No nodes added */
+        return dav_new_error(r->pool, HTTP_BAD_REQUEST, DAV_ERR_IF_ABSENT, 0,
+                             "No locktokens were specified in the \"If:\" "
+                             "header, so the refresh could not be performed.");
+    }
+
+    return NULL;
+}
+
+#if 0 /* not needed right now... */
+
+static const char *strip_white(const char *s, apr_pool_t *pool)
+{
+    apr_size_t idx;
+
+    /* trim leading whitespace */
+    while (apr_isspace(*s))     /* assume: return false for '\0' */
+        ++s;
+
+    /* trim trailing whitespace */
+    idx = strlen(s) - 1;
+    if (apr_isspace(s[idx])) {
+        char *s2 = apr_pstrdup(pool, s);
+
+        while (apr_isspace(s2[idx]) && idx > 0)
+            --idx;
+        s2[idx + 1] = '\0';
+        return s2;
+    }
+
+    return s;
+}
+#endif
+
+#define DAV_LABEL_HDR "Label"
+
+/* dav_add_vary_header
+ *
+ * If there were any headers in the request which require a Vary header
+ * in the response, add it.
+ */
+DAV_DECLARE(void) dav_add_vary_header(request_rec *in_req,
+                                      request_rec *out_req,
+                                      const dav_resource *resource)
+{
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(in_req);
+
+    /* ### this is probably all wrong... I think there is a function in
+       ### the Apache API to add things to the Vary header. need to check */
+
+    /* Only versioning headers require a Vary response header,
+     * so only do this check if there is a versioning provider */
+    if (vsn_hooks != NULL) {
+        const char *target = apr_table_get(in_req->headers_in, DAV_LABEL_HDR);
+
+        /* If Target-Selector specified, add it to the Vary header */
+        if (target != NULL) {
+            const char *vary = apr_table_get(out_req->headers_out, "Vary");
+
+            if (vary == NULL)
+                vary = DAV_LABEL_HDR;
+            else
+                vary = apr_pstrcat(out_req->pool, vary, "," DAV_LABEL_HDR,
+                                   NULL);
+
+            apr_table_setn(out_req->headers_out, "Vary", vary);
+        }
+    }
+}
+
+/* dav_can_auto_checkout
+ *
+ * Determine whether auto-checkout is enabled for a resource.
+ * r - the request_rec
+ * resource - the resource
+ * auto_version - the value of the auto_versionable hook for the resource
+ * lockdb - pointer to lock database (opened if necessary)
+ * auto_checkout - set to 1 if auto-checkout enabled
+ */
+static dav_error * dav_can_auto_checkout(
+    request_rec *r,
+    dav_resource *resource,
+    dav_auto_version auto_version,
+    dav_lockdb **lockdb,
+    int *auto_checkout)
+{
+    dav_error *err;
+    dav_lock *lock_list;
+
+    *auto_checkout = 0;
+
+    if (auto_version == DAV_AUTO_VERSION_ALWAYS) {
+        *auto_checkout = 1;
+    }
+    else if (auto_version == DAV_AUTO_VERSION_LOCKED) {
+        if (*lockdb == NULL) {
+            const dav_hooks_locks *locks_hooks = DAV_GET_HOOKS_LOCKS(r);
+
+            if (locks_hooks == NULL) {
+                return dav_new_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                                     "Auto-checkout is only enabled for locked resources, "
+                                     "but there is no lock provider.");
+            }
+
+            if ((err = (*locks_hooks->open_lockdb)(r, 0, 0, lockdb)) != NULL) {
+                return dav_push_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0,
+                                      "Cannot open lock database to determine "
+                                      "auto-versioning behavior.",
+                                      err);
+            }
+        }
+
+        if ((err = dav_lock_query(*lockdb, resource, &lock_list)) != NULL) {
+            return dav_push_error(r->pool,
+                                  HTTP_INTERNAL_SERVER_ERROR, 0,
+                                  "The locks could not be queried for "
+                                  "determining auto-versioning behavior.",
+                                  err);
+        }
+
+        if (lock_list != NULL)
+            *auto_checkout = 1;
+    }
+
+    return NULL;
+}
+
+/* see mod_dav.h for docco */
+DAV_DECLARE(dav_error *) dav_auto_checkout(
+    request_rec *r,
+    dav_resource *resource,
+    int parent_only,
+    dav_auto_version_info *av_info)
+{
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    dav_lockdb *lockdb = NULL;
+    dav_error *err = NULL;
+
+    /* Initialize results */
+    memset(av_info, 0, sizeof(*av_info));
+
+    /* if no versioning provider, just return */
+    if (vsn_hooks == NULL)
+        return NULL;
+
+    /* check parent resource if requested or if resource must be created */
+    if (!resource->exists || parent_only) {
+        dav_resource *parent;
+
+        if ((err = (*resource->hooks->get_parent_resource)(resource,
+                                                           &parent)) != NULL)
+            goto done;
+
+        if (parent == NULL || !parent->exists) {
+            err = dav_new_error(r->pool, HTTP_CONFLICT, 0, 0,
+                                apr_psprintf(r->pool,
+                                            "Missing one or more intermediate "
+                                            "collections. Cannot create resource %s.",
+                                            ap_escape_html(r->pool, resource->uri)));
+            goto done;
+        }
+
+        av_info->parent_resource = parent;
+
+        /* if parent versioned and not checked out, see if it can be */
+        if (parent->versioned && !parent->working) {
+            int checkout_parent;
+
+            if ((err = dav_can_auto_checkout(r, parent,
+                                             (*vsn_hooks->auto_versionable)(parent),
+                                             &lockdb, &checkout_parent))
+                != NULL) {
+                goto done;
+            }
+
+            if (!checkout_parent) {
+                err = dav_new_error(r->pool, HTTP_CONFLICT, 0, 0,
+                                    "<DAV:cannot-modify-checked-in-parent>");
+                goto done;
+            }
+
+            /* Try to checkout the parent collection.
+             * Note that auto-versioning can only be applied to a version selector,
+             * so no separate working resource will be created.
+             */
+            if ((err = (*vsn_hooks->checkout)(parent, 1 /*auto_checkout*/,
+                                              0, 0, 0, NULL, NULL))
+                != NULL)
+            {
+                err = dav_push_error(r->pool, HTTP_CONFLICT, 0,
+                                     apr_psprintf(r->pool,
+                                                 "Unable to auto-checkout parent collection. "
+                                                 "Cannot create resource %s.",
+                                                 ap_escape_html(r->pool, resource->uri)),
+                                     err);
+                goto done;
+            }
+
+            /* remember that parent was checked out */
+            av_info->parent_checkedout = 1;
+        }
+    }
+
+    /* if only checking parent, we're done */
+    if (parent_only)
+        goto done;
+
+    /* if creating a new resource, see if it should be version-controlled */
+    if (!resource->exists
+        && (*vsn_hooks->auto_versionable)(resource) == DAV_AUTO_VERSION_ALWAYS) {
+
+        if ((err = (*vsn_hooks->vsn_control)(resource, NULL)) != NULL) {
+            err = dav_push_error(r->pool, HTTP_CONFLICT, 0,
+                                 apr_psprintf(r->pool,
+                                             "Unable to create versioned resource %s.",
+                                             ap_escape_html(r->pool, resource->uri)),
+                                 err);
+            goto done;
+        }
+
+        /* remember that resource was created */
+        av_info->resource_versioned = 1;
+    }
+
+    /* if resource is versioned, make sure it is checked out */
+    if (resource->versioned && !resource->working) {
+        int checkout_resource;
+
+        if ((err = dav_can_auto_checkout(r, resource,
+                                         (*vsn_hooks->auto_versionable)(resource),
+                                         &lockdb, &checkout_resource)) != NULL) {
+            goto done;
+        }
+
+        if (!checkout_resource) {
+            err = dav_new_error(r->pool, HTTP_CONFLICT, 0, 0,
+                                "<DAV:cannot-modify-version-controlled-content>");
+            goto done;
+        }
+
+        /* Auto-versioning can only be applied to version selectors, so
+         * no separate working resource will be created. */
+        if ((err = (*vsn_hooks->checkout)(resource, 1 /*auto_checkout*/,
+                                          0, 0, 0, NULL, NULL))
+            != NULL)
+        {
+            err = dav_push_error(r->pool, HTTP_CONFLICT, 0,
+                                 apr_psprintf(r->pool,
+                                             "Unable to checkout resource %s.",
+                                             ap_escape_html(r->pool, resource->uri)),
+                                 err);
+            goto done;
+        }
+
+        /* remember that resource was checked out */
+        av_info->resource_checkedout = 1;
+    }
+
+done:
+
+    /* make sure lock database is closed */
+    if (lockdb != NULL)
+        (*lockdb->hooks->close_lockdb)(lockdb);
+
+    /* if an error occurred, undo any auto-versioning operations already done */
+    if (err != NULL) {
+        dav_auto_checkin(r, resource, 1 /*undo*/, 0 /*unlock*/, av_info);
+        return err;
+    }
+
+    return NULL;
+}
+
+/* see mod_dav.h for docco */
+DAV_DECLARE(dav_error *) dav_auto_checkin(
+    request_rec *r,
+    dav_resource *resource,
+    int undo,
+    int unlock,
+    dav_auto_version_info *av_info)
+{
+    const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(r);
+    dav_error *err = NULL;
+    dav_auto_version auto_version;
+
+    /* If no versioning provider, this is a no-op */
+    if (vsn_hooks == NULL)
+        return NULL;
+
+    /* If undoing auto-checkouts, then do uncheckouts */
+    if (undo) {
+        if (resource != NULL) {
+            if (av_info->resource_checkedout) {
+                if ((err = (*vsn_hooks->uncheckout)(resource)) != NULL) {
+                    return dav_push_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0,
+                                          apr_psprintf(r->pool,
+                                                      "Unable to undo auto-checkout "
+                                                      "of resource %s.",
+                                                      ap_escape_html(r->pool, resource->uri)),
+                                          err);
+                }
+            }
+
+            if (av_info->resource_versioned) {
+                dav_response *response;
+
+                /* ### should we do anything with the response? */
+                if ((err = (*resource->hooks->remove_resource)(resource,
+                                                               &response)) != NULL) {
+                    return dav_push_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0,
+                                          apr_psprintf(r->pool,
+                                                      "Unable to undo auto-version-control "
+                                                      "of resource %s.",
+                                                      ap_escape_html(r->pool, resource->uri)),
+                                          err);
+                }
+            }
+        }
+
+        if (av_info->parent_resource != NULL && av_info->parent_checkedout) {
+            if ((err = (*vsn_hooks->uncheckout)(av_info->parent_resource)) != NULL) {
+                return dav_push_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0,
+                                      apr_psprintf(r->pool,
+                                                  "Unable to undo auto-checkout "
+                                                  "of parent collection %s.",
+                                                  ap_escape_html(r->pool, av_info->parent_resource->uri)),
+                                      err);
+            }
+        }
+
+        return NULL;
+    }
+
+    /* If the resource was checked out, and auto-checkin is enabled,
+     * then check it in.
+     */
+    if (resource != NULL && resource->working
+        && (unlock || av_info->resource_checkedout)) {
+
+        auto_version = (*vsn_hooks->auto_versionable)(resource);
+
+        if (auto_version == DAV_AUTO_VERSION_ALWAYS ||
+            (unlock && (auto_version == DAV_AUTO_VERSION_LOCKED))) {
+
+            if ((err = (*vsn_hooks->checkin)(resource,
+                                             0 /*keep_checked_out*/, NULL))
+                != NULL) {
+                return dav_push_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0,
+                                      apr_psprintf(r->pool,
+                                                  "Unable to auto-checkin resource %s.",
+                                                  ap_escape_html(r->pool, resource->uri)),
+                                      err);
+            }
+        }
+    }
+
+    /* If parent resource was checked out, and auto-checkin is enabled,
+     * then check it in.
+     */
+    if (!unlock
+        && av_info->parent_checkedout
+        && av_info->parent_resource != NULL
+        && av_info->parent_resource->working) {
+
+        auto_version = (*vsn_hooks->auto_versionable)(av_info->parent_resource);
+
+        if (auto_version == DAV_AUTO_VERSION_ALWAYS) {
+            if ((err = (*vsn_hooks->checkin)(av_info->parent_resource,
+                                             0 /*keep_checked_out*/, NULL))
+                != NULL) {
+                return dav_push_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0,
+                                      apr_psprintf(r->pool,
+                                                  "Unable to auto-checkin parent collection %s.",
+                                                  ap_escape_html(r->pool, av_info->parent_resource->uri)),
+                                                  err);
+            }
+        }
+    }
+
+    return NULL;
+}
diff --git a/modules/dav/main/util_lock.c b/modules/dav/main/util_lock.c
new file mode 100644
index 0000000..1b3a647
--- /dev/null
+++ b/modules/dav/main/util_lock.c
@@ -0,0 +1,798 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+** DAV repository-independent lock functions
+*/
+
+#include "apr.h"
+#include "apr_strings.h"
+
+#include "mod_dav.h"
+#include "http_log.h"
+#include "http_config.h"
+#include "http_protocol.h"
+#include "http_core.h"
+
+APLOG_USE_MODULE(dav);
+
+/* ---------------------------------------------------------------
+**
+** Property-related lock functions
+**
+*/
+
+/*
+** dav_lock_get_activelock:  Returns a <lockdiscovery> containing
+**    an activelock element for every item in the lock_discovery tree
+*/
+DAV_DECLARE(const char *) dav_lock_get_activelock(request_rec *r,
+                                                  dav_lock *lock,
+                                                  dav_buffer *pbuf)
+{
+    dav_lock *lock_scan;
+    const dav_hooks_locks *hooks = DAV_GET_HOOKS_LOCKS(r);
+    int count = 0;
+    dav_buffer work_buf = { 0 };
+    apr_pool_t *p = r->pool;
+
+    /* If no locks or no lock provider, there are no locks */
+    if (lock == NULL || hooks == NULL) {
+        /*
+        ** Since resourcediscovery is defined with (activelock)*,
+        ** <D:activelock/> shouldn't be necessary for an empty lock.
+        */
+        return "";
+    }
+
+    /*
+    ** Note: it could be interesting to sum the lengths of the owners
+    **       and locktokens during this loop. However, the buffer
+    **       mechanism provides some rough padding so that we don't
+    **       really need to have an exact size. Further, constructing
+    **       locktoken strings could be relatively expensive.
+    */
+    for (lock_scan = lock; lock_scan != NULL; lock_scan = lock_scan->next)
+        count++;
+
+    /* if a buffer was not provided, then use an internal buffer */
+    if (pbuf == NULL)
+        pbuf = &work_buf;
+
+    /* reset the length before we start appending stuff */
+    pbuf->cur_len = 0;
+
+    /* prep the buffer with a "good" size */
+    dav_check_bufsize(p, pbuf, count * 300);
+
+    for (; lock != NULL; lock = lock->next) {
+        char tmp[100];
+
+#if DAV_DEBUG
+        if (lock->rectype == DAV_LOCKREC_INDIRECT_PARTIAL) {
+            /* ### crap. design error */
+            dav_buffer_append(p, pbuf,
+                              "DESIGN ERROR: attempted to product an "
+                              "activelock element from a partial, indirect "
+                              "lock record. Creating an XML parsing error "
+                              "to ease detection of this situation: <");
+        }
+#endif
+
+        dav_buffer_append(p, pbuf, "<D:activelock>" DEBUG_CR "<D:locktype>");
+        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);
+        apr_snprintf(tmp, sizeof(tmp), "<D:depth>%s</D:depth>" DEBUG_CR,
+                     lock->depth == DAV_INFINITY ? "infinity" : "0");
+        dav_buffer_append(p, pbuf, tmp);
+
+        if (lock->owner) {
+            /*
+            ** This contains a complete, self-contained <DAV:owner> element,
+            ** with namespace declarations and xml:lang handling. Just drop
+            ** it in.
+            */
+            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);
+            
+            /*
+            ** Check if the timeout is not, for any reason, already elapsed.
+            ** (e.g., because of a large collection, or disk under heavy load...)
+             */
+            if (now >= lock->timeout) {
+                dav_buffer_append(p, pbuf, "Second-0");
+            }
+            else {
+                apr_snprintf(tmp, sizeof(tmp), "Second-%lu", (long unsigned int)(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_lock_parse_lockinfo:  Validates the given xml_doc to contain a
+**    lockinfo XML element, then populates a dav_lock structure
+**    with its contents.
+*/
+DAV_DECLARE(dav_error *) dav_lock_parse_lockinfo(request_rec *r,
+                                                 const dav_resource *resource,
+                                                 dav_lockdb *lockdb,
+                                                 const apr_xml_doc *doc,
+                                                 dav_lock **lock_request)
+{
+    apr_pool_t *p = r->pool;
+    dav_error *err;
+    apr_xml_elem *child;
+    dav_lock *lock;
+
+    if (!dav_validate_root(doc, "lockinfo")) {
+        return dav_new_error(p, HTTP_BAD_REQUEST, 0, 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, 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 */
+            apr_xml_quote_elem(p, child);
+
+            /*
+            ** Store a full <DAV:owner> element with namespace definitions
+            ** and an xml:lang definition, if applicable.
+            */
+            apr_xml_to_text(p, child, APR_XML_X2T_FULL_NS_LANG, doc->namespaces,
+                            NULL, &text, NULL);
+            lock->owner = text;
+
+            continue;
+        }
+
+        return dav_new_error(p, HTTP_PRECONDITION_FAILED, 0, 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;
+}
+
+/* ---------------------------------------------------------------
+**
+** General lock functions
+**
+*/
+
+/* dav_lock_walker:  Walker callback function to record indirect locks */
+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);
+
+        /*
+        ** ### actually, this is probably wrong: we want to fail the whole
+        ** ### LOCK process if something goes bad. maybe the caller should
+        ** ### do a dav_unlock() (e.g. a rollback) if any errors occurred.
+        */
+    }
+
+    return NULL;
+}
+
+/*
+** dav_add_lock:  Add a direct lock for resource, and indirect locks for
+**    all children, bounded by depth.
+**    ### assume request only contains one lock
+*/
+DAV_DECLARE(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:
+     *   Depth: 0   for null resource, existing resource, or existing collection
+     *   Depth: Inf for existing collection
+     */
+
+    /*
+    ** 2518 9.2 says to ignore depth if target is not a collection (it has
+    **   no internal children); pretend the client gave the correct depth.
+    */
+    if (!resource->collection) {
+        depth = 0;
+    }
+
+    /* In all cases, first add direct entry in lockdb */
+
+    /*
+    ** Append the new (direct) lock to the resource's existing locks.
+    **
+    ** Note: this also handles locknull resources
+    */
+    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, 0,
+                                 "Error(s) occurred on resources during the "
+                                 "addition of a depth lock.");
+        }
+    }
+
+    return NULL;
+}
+
+/*
+** dav_lock_query:  Opens the lock database. Returns a linked list of
+**    dav_lock structures for all direct locks on path.
+*/
+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);
+}
+
+/* dav_unlock_walker:  Walker callback function to remove indirect locks */
+static dav_error * dav_unlock_walker(dav_walk_resource *wres, int calltype)
+{
+    dav_walker_ctx *ctx = wres->walk_ctx;
+    dav_error *err;
+
+    /* Before removing the lock, do any auto-checkin required */
+    if (wres->resource->working) {
+        /* ### get rid of this typecast */
+        if ((err = dav_auto_checkin(ctx->r, (dav_resource *) wres->resource,
+                                    0 /*undo*/, 1 /*unlock*/, NULL))
+            != NULL) {
+            return 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;
+}
+
+/*
+** dav_get_direct_resource:
+**
+** Find a lock on the specified resource, then return the resource the
+** lock was applied to (in other words, given a (possibly) indirect lock,
+** return the direct lock's corresponding resource).
+**
+** If the lock is an indirect lock, this usually means traversing up the
+** namespace [repository] hierarchy. Note that some lock providers may be
+** able to return this information with a traversal.
+*/
+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-
+     * If r->filename's direct   locks include locktoken, use r->filename.
+     * If r->filename's indirect locks include locktoken, retry r->filename/..
+     * Else fail.
+     */
+    while (resource != NULL) {
+        dav_error *err;
+        dav_lock *lock;
+        dav_resource *parent;
+
+        /*
+        ** Find the lock specified by <locktoken> on <resource>. If it is
+        ** an indirect lock, then partial results are okay. We're just
+        ** trying to find the thing and know whether it is a direct or
+        ** an indirect 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, 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 */
+        if ((err = (*resource->hooks->get_parent_resource)(resource,
+                                                           &parent)) != NULL) {
+            /* ### add a higher-level desc? */
+            return err;
+        }
+        resource = parent;
+    }
+
+    return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                         "The lock database is corrupt. A direct lock could "
+                         "not be found for the corresponding indirect lock "
+                         "on this resource.");
+}
+
+/*
+** dav_unlock:  Removes all direct and indirect locks for r->filename,
+**    with given locktoken.  If locktoken == null_locktoken, all locks
+**    are removed.  If r->filename represents an indirect lock,
+**    we must unlock the appropriate direct lock.
+**    Returns OK or appropriate HTTP_* response and logs any errors.
+**
+** ### We've already crawled the tree to ensure everything was locked
+**     by us; there should be no need to incorporate a rollback.
+*/
+DAV_DECLARE(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_walker_ctx ctx = { { 0 } };
+    dav_response *multi_status;
+    dav_error *err;
+
+    /* If no locks provider, then there is nothing to unlock. */
+    if (hooks == NULL) {
+        return OK;
+    }
+
+    /* 2518 requires the entire lock to be removed if resource/locktoken
+     * point to an indirect lock.  We need resource of the _direct_
+     * lock in order to walk down the tree and remove the locks.  So,
+     * If locktoken != null_locktoken,
+     *    Walk up the resource hierarchy until we see a direct lock.
+     *    Or, we could get the direct lock's db/key, pick out the URL
+     *    and do a subrequest.  I think walking up is faster and will work
+     *    all the time.
+     * Else
+     *    Just start removing all locks at and below resource.
+     */
+
+    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
+     * the root of a depth > 0 lock, or locktoken is null.
+     */
+    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;
+
+    (*hooks->close_lockdb)(lockdb);
+
+    return result;
+}
+
+/* dav_inherit_walker:  Walker callback function to inherit locks */
+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);
+}
+
+/*
+** dav_inherit_locks:  When a resource or collection is added to a collection,
+**    locks on the collection should be inherited to the resource/collection.
+**    (MOVE, MKCOL, etc) Here we propagate any direct or indirect locks from
+**    parent of resource to resource and below.
+*/
+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) {
+        dav_resource *parent;
+        if ((err = (*repos_hooks->get_parent_resource)(resource,
+                                                       &parent)) != NULL) {
+            /* ### add a higher-level desc? */
+            return err;
+        }
+        if (parent == NULL) {
+            /* ### map result to something nice; log an error */
+            return dav_new_error(r->pool, HTTP_INTERNAL_SERVER_ERROR, 0, 0,
+                                 "Could not fetch parent resource. Unable to "
+                                 "inherit locks from the parent and apply "
+                                 "them to this resource.");
+        }
+        which_resource = parent;
+    }
+    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;
+    }
+
+    /*
+    ** (1) Copy all indirect locks from our parent;
+    ** (2) Create indirect locks for the depth infinity, direct locks
+    **     in our parent.
+    **
+    ** The append_locks call in the walker callback will do the indirect
+    ** conversion, but we need to remove any direct locks that are NOT
+    ** depth "infinity".
+    */
+    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);
+}
+
+/* ---------------------------------------------------------------
+**
+** Functions dealing with lock-null resources
+**
+*/
+
+/*
+** dav_get_resource_state:  Returns the state of the resource
+**    r->filename:  DAV_RESOURCE_NULL, DAV_RESOURCE_LOCK_NULL,
+**    or DAV_RESOURCE_EXIST.
+**
+**    Returns DAV_RESOURCE_ERROR if an error occurs.
+*/
+DAV_DECLARE(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;
+
+        /*
+        ** A locknull resource has the form:
+        **
+        **   known-dir "/" locknull-file
+        **
+        ** It would be nice to look into <resource> to verify this form,
+        ** but it does not have enough information for us. Instead, we
+        ** can look at the path_info. If the form does not match, then
+        ** there is no way we could have a locknull resource -- it must
+        ** be a plain, null resource.
+        **
+        ** Apache sets r->filename to known-dir/unknown-file and r->path_info
+        ** to "" for the "proper" case. If anything is in path_info, then
+        ** it can't be a locknull resource.
+        **
+        ** ### I bet this path_info hack doesn't work for repositories.
+        ** ### Need input from repository implementors! What kind of
+        ** ### restructure do we need? New provider APIs?
+        */
+        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, 0, r, APLOGNO(00623)
+                          "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_DECLARE(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) {
+
+        /*
+        ** The resource is no longer a locknull resource. This will remove
+        ** the special marker.
+        **
+        ** Note that a locknull resource has already inherited all of the
+        ** locks from the parent. We do not need to call dav_inherit_locks.
+        **
+        ** NOTE: some lock providers record locks for locknull resources using
+        **       a different key than for regular resources. this will shift
+        **       the lock information between the two key types.
+        */
+        (void)(*lockdb->hooks->remove_locknull_state)(lockdb, resource);
+
+        /*
+        ** There are resources under this one, which are new. We must
+        ** propagate the locks down to the new resources.
+        */
+        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
+        ** ### optimize for the depth==0 case.
+        */
+
+        /* 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;
+}