text: /* Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  #include "httpd.h"
  #include "http_log.h"
  #include "http_request.h"
  #include "http_protocol.h"
  #include "http_config.h"
  #include "mpm_common.h"
  #include "mod_status.h"
  
  #include "apr.h"
  #include "apr_strings.h"
  #include "apr_time.h"
  #define APR_WANT_STRFUNC
  #include "apr_want.h"
  #include "apr_dbm.h"
  
  #if APR_HAVE_UNISTD_H
  #include <unistd.h>
  #endif
  
  #include "ap_socache.h"
  
  #if AP_NEED_SET_MUTEX_PERMS
  #include "unixd.h"
  #endif
  
  /* Use of the context structure must be thread-safe after the initial
   * create/init; callers must hold the mutex. */
  struct ap_socache_instance_t {
      const char *data_file;
      /* Pool must only be used with the mutex held. */
      apr_pool_t *pool;
      apr_time_t last_expiry;
      apr_interval_time_t expiry_interval;
  };
  
  /**
   * Support for DBM library
   */
  #define DBM_FILE_MODE ( APR_UREAD | APR_UWRITE | APR_GREAD | APR_WREAD )
  
  #define DEFAULT_DBM_PREFIX "socache-dbm-"
  
  /* ### this should use apr_dbm_usednames. */
  #if !defined(DBM_FILE_SUFFIX_DIR) && !defined(DBM_FILE_SUFFIX_PAG)
  #if defined(DBM_SUFFIX)
  #define DBM_FILE_SUFFIX_DIR DBM_SUFFIX
  #define DBM_FILE_SUFFIX_PAG DBM_SUFFIX
  #elif defined(__FreeBSD__) || (defined(DB_LOCK) && defined(DB_SHMEM))
  #define DBM_FILE_SUFFIX_DIR ".db"
  #define DBM_FILE_SUFFIX_PAG ".db"
  #else
  #define DBM_FILE_SUFFIX_DIR ".dir"
  #define DBM_FILE_SUFFIX_PAG ".pag"
  #endif
  #endif
  
  static void socache_dbm_expire(ap_socache_instance_t *ctx, server_rec *s);
  
  static apr_status_t socache_dbm_remove(ap_socache_instance_t *ctx,
                                         server_rec *s, const unsigned char *id,
                                         unsigned int idlen, apr_pool_t *p);
  
  static const char *socache_dbm_create(ap_socache_instance_t **context,
                                        const char *arg,
                                        apr_pool_t *tmp, apr_pool_t *p)
  {
      ap_socache_instance_t *ctx;
  
      *context = ctx = apr_pcalloc(p, sizeof *ctx);
  
      if (arg && *arg) {
          ctx->data_file = ap_runtime_dir_relative(p, arg);
          if (!ctx->data_file) {
              return apr_psprintf(tmp, "Invalid cache file path %s", arg);
          }
      }
  
      apr_pool_create(&ctx->pool, p);
      apr_pool_tag(ctx->pool, "socache_dbm_instance");
  
      return NULL;
  }
  
  #if AP_NEED_SET_MUTEX_PERMS
  static int try_chown(apr_pool_t *p, server_rec *s,
                       const char *name, const char *suffix)
  {
      if (suffix)
          name = apr_pstrcat(p, name, suffix, NULL);
      if (-1 == chown(name, ap_unixd_config.user_id,
                      (gid_t)-1 /* no gid change */ ))
      {
          if (errno != ENOENT)
              ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(errno), s, APLOGNO(00802)
                           "Can't change owner of %s", name);
          return -1;
      }
      return 0;
  }
  #endif
  
  
  static apr_status_t socache_dbm_init(ap_socache_instance_t *ctx,
                                       const char *namespace,
                                       const struct ap_socache_hints *hints,
                                       server_rec *s, apr_pool_t *p)
  {
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      const apr_dbm_driver_t *driver;
      const apu_err_t *err;
  #endif
      apr_dbm_t *dbm;
      apr_status_t rv;
  
      /* for the DBM we need the data file */
      if (ctx->data_file == NULL) {
          const char *path = apr_pstrcat(p, DEFAULT_DBM_PREFIX, namespace,
                                         NULL);
  
          ctx->data_file = ap_runtime_dir_relative(p, path);
  
          if (ctx->data_file == NULL) {
              ap_log_error(APLOG_MARK, APLOG_ERR, 0, s, APLOGNO(00803)
                           "could not use default path '%s' for DBM socache",
                           path);
              return APR_EINVAL;
          }
      }
  
      /* open it once to create it and to make sure it _can_ be created */
      apr_pool_clear(ctx->pool);
  
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      if ((rv = apr_dbm_get_driver(&driver, NULL, &err,
              ctx->pool) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(10277)
                  "Cannot load socache DBM library '%s': %s",
                       err->reason, err->msg);
          return rv;
      }
      if ((rv = apr_dbm_open2(&dbm, driver, ctx->data_file,
              APR_DBM_RWCREATE, DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00804)
                       "Cannot create socache DBM file `%s'",
                       ctx->data_file);
          return DECLINED;
      }
  #else
      if ((rv = apr_dbm_open(&dbm, ctx->data_file,
              APR_DBM_RWCREATE, DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00804)
                       "Cannot create socache DBM file `%s'",
                       ctx->data_file);
          return rv;
      }
  #endif
      apr_dbm_close(dbm);
  
      ctx->expiry_interval = (hints && hints->expiry_interval
                              ? hints->expiry_interval : apr_time_from_sec(30));
  
  #if AP_NEED_SET_MUTEX_PERMS
      /*
       * We have to make sure the Apache child processes have access to
       * the DBM file. But because there are brain-dead platforms where we
       * cannot exactly determine the suffixes we try all possibilities.
       */
      if (geteuid() == 0 /* is superuser */) {
          try_chown(p, s, ctx->data_file, NULL);
          if (try_chown(p, s, ctx->data_file, DBM_FILE_SUFFIX_DIR))
              if (try_chown(p, s, ctx->data_file, ".db"))
                  try_chown(p, s, ctx->data_file, ".dir");
          if (try_chown(p, s, ctx->data_file, DBM_FILE_SUFFIX_PAG))
              if (try_chown(p, s, ctx->data_file, ".db"))
                  try_chown(p, s, ctx->data_file, ".pag");
      }
  #endif
      socache_dbm_expire(ctx, s);
  
      return APR_SUCCESS;
  }
  
  static void socache_dbm_destroy(ap_socache_instance_t *ctx, server_rec *s)
  {
      /* the correct way */
      unlink(apr_pstrcat(ctx->pool, ctx->data_file, DBM_FILE_SUFFIX_DIR, NULL));
      unlink(apr_pstrcat(ctx->pool, ctx->data_file, DBM_FILE_SUFFIX_PAG, NULL));
      /* the additional ways to be sure */
      unlink(apr_pstrcat(ctx->pool, ctx->data_file, ".dir", NULL));
      unlink(apr_pstrcat(ctx->pool, ctx->data_file, ".pag", NULL));
      unlink(apr_pstrcat(ctx->pool, ctx->data_file, ".db", NULL));
      unlink(ctx->data_file);
  }
  
  static apr_status_t socache_dbm_store(ap_socache_instance_t *ctx,
                                        server_rec *s, const unsigned char *id,
                                        unsigned int idlen, apr_time_t expiry,
                                        unsigned char *ucaData,
                                        unsigned int nData, apr_pool_t *pool)
  {
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      const apr_dbm_driver_t *driver;
      const apu_err_t *err;
  #endif
      apr_dbm_t *dbm;
      apr_datum_t dbmkey;
      apr_datum_t dbmval;
      apr_status_t rv;
  
      /* be careful: do not try to store too much bytes in a DBM file! */
  #ifdef PAIRMAX
      if ((idlen + nData) >= PAIRMAX) {
          ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(00805)
                   "data size too large for DBM socache: %d >= %d",
                   (idlen + nData), PAIRMAX);
          return APR_ENOSPC;
      }
  #else
      if ((idlen + nData) >= 950 /* at least less than approx. 1KB */) {
          ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(00806)
                   "data size too large for DBM socache: %d >= %d",
                   (idlen + nData), 950);
          return APR_ENOSPC;
      }
  #endif
  
      /* create DBM key */
      dbmkey.dptr  = (char *)id;
      dbmkey.dsize = idlen;
  
      /* create DBM value */
      dbmval.dsize = sizeof(apr_time_t) + nData;
      dbmval.dptr  = (char *)ap_malloc(dbmval.dsize);
      memcpy((char *)dbmval.dptr, &expiry, sizeof(apr_time_t));
      memcpy((char *)dbmval.dptr+sizeof(apr_time_t), ucaData, nData);
  
      /* and store it to the DBM file */
      apr_pool_clear(ctx->pool);
  
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      if ((rv = apr_dbm_get_driver(&driver, NULL, &err,
              ctx->pool) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(10278)
                  "Cannot load socache DBM library '%s' (store): %s",
                       err->reason, err->msg);
          free(dbmval.dptr);
          return rv;
      }
      if ((rv = apr_dbm_open2(&dbm, driver, ctx->data_file,
              APR_DBM_RWCREATE, DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00807)
                       "Cannot open socache DBM file `%s' for writing "
                       "(store)",
                       ctx->data_file);
          free(dbmval.dptr);
          return rv;
      }
  #else
      if ((rv = apr_dbm_open(&dbm, ctx->data_file,
                             APR_DBM_RWCREATE, DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00807)
                       "Cannot open socache DBM file `%s' for writing "
                       "(store)",
                       ctx->data_file);
          free(dbmval.dptr);
          return rv;
      }
  #endif
      if ((rv = apr_dbm_store(dbm, dbmkey, dbmval)) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00808)
                       "Cannot store socache object to DBM file `%s'",
                       ctx->data_file);
          apr_dbm_close(dbm);
          free(dbmval.dptr);
          return rv;
      }
      apr_dbm_close(dbm);
  
      /* free temporary buffers */
      free(dbmval.dptr);
  
      /* allow the regular expiring to occur */
      socache_dbm_expire(ctx, s);
  
      return APR_SUCCESS;
  }
  
  static apr_status_t socache_dbm_retrieve(ap_socache_instance_t *ctx, server_rec *s,
                                           const unsigned char *id, unsigned int idlen,
                                           unsigned char *dest, unsigned int *destlen,
                                           apr_pool_t *p)
  {
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      const apr_dbm_driver_t *driver;
      const apu_err_t *err;
  #endif
      apr_dbm_t *dbm;
      apr_datum_t dbmkey;
      apr_datum_t dbmval;
      unsigned int nData;
      apr_time_t expiry;
      apr_time_t now;
      apr_status_t rc;
  
      /* allow the regular expiring to occur */
      socache_dbm_expire(ctx, s);
  
      /* create DBM key and values */
      dbmkey.dptr  = (char *)id;
      dbmkey.dsize = idlen;
  
      /* and fetch it from the DBM file
       * XXX: Should we open the dbm against r->pool so the cleanup will
       * do the apr_dbm_close? This would make the code a bit cleaner.
       */
      apr_pool_clear(ctx->pool);
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      if ((rv = apr_dbm_get_driver(&driver, NULL, &err,
              ctx->pool) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(10279)
                  "Cannot load socache DBM library '%s' (fetch): %s",
                       err->reason, err->msg);
          return rc;
      }
      if ((rv = apr_dbm_open2(&dbm, driver, ctx->data_file,
              APR_DBM_RWCREATE, DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rc, s, APLOGNO(00809)
                       "Cannot open socache DBM file `%s' for reading "
                       "(fetch)",
                       ctx->data_file);
          return rc;
      }
  #else
      if ((rc = apr_dbm_open(&dbm, ctx->data_file, APR_DBM_RWCREATE,
                             DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rc, s, APLOGNO(00809)
                       "Cannot open socache DBM file `%s' for reading "
                       "(fetch)",
                       ctx->data_file);
          return rc;
      }
  #endif
      rc = apr_dbm_fetch(dbm, dbmkey, &dbmval);
      if (rc != APR_SUCCESS) {
          apr_dbm_close(dbm);
          return APR_NOTFOUND;
      }
      if (dbmval.dptr == NULL || dbmval.dsize <= sizeof(apr_time_t)) {
          apr_dbm_close(dbm);
          return APR_EGENERAL;
      }
  
      /* parse resulting data */
      nData = dbmval.dsize-sizeof(apr_time_t);
      if (nData > *destlen) {
          apr_dbm_close(dbm);
          return APR_ENOSPC;
      }
  
      *destlen = nData;
      memcpy(&expiry, dbmval.dptr, sizeof(apr_time_t));
      memcpy(dest, (char *)dbmval.dptr + sizeof(apr_time_t), nData);
  
      apr_dbm_close(dbm);
  
      /* make sure the stuff is still not expired */
      now = apr_time_now();
      if (expiry <= now) {
          socache_dbm_remove(ctx, s, id, idlen, p);
          return APR_NOTFOUND;
      }
  
      return APR_SUCCESS;
  }
  
  static apr_status_t socache_dbm_remove(ap_socache_instance_t *ctx,
                                         server_rec *s, const unsigned char *id,
                                         unsigned int idlen, apr_pool_t *p)
  {
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      const apr_dbm_driver_t *driver;
      const apu_err_t *err;
  #endif
      apr_dbm_t *dbm;
      apr_datum_t dbmkey;
      apr_status_t rv;
  
      /* create DBM key and values */
      dbmkey.dptr  = (char *)id;
      dbmkey.dsize = idlen;
  
      /* and delete it from the DBM file */
      apr_pool_clear(ctx->pool);
  
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      if ((rv = apr_dbm_get_driver(&driver, NULL, &err,
              ctx->pool) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(10280)
                  "Cannot load socache DBM library '%s' (delete): %s",
                       err->reason, err->msg);
          return rv;
      }
      if ((rv = apr_dbm_open2(&dbm, driver, ctx->data_file,
              APR_DBM_RWCREATE, DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00810)
                       "Cannot open socache DBM file `%s' for writing "
                       "(delete)",
                       ctx->data_file);
          return rv;
      }
  #else
      if ((rv = apr_dbm_open(&dbm, ctx->data_file, APR_DBM_RWCREATE,
                             DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00810)
                       "Cannot open socache DBM file `%s' for writing "
                       "(delete)",
                       ctx->data_file);
          return rv;
      }
  #endif
      apr_dbm_delete(dbm, dbmkey);
      apr_dbm_close(dbm);
  
      return APR_SUCCESS;
  }
  
  static void socache_dbm_expire(ap_socache_instance_t *ctx, server_rec *s)
  {
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      const apr_dbm_driver_t *driver;
      const apu_err_t *err;
  #endif
      apr_dbm_t *dbm;
      apr_datum_t dbmkey;
      apr_datum_t dbmval;
      apr_time_t expiry;
      int elts = 0;
      int deleted = 0;
      int expired;
      apr_datum_t *keylist;
      int keyidx;
      int i;
      apr_time_t now;
      apr_status_t rv;
  
      /*
       * make sure the expiration for still not-accessed
       * socache entries is done only from time to time
       */
      now = apr_time_now();
  
      if (now < ctx->last_expiry + ctx->expiry_interval) {
          return;
      }
  
      ctx->last_expiry = now;
  
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      if ((rv = apr_dbm_get_driver(&driver, NULL, &err,
              ctx->pool) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(10281)
                  "Cannot load socache DBM library '%s' (expire): %s",
                       err->reason, err->msg);
          return rv;
      }
  #endif
  
      /*
       * Here we have to be very carefully: Not all DBM libraries are
       * smart enough to allow one to iterate over the elements and at the
       * same time delete expired ones. Some of them get totally crazy
       * while others have no problems. So we have to do it the slower but
       * more safe way: we first iterate over all elements and remember
       * those which have to be expired. Then in a second pass we delete
       * all those expired elements. Additionally we reopen the DBM file
       * to be really safe in state.
       */
  
  #define KEYMAX 1024
  
      for (;;) {
          /* allocate the key array in a memory sub pool */
          apr_pool_clear(ctx->pool);
  
          if ((keylist = apr_palloc(ctx->pool, sizeof(dbmkey)*KEYMAX)) == NULL) {
              break;
          }
  
          /* pass 1: scan DBM database */
          keyidx = 0;
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
          if ((rv = apr_dbm_open2(&dbm, driver, ctx->data_file, APR_DBM_RWCREATE,
                                 DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
              ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00811)
                           "Cannot open socache DBM file `%s' for "
                           "scanning",
                           ctx->data_file);
              break;
          }
  #else
          if ((rv = apr_dbm_open(&dbm, ctx->data_file, APR_DBM_RWCREATE,
                                 DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
              ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00811)
                           "Cannot open socache DBM file `%s' for "
                           "scanning",
                           ctx->data_file);
              break;
          }
  #endif
          apr_dbm_firstkey(dbm, &dbmkey);
          while (dbmkey.dptr != NULL) {
              elts++;
              expired = FALSE;
              apr_dbm_fetch(dbm, dbmkey, &dbmval);
              if (dbmval.dsize <= sizeof(apr_time_t) || dbmval.dptr == NULL)
                  expired = TRUE;
              else {
                  memcpy(&expiry, dbmval.dptr, sizeof(apr_time_t));
                  if (expiry <= now)
                      expired = TRUE;
              }
              if (expired) {
                  if ((keylist[keyidx].dptr = apr_pmemdup(ctx->pool, dbmkey.dptr, dbmkey.dsize)) != NULL) {
                      keylist[keyidx].dsize = dbmkey.dsize;
                      keyidx++;
                      if (keyidx == KEYMAX)
                          break;
                  }
              }
              apr_dbm_nextkey(dbm, &dbmkey);
          }
          apr_dbm_close(dbm);
  
          /* pass 2: delete expired elements */
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
          if (apr_dbm_open2(&dbm, driver, ctx->data_file, APR_DBM_RWCREATE,
                           DBM_FILE_MODE, ctx->pool) != APR_SUCCESS) {
              ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00812)
                           "Cannot re-open socache DBM file `%s' for "
                           "expiring",
                           ctx->data_file);
              break;
          }
  #else
          if (apr_dbm_open(&dbm, ctx->data_file, APR_DBM_RWCREATE,
                           DBM_FILE_MODE, ctx->pool) != APR_SUCCESS) {
              ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00812)
                           "Cannot re-open socache DBM file `%s' for "
                           "expiring",
                           ctx->data_file);
              break;
          }
  #endif
          for (i = 0; i < keyidx; i++) {
              apr_dbm_delete(dbm, keylist[i]);
              deleted++;
          }
          apr_dbm_close(dbm);
  
          if (keyidx < KEYMAX)
              break;
      }
  
      ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(00813)
                   "DBM socache expiry: "
                   "old: %d, new: %d, removed: %d",
                   elts, elts-deleted, deleted);
  }
  
  static void socache_dbm_status(ap_socache_instance_t *ctx, request_rec *r,
                                 int flags)
  {
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      const apr_dbm_driver_t *driver;
      const apu_err_t *err;
  #endif
      apr_dbm_t *dbm;
      apr_datum_t dbmkey;
      apr_datum_t dbmval;
      int elts;
      long size;
      int avg;
      apr_status_t rv;
  
      elts = 0;
      size = 0;
  
      apr_pool_clear(ctx->pool);
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      if ((rv = apr_dbm_get_driver(&driver, NULL, &err,
              ctx->pool) != APR_SUCCESS) {
          ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(10282)
                  "Cannot load socache DBM library '%s' (status retrieval): %s",
                       err->reason, err->msg);
          return;
      }
      if ((rv = apr_dbm_open2(&dbm, driver, ctx->data_file, APR_DBM_RWCREATE,
                             DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(00814)
                       "Cannot open socache DBM file `%s' for status "
                       "retrieval",
                       ctx->data_file);
          return;
      }
  #else
      if ((rv = apr_dbm_open(&dbm, ctx->data_file, APR_DBM_RWCREATE,
                             DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(00814)
                       "Cannot open socache DBM file `%s' for status "
                       "retrieval",
                       ctx->data_file);
          return;
      }
  #endif
      /*
       * XXX - Check the return value of apr_dbm_firstkey, apr_dbm_fetch - TBD
       */
      apr_dbm_firstkey(dbm, &dbmkey);
      for ( ; dbmkey.dptr != NULL; apr_dbm_nextkey(dbm, &dbmkey)) {
          apr_dbm_fetch(dbm, dbmkey, &dbmval);
          if (dbmval.dptr == NULL)
              continue;
          elts += 1;
          size += dbmval.dsize;
      }
      apr_dbm_close(dbm);
      if (size > 0 && elts > 0)
          avg = (int)(size / (long)elts);
      else
          avg = 0;
      if (!(flags & AP_STATUS_SHORT)) {
          ap_rprintf(r, "cache type: <b>DBM</b>, maximum size: <b>unlimited</b><br>");
          ap_rprintf(r, "current entries: <b>%d</b>, current size: <b>%ld</b> bytes<br>", elts, size);
          ap_rprintf(r, "average entry size: <b>%d</b> bytes<br>", avg);
      }
      else {
          ap_rputs("CacheType: DBM\n", r);
          ap_rputs("CacheMaximumSize: unlimited\n", r);
          ap_rprintf(r, "CacheCurrentEntries: %d\n", elts);
          ap_rprintf(r, "CacheCurrentSize: %ld\n", size);
          ap_rprintf(r, "CacheAvgEntrySize: %d\n", avg);
      }
  }
  
  static apr_status_t socache_dbm_iterate(ap_socache_instance_t *ctx,
                                          server_rec *s, void *userctx,
                                          ap_socache_iterator_t *iterator,
                                          apr_pool_t *pool)
  {
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      const apr_dbm_driver_t *driver;
      const apu_err_t *err;
  #endif
      apr_dbm_t *dbm;
      apr_datum_t dbmkey;
      apr_datum_t dbmval;
      apr_time_t expiry;
      int expired;
      apr_time_t now;
      apr_status_t rv;
  
      /*
       * make sure the expired records are omitted
       */
      now = apr_time_now();
  #if APU_MAJOR_VERSION > 1 || (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 7)
      if ((rv = apr_dbm_get_driver(&driver, NULL, &err,
              ctx->pool) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(10283)
                  "Cannot load socache DBM library '%s' (iterating): %s",
                       err->reason, err->msg);
          return rv;
      }
      if ((rv = apr_dbm_open2(&dbm, driver, ctx->data_file, APR_DBM_RWCREATE,
                             DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00815)
                       "Cannot open socache DBM file `%s' for "
                       "iterating", ctx->data_file);
          return rv;
      }
  #else
      if ((rv = apr_dbm_open(&dbm, ctx->data_file, APR_DBM_RWCREATE,
                             DBM_FILE_MODE, ctx->pool)) != APR_SUCCESS) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00815)
                       "Cannot open socache DBM file `%s' for "
                       "iterating", ctx->data_file);
          return rv;
      }
  #endif
      rv = apr_dbm_firstkey(dbm, &dbmkey);
      while (rv == APR_SUCCESS && dbmkey.dptr != NULL) {
          expired = FALSE;
          apr_dbm_fetch(dbm, dbmkey, &dbmval);
          if (dbmval.dsize <= sizeof(apr_time_t) || dbmval.dptr == NULL)
              expired = TRUE;
          else {
              memcpy(&expiry, dbmval.dptr, sizeof(apr_time_t));
              if (expiry <= now)
                  expired = TRUE;
          }
          if (!expired) {
              rv = iterator(ctx, s, userctx,
                               (unsigned char *)dbmkey.dptr, dbmkey.dsize,
                               (unsigned char *)dbmval.dptr + sizeof(apr_time_t),
                               dbmval.dsize - sizeof(apr_time_t), pool);
              ap_log_error(APLOG_MARK, APLOG_DEBUG, rv, s, APLOGNO(00816)
                           "dbm `%s' entry iterated", ctx->data_file);
              if (rv != APR_SUCCESS)
                  return rv;
          }
          rv = apr_dbm_nextkey(dbm, &dbmkey);
      }
      apr_dbm_close(dbm);
  
      if (rv != APR_SUCCESS && rv != APR_EOF) {
          ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00817)
                       "Failure reading first/next socache DBM file `%s' record",
                       ctx->data_file);
          return rv;
      }
      return APR_SUCCESS;
  }
  
  static const ap_socache_provider_t socache_dbm = {
      "dbm",
      AP_SOCACHE_FLAG_NOTMPSAFE,
      socache_dbm_create,
      socache_dbm_init,
      socache_dbm_destroy,
      socache_dbm_store,
      socache_dbm_retrieve,
      socache_dbm_remove,
      socache_dbm_status,
      socache_dbm_iterate
  };
  
  static void register_hooks(apr_pool_t *p)
  {
      ap_register_provider(p, AP_SOCACHE_PROVIDER_GROUP, "dbm",
                           AP_SOCACHE_PROVIDER_VERSION,
                           &socache_dbm);
  }
  
  AP_DECLARE_MODULE(socache_dbm) = {
      STANDARD20_MODULE_STUFF,
      NULL, NULL, NULL, NULL, NULL,
      register_hooks
  };
  