dav/fs/dbm.c

	dbm.c revision edab53cc0be707fa71968a95c696b19f0e6c4736
d7759bdad133e1e92fe41aab75dd8c1584eda38cjim/* Licensed to the Apache Software Foundation (ASF) under one or more
d7759bdad133e1e92fe41aab75dd8c1584eda38cjim * contributor license agreements.  See the NOTICE file distributed with
d7759bdad133e1e92fe41aab75dd8c1584eda38cjim * this work for additional information regarding copyright ownership.
4e191199a0aeab09d78df8f5579e745572e8b7bcwsanchez * The ASF licenses this file to You under the Apache License, Version 2.0
f3a5934ca0fb0f0f813bd9d9d06af8937e3f401fjim * (the "License"); you may not use this file except in compliance with
f3a5934ca0fb0f0f813bd9d9d06af8937e3f401fjim * the License.  You may obtain a copy of the License at
d7759bdad133e1e92fe41aab75dd8c1584eda38cjim *
d7759bdad133e1e92fe41aab75dd8c1584eda38cjim *     http://www.apache.org/licenses/LICENSE-2.0
d7759bdad133e1e92fe41aab75dd8c1584eda38cjim *
d7759bdad133e1e92fe41aab75dd8c1584eda38cjim * Unless required by applicable law or agreed to in writing, software
b3155b9e3b06b20030ec6c16d98f8dabf12ead9cianh * distributed under the License is distributed on an "AS IS" BASIS,
b3155b9e3b06b20030ec6c16d98f8dabf12ead9cianh * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
b3155b9e3b06b20030ec6c16d98f8dabf12ead9cianh * See the License for the specific language governing permissions and
b3155b9e3b06b20030ec6c16d98f8dabf12ead9cianh * limitations under the License.
b3155b9e3b06b20030ec6c16d98f8dabf12ead9cianh */
b3155b9e3b06b20030ec6c16d98f8dabf12ead9cianh
b3155b9e3b06b20030ec6c16d98f8dabf12ead9cianh/*
b3155b9e3b06b20030ec6c16d98f8dabf12ead9cianh** DAV extension module for Apache 2.0.*
ff1234e45aca1b8171d711ecb87f58b9d9100a99ianh**  - Database support using DBM-style databases,
ff1234e45aca1b8171d711ecb87f58b9d9100a99ianh**    part of the filesystem repository implementation
ff1234e45aca1b8171d711ecb87f58b9d9100a99ianh*/
ff1234e45aca1b8171d711ecb87f58b9d9100a99ianh
ff1234e45aca1b8171d711ecb87f58b9d9100a99ianh/*
ff1234e45aca1b8171d711ecb87f58b9d9100a99ianh** This implementation uses a SDBM database per file and directory to
ff1234e45aca1b8171d711ecb87f58b9d9100a99ianh** record the properties. These databases are kept in a subdirectory (of
ff1234e45aca1b8171d711ecb87f58b9d9100a99ianh** the directory in question or the directory that holds the file in
b999f6ba2a266bf9a92687f31bb7e76021ac5891ianh** question) named by the macro DAV_FS_STATE_DIR (.DAV). The filename of the
2ceedfca3a2fdfdb5ff60ca17f030ce91f6331cbwrowe** database is equivalent to the target filename, and is
2ceedfca3a2fdfdb5ff60ca17f030ce91f6331cbwrowe** DAV_FS_STATE_FILE_FOR_DIR (.state_for_dir) for the directory itself.
2ceedfca3a2fdfdb5ff60ca17f030ce91f6331cbwrowe*/
2ceedfca3a2fdfdb5ff60ca17f030ce91f6331cbwrowe
2ceedfca3a2fdfdb5ff60ca17f030ce91f6331cbwrowe#include "apr_strings.h"
2ceedfca3a2fdfdb5ff60ca17f030ce91f6331cbwrowe#include "apr_file_io.h"
2ceedfca3a2fdfdb5ff60ca17f030ce91f6331cbwrowe
2ceedfca3a2fdfdb5ff60ca17f030ce91f6331cbwrowe#include "apr_dbm.h"
b999f6ba2a266bf9a92687f31bb7e76021ac5891ianh
2ceedfca3a2fdfdb5ff60ca17f030ce91f6331cbwrowe#define APR_WANT_BYTEFUNC
b999f6ba2a266bf9a92687f31bb7e76021ac5891ianh#include "apr_want.h"       /* for ntohs and htons */
7d7931c1f4d46b041ad2ad6fdb9499289063611eianh
1f3a44f2fd7f9fee00b80c7ddcf1028ea145f91drbb#include "mod_dav.h"
b9b69856aec9ea58ea1b1e5aff669e8eaf2ebce4rbb#include "repos.h"
b9b69856aec9ea58ea1b1e5aff669e8eaf2ebce4rbb#include "http_log.h"
b9b69856aec9ea58ea1b1e5aff669e8eaf2ebce4rbb#include "http_main.h"      /* for ap_server_conf */
1f3a44f2fd7f9fee00b80c7ddcf1028ea145f91drbb
1f3a44f2fd7f9fee00b80c7ddcf1028ea145f91drbbAPLOG_USE_MODULE(dav_fs);
1f3a44f2fd7f9fee00b80c7ddcf1028ea145f91drbb
7d7931c1f4d46b041ad2ad6fdb9499289063611eianhstruct dav_db {
1f3a44f2fd7f9fee00b80c7ddcf1028ea145f91drbb    apr_pool_t *pool;
68bcde9c52e9e749482df2800dbdff09559115e0chuck    apr_dbm_t *file;
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck
43ea154f46345c9722c2b25b2b9f5086ec79eaeeorlikowski    /* when used as a property database: */
43ea154f46345c9722c2b25b2b9f5086ec79eaeeorlikowski
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck    int version;                /* *minor* version of this db */
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck    dav_buffer ns_table;        /* table of namespace URIs */
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck    short ns_count;             /* number of entries in table */
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck    int ns_table_dirty;         /* ns_table was modified */
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck    apr_hash_t *uri_index;      /* map URIs to (1-based) table indices */
68bcde9c52e9e749482df2800dbdff09559115e0chuck
53c2eb831bfe47860e3f5ec9190b15cb92f15181chuck    dav_buffer wb_key;          /* work buffer for dav_gdbm_key */
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck
53c2eb831bfe47860e3f5ec9190b15cb92f15181chuck    apr_datum_t iter;           /* iteration key */
c1635d9f723f28fed4b95e5d9693e554a79e8d77orlikowski};
c1635d9f723f28fed4b95e5d9693e554a79e8d77orlikowski
c1635d9f723f28fed4b95e5d9693e554a79e8d77orlikowski/* -------------------------------------------------------------------------
c1635d9f723f28fed4b95e5d9693e554a79e8d77orlikowski *
c1635d9f723f28fed4b95e5d9693e554a79e8d77orlikowski * GENERIC DBM ACCESS
c1635d9f723f28fed4b95e5d9693e554a79e8d77orlikowski *
c1635d9f723f28fed4b95e5d9693e554a79e8d77orlikowski * For the most part, this just uses the APR DBM functions. They are wrapped
4f7dd0949d92462a8adc31eee8aff266eea55204chuck * a bit with some error handling (using the mod_dav error functions).
4f7dd0949d92462a8adc31eee8aff266eea55204chuck */
4f7dd0949d92462a8adc31eee8aff266eea55204chuck
4f7dd0949d92462a8adc31eee8aff266eea55204chuckvoid dav_dbm_get_statefiles(apr_pool_t *p, const char *fname,
4f7dd0949d92462a8adc31eee8aff266eea55204chuck                            const char **state1, const char **state2)
75b3ed55173b29dbdf9e2fb6ec5462bfceee21aechuck{
75b3ed55173b29dbdf9e2fb6ec5462bfceee21aechuck    if (fname == NULL)
75b3ed55173b29dbdf9e2fb6ec5462bfceee21aechuck        fname = DAV_FS_STATE_FILE_FOR_DIR;
4f7dd0949d92462a8adc31eee8aff266eea55204chuck
75b3ed55173b29dbdf9e2fb6ec5462bfceee21aechuck    apr_dbm_get_usednames(p, fname, state1, state2);
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck}
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck
68bcde9c52e9e749482df2800dbdff09559115e0chuckstatic dav_error * dav_fs_dbm_error(dav_db *db, apr_pool_t *p,
68bcde9c52e9e749482df2800dbdff09559115e0chuck                                    apr_status_t status)
68bcde9c52e9e749482df2800dbdff09559115e0chuck{
68bcde9c52e9e749482df2800dbdff09559115e0chuck    int errcode;
68bcde9c52e9e749482df2800dbdff09559115e0chuck    const char *errstr;
68bcde9c52e9e749482df2800dbdff09559115e0chuck    dav_error *err;
68bcde9c52e9e749482df2800dbdff09559115e0chuck    char errbuf[200];
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    if (status == APR_SUCCESS)
68bcde9c52e9e749482df2800dbdff09559115e0chuck        return NULL;
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    p = db ? db->pool : p;
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    /* There might not be a <db> if we had problems creating it. */
68bcde9c52e9e749482df2800dbdff09559115e0chuck    if (db == NULL) {
68bcde9c52e9e749482df2800dbdff09559115e0chuck        errcode = 1;
68bcde9c52e9e749482df2800dbdff09559115e0chuck        errstr = "Could not open property database.";
68bcde9c52e9e749482df2800dbdff09559115e0chuck        if (APR_STATUS_IS_EDSOOPEN(status))
68bcde9c52e9e749482df2800dbdff09559115e0chuck            ap_log_error(APLOG_MARK, APLOG_CRIT, status, ap_server_conf, APLOGNO(00576)
68bcde9c52e9e749482df2800dbdff09559115e0chuck            "The DBM driver could not be loaded");
68bcde9c52e9e749482df2800dbdff09559115e0chuck    }
68bcde9c52e9e749482df2800dbdff09559115e0chuck    else {
68bcde9c52e9e749482df2800dbdff09559115e0chuck        (void) apr_dbm_geterror(db->file, &errcode, errbuf, sizeof(errbuf));
68bcde9c52e9e749482df2800dbdff09559115e0chuck        errstr = apr_pstrdup(p, errbuf);
68bcde9c52e9e749482df2800dbdff09559115e0chuck    }
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, errcode, status, errstr);
68bcde9c52e9e749482df2800dbdff09559115e0chuck    return err;
68bcde9c52e9e749482df2800dbdff09559115e0chuck}
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck/* ensure that our state subdirectory is present */
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck/* ### does this belong here or in dav_fs_repos.c ?? */
0c233c76f21b358f4a0d81e0f956339ca727c14cchuckvoid dav_fs_ensure_state_dir(apr_pool_t * p, const char *dirname)
68bcde9c52e9e749482df2800dbdff09559115e0chuck{
68bcde9c52e9e749482df2800dbdff09559115e0chuck    const char *pathname = apr_pstrcat(p, dirname, "/" DAV_FS_STATE_DIR, NULL);
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    /* ### do we need to deal with the umask? */
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    /* just try to make it, ignoring any resulting errors */
68bcde9c52e9e749482df2800dbdff09559115e0chuck    (void) apr_dir_make(pathname, APR_OS_DEFAULT, p);
68bcde9c52e9e749482df2800dbdff09559115e0chuck}
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck/* dav_dbm_open_direct:  Opens a *dbm database specified by path.
68bcde9c52e9e749482df2800dbdff09559115e0chuck *    ro = boolean read-only flag.
68bcde9c52e9e749482df2800dbdff09559115e0chuck */
68bcde9c52e9e749482df2800dbdff09559115e0chuckdav_error * dav_dbm_open_direct(apr_pool_t *p, const char *pathname, int ro,
68bcde9c52e9e749482df2800dbdff09559115e0chuck                                dav_db **pdb)
68bcde9c52e9e749482df2800dbdff09559115e0chuck{
68bcde9c52e9e749482df2800dbdff09559115e0chuck    apr_status_t status;
68bcde9c52e9e749482df2800dbdff09559115e0chuck    apr_dbm_t *file = NULL;
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    *pdb = NULL;
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    if ((status = apr_dbm_open(&file, pathname,
68bcde9c52e9e749482df2800dbdff09559115e0chuck                               ro ? APR_DBM_READONLY : APR_DBM_RWCREATE,
68bcde9c52e9e749482df2800dbdff09559115e0chuck                               APR_OS_DEFAULT, p))
68bcde9c52e9e749482df2800dbdff09559115e0chuck                != APR_SUCCESS
68bcde9c52e9e749482df2800dbdff09559115e0chuck        && !ro) {
68bcde9c52e9e749482df2800dbdff09559115e0chuck        /* ### do something with 'status' */
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck        /* we can't continue if we couldn't open the file
68bcde9c52e9e749482df2800dbdff09559115e0chuck           and we need to write */
68bcde9c52e9e749482df2800dbdff09559115e0chuck        return dav_fs_dbm_error(NULL, p, status);
68bcde9c52e9e749482df2800dbdff09559115e0chuck    }
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    /* may be NULL if we tried to open a non-existent db as read-only */
68bcde9c52e9e749482df2800dbdff09559115e0chuck    if (file != NULL) {
68bcde9c52e9e749482df2800dbdff09559115e0chuck        /* we have an open database... return it */
68bcde9c52e9e749482df2800dbdff09559115e0chuck        *pdb = apr_pcalloc(p, sizeof(**pdb));
68bcde9c52e9e749482df2800dbdff09559115e0chuck        (*pdb)->pool = p;
68bcde9c52e9e749482df2800dbdff09559115e0chuck        (*pdb)->file = file;
68bcde9c52e9e749482df2800dbdff09559115e0chuck    }
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    return NULL;
68bcde9c52e9e749482df2800dbdff09559115e0chuck}
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuckstatic dav_error * dav_dbm_open(apr_pool_t * p, const dav_resource *resource,
68bcde9c52e9e749482df2800dbdff09559115e0chuck                                int ro, dav_db **pdb)
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck{
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck    const char *dirpath;
68bcde9c52e9e749482df2800dbdff09559115e0chuck    const char *fname;
68bcde9c52e9e749482df2800dbdff09559115e0chuck    const char *pathname;
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    /* Get directory and filename for resource */
68bcde9c52e9e749482df2800dbdff09559115e0chuck    /* ### should test this result value... */
68bcde9c52e9e749482df2800dbdff09559115e0chuck    (void) dav_fs_dir_file_name(resource, &dirpath, &fname);
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    /* If not opening read-only, ensure the state dir exists */
68bcde9c52e9e749482df2800dbdff09559115e0chuck    if (!ro) {
68bcde9c52e9e749482df2800dbdff09559115e0chuck        /* ### what are the perf implications of always checking this? */
68bcde9c52e9e749482df2800dbdff09559115e0chuck        dav_fs_ensure_state_dir(p, dirpath);
68bcde9c52e9e749482df2800dbdff09559115e0chuck    }
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    pathname = apr_pstrcat(p, dirpath, "/" DAV_FS_STATE_DIR "/",
68bcde9c52e9e749482df2800dbdff09559115e0chuck                              fname ? fname : DAV_FS_STATE_FILE_FOR_DIR,
68bcde9c52e9e749482df2800dbdff09559115e0chuck                              NULL);
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck    /* ### readers cannot open while a writer has this open; we should
68bcde9c52e9e749482df2800dbdff09559115e0chuck       ### perform a few retries with random pauses. */
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    /* ### do we need to deal with the umask? */
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    return dav_dbm_open_direct(p, pathname, ro, pdb);
68bcde9c52e9e749482df2800dbdff09559115e0chuck}
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuckvoid dav_dbm_close(dav_db *db)
68bcde9c52e9e749482df2800dbdff09559115e0chuck{
68bcde9c52e9e749482df2800dbdff09559115e0chuck    apr_dbm_close(db->file);
68bcde9c52e9e749482df2800dbdff09559115e0chuck}
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuckdav_error * dav_dbm_fetch(dav_db *db, apr_datum_t key, apr_datum_t *pvalue)
68bcde9c52e9e749482df2800dbdff09559115e0chuck{
68bcde9c52e9e749482df2800dbdff09559115e0chuck    apr_status_t status;
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    if (!key.dptr) {
68bcde9c52e9e749482df2800dbdff09559115e0chuck        /* no key could be created (namespace not known) => no value */
68bcde9c52e9e749482df2800dbdff09559115e0chuck        memset(pvalue, 0, sizeof(*pvalue));
68bcde9c52e9e749482df2800dbdff09559115e0chuck        status = APR_SUCCESS;
68bcde9c52e9e749482df2800dbdff09559115e0chuck    } else {
68bcde9c52e9e749482df2800dbdff09559115e0chuck        status = apr_dbm_fetch(db->file, key, pvalue);
68bcde9c52e9e749482df2800dbdff09559115e0chuck    }
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    return dav_fs_dbm_error(db, NULL, status);
68bcde9c52e9e749482df2800dbdff09559115e0chuck}
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuckdav_error * dav_dbm_store(dav_db *db, apr_datum_t key, apr_datum_t value)
68bcde9c52e9e749482df2800dbdff09559115e0chuck{
68bcde9c52e9e749482df2800dbdff09559115e0chuck    apr_status_t status = apr_dbm_store(db->file, key, value);
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuck    return dav_fs_dbm_error(db, NULL, status);
0c233c76f21b358f4a0d81e0f956339ca727c14cchuck}
68bcde9c52e9e749482df2800dbdff09559115e0chuck
68bcde9c52e9e749482df2800dbdff09559115e0chuckdav_error * dav_dbm_delete(dav_db *db, apr_datum_t key)
4f7dd0949d92462a8adc31eee8aff266eea55204chuck{
4f7dd0949d92462a8adc31eee8aff266eea55204chuck    apr_status_t status = apr_dbm_delete(db->file, key);
68bcde9c52e9e749482df2800dbdff09559115e0chuck
4f7dd0949d92462a8adc31eee8aff266eea55204chuck    return dav_fs_dbm_error(db, NULL, status);
4f7dd0949d92462a8adc31eee8aff266eea55204chuck}
68bcde9c52e9e749482df2800dbdff09559115e0chuck
4f7dd0949d92462a8adc31eee8aff266eea55204chuckint dav_dbm_exists(dav_db *db, apr_datum_t key)
4f7dd0949d92462a8adc31eee8aff266eea55204chuck{
68bcde9c52e9e749482df2800dbdff09559115e0chuck    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 */
};