httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jerenkra...@apache.org
Subject cvs commit: httpd-2.0/modules/dav/lock .cvsignore Makefile.in config6.m4 locks.c locks.h mod_dav_lock.c
Date Sat, 04 Jan 2003 23:19:39 GMT
jerenkrantz    2003/01/04 15:19:39

  Modified:    .        CHANGES
  Added:       modules/dav/lock .cvsignore Makefile.in config6.m4 locks.c
                        locks.h mod_dav_lock.c
  Log:
  Add a generic locking provider to DAV - mod_dav_lock.  Other DAV providers
  can use the dav_hooks_locks_generic structure to implement locking in a
  non-optimal, but compliant fashion.  (Use 'dav-lock', 'generic', '0' to
  ap_lookup_provider to retrieve it.)
  
  Use the DavGenericLockDB directive to configure the location of the lock
  database (may be server-relative or absolute).
  
  This allows all DAV providers to use a baseline locking API rather than roll
  their own.
  
  This code is based mainly off the mod_dav_fs locking code (which uses the
  on-disk storage for locking), but removing components that aren't needed in a
  non-file-backed repository (such as recording inodes).
  
  Revision  Changes    Path
  1.1020    +3 -0      httpd-2.0/CHANGES
  
  Index: CHANGES
  ===================================================================
  RCS file: /home/cvs/httpd-2.0/CHANGES,v
  retrieving revision 1.1019
  retrieving revision 1.1020
  diff -u -u -r1.1019 -r1.1020
  --- CHANGES	3 Jan 2003 18:35:08 -0000	1.1019
  +++ CHANGES	4 Jan 2003 23:19:38 -0000	1.1020
  @@ -2,6 +2,9 @@
   
     [Remove entries to the current 2.0 section below, when backported]
   
  +  *) Add mod_dav_lock - a generic subset of the DAV locking implementation.
  +     [Justin Erenkrantz]
  +
     *) Replace some of the mutex locking in the worker MPM with
        atomic operations for higher concurrency.  [Brian Pane]
   
  
  
  
  1.1                  httpd-2.0/modules/dav/lock/.cvsignore
  
  Index: .cvsignore
  ===================================================================
  .deps
  .libs
  *.la
  modules.mk
  Makefile
  *.lo
  *.slo
  *.so
  Debug
  Release
  *.plg
  *.aps
  *.dep
  *.mak
  *.rc
  BuildLog.htm
  *.stc
  *.stt
  *.sto
  *.vcproj
  
  
  
  1.1                  httpd-2.0/modules/dav/lock/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  # 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
  
  
  
  1.1                  httpd-2.0/modules/dav/lock/config6.m4
  
  Index: config6.m4
  ===================================================================
  dnl modules enabled in this directory by default
  
  APACHE_MODPATH_INIT(dav/lock)
  
  dav_lock_objects="mod_dav_lock.lo locks.lo"
  
  if test "x$enable_dav" != "x"; then
    dav_lock_enable=$enable_dav
  else
    dav_lock_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_lock_objects="$dav_lock_objects ../main/mod_dav.la"
      ;;
  esac
  
  APACHE_MODULE(dav_lock, DAV provider for generic locking, $dav_lock_objects, , $dav_lock_enable)
  
  APACHE_MODPATH_FINISH
  
  
  
  1.1                  httpd-2.0/modules/dav/lock/locks.c
  
  Index: locks.c
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2003 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" must
   *    not be used to endorse or promote products derived from this
   *    software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache",
   *    nor may "Apache" appear in their name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  /*
   * 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;
      apr_dbm_t *db;
  
      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;
  
      /* ### 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,
                               "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;
      dav_buffer buf = { 0 };
  
      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_palloc(p, sizeof(*dp->locktoken));
              memcpy(dp->locktoken, 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_palloc(p, sizeof(*ip->locktoken));
              memcpy(ip->locktoken, 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_palloc(p, ip->key.dsize); 
              memcpy(ip->key.dptr, 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,
                                   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,
                           "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,
                               "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_buffer buf = { 0 };
      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;
          }
      }
  
      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 */
  };
  
  
  
  1.1                  httpd-2.0/modules/dav/lock/locks.h
  
  Index: locks.h
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2003 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" must
   *    not be used to endorse or promote products derived from this
   *    software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache",
   *    nor may "Apache" appear in their name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  /*
  ** Declarations for the generic lock implementation
  */
  
  #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_ */
  
  
  
  1.1                  httpd-2.0/modules/dav/lock/mod_dav_lock.c
  
  Index: mod_dav_lock.c
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2003 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" must
   *    not be used to endorse or promote products derived from this
   *    software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache",
   *    nor may "Apache" appear in their name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  #include "httpd.h"
  #include "http_config.h"
  #include "apr_strings.h"
  #include "ap_provider.h"
  
  #include "mod_dav.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);
  }
  
  module AP_MODULE_DECLARE_DATA dav_lock_module =
  {
      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 */
  };
  
  
  

Mime
View raw message