/* Copyright 2003-2005 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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 save_errno = errno;    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, errstr);    err->save_errno = save_errno;    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,                             "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,                             "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,                             "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;