dbm/apr_dbm_gdbm.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "apu.h"
  18 #include "apr_strings.h"
  19
  20 #if APR_HAVE_STDLIB_H
  21 #include <stdlib.h>     /* for free() */
  22 #endif
  23
  24 #if APU_HAVE_GDBM
  25 #include "apr_dbm_private.h"
  26
  27 #include <gdbm.h>
  28
  29 #define APR_DBM_DBMODE_RO       GDBM_READER
  30 #define APR_DBM_DBMODE_RW       GDBM_WRITER
  31 #define APR_DBM_DBMODE_RWCREATE GDBM_WRCREAT
  32 #define APR_DBM_DBMODE_RWTRUNC  GDBM_NEWDB
  33
  34 /* map a GDBM error to an apr_status_t */
  35 static apr_status_t g2s(int gerr)
  36 {
  37     if (gerr == -1) {
  38         /* ### need to fix this */
  39         return APR_EGENERAL;
  40     }
  41
  42     return APR_SUCCESS;
  43 }
  44
  45 static apr_status_t datum_cleanup(void *dptr)
  46 {
  47     if (dptr)
  48         free(dptr);
  49
  50     return APR_SUCCESS;
  51 }
  52
  53 static apr_status_t set_error(apr_dbm_t *dbm, apr_status_t dbm_said)
  54 {
  55     apr_status_t rv = APR_SUCCESS;
  56
  57     /* ### ignore whatever the DBM said (dbm_said); ask it explicitly */
  58
  59     if ((dbm->errcode = gdbm_errno) == GDBM_NO_ERROR) {
  60         dbm->errmsg = NULL;
  61     }
  62     else {
  63         dbm->errmsg = gdbm_strerror(gdbm_errno);
  64         rv = APR_EGENERAL;        /* ### need something better */
  65     }
  66
  67     /* captured it. clear it now. */
  68     gdbm_errno = GDBM_NO_ERROR;
  69
  70     return rv;
  71 }
  72
  73 /* --------------------------------------------------------------------------
  74 **
  75 ** DEFINE THE VTABLE FUNCTIONS FOR GDBM
  76 */
  77
  78 static apr_status_t vt_gdbm_open(apr_dbm_t **pdb, const char *pathname,
  79                                  apr_int32_t mode, apr_fileperms_t perm,
  80                                  apr_pool_t *pool)
  81 {
  82     GDBM_FILE file;
  83     int dbmode;
  84
  85     *pdb = NULL;
  86
  87     switch (mode) {
  88     case APR_DBM_READONLY:
  89         dbmode = APR_DBM_DBMODE_RO;
  90         break;
  91     case APR_DBM_READWRITE:
  92         dbmode = APR_DBM_DBMODE_RW;
  93         break;
  94     case APR_DBM_RWCREATE:
  95         dbmode = APR_DBM_DBMODE_RWCREATE;
  96         break;
  97     case APR_DBM_RWTRUNC:
  98         dbmode = APR_DBM_DBMODE_RWTRUNC;
  99         break;
 100     default:
 101         return APR_EINVAL;
 102     }
 103
 104     /* Note: stupid cast to get rid of "const" on the pathname */
 105     file = gdbm_open((char *) pathname, 0, dbmode, apr_posix_perms2mode(perm),
 106                      NULL);
 107
 108     if (file == NULL)
 109         return APR_EGENERAL;      /* ### need a better error */
 110
 111     /* we have an open database... return it */
 112     *pdb = apr_pcalloc(pool, sizeof(**pdb));
 113     (*pdb)->pool = pool;
 114     (*pdb)->type = &apr_dbm_type_gdbm;
 115     (*pdb)->file = file;
 116
 117     /* ### register a cleanup to close the DBM? */
 118
 119     return APR_SUCCESS;
 120 }
 121
 122 static void vt_gdbm_close(apr_dbm_t *dbm)
 123 {
 124     gdbm_close(dbm->file);
 125 }
 126
 127 static apr_status_t vt_gdbm_fetch(apr_dbm_t *dbm, apr_datum_t key,
 128                                   apr_datum_t *pvalue)
 129 {
 130     datum kd, rd;
 131
 132     kd.dptr = key.dptr;
 133     kd.dsize = key.dsize;
 134
 135     rd = gdbm_fetch(dbm->file, kd);
 136
 137     pvalue->dptr = rd.dptr;
 138     pvalue->dsize = rd.dsize;
 139
 140     if (pvalue->dptr)
 141         apr_pool_cleanup_register(dbm->pool, pvalue->dptr, datum_cleanup,
 142                                   apr_pool_cleanup_null);
 143
 144     /* store the error info into DBM, and return a status code. Also, note
 145        that *pvalue should have been cleared on error. */
 146     return set_error(dbm, APR_SUCCESS);
 147 }
 148
 149 static apr_status_t vt_gdbm_store(apr_dbm_t *dbm, apr_datum_t key,
 150                                   apr_datum_t value)
 151 {
 152     int rc;
 153     datum kd, vd;
 154
 155     kd.dptr = key.dptr;
 156     kd.dsize = key.dsize;
 157
 158     vd.dptr = value.dptr;
 159     vd.dsize = value.dsize;
 160
 161     rc = gdbm_store(dbm->file, kd, vd, GDBM_REPLACE);
 162
 163     /* store any error info into DBM, and return a status code. */
 164     return set_error(dbm, g2s(rc));
 165 }
 166
 167 static apr_status_t vt_gdbm_del(apr_dbm_t *dbm, apr_datum_t key)
 168 {
 169     int rc;
 170     datum kd;
 171
 172     kd.dptr = key.dptr;
 173     kd.dsize = key.dsize;
 174
 175     rc = gdbm_delete(dbm->file, kd);
 176
 177     /* store any error info into DBM, and return a status code. */
 178     return set_error(dbm, g2s(rc));
 179 }
 180
 181 static int vt_gdbm_exists(apr_dbm_t *dbm, apr_datum_t key)
 182 {
 183     datum kd;
 184
 185     kd.dptr = key.dptr;
 186     kd.dsize = key.dsize;
 187
 188     return gdbm_exists(dbm->file, kd) != 0;
 189 }
 190
 191 static apr_status_t vt_gdbm_firstkey(apr_dbm_t *dbm, apr_datum_t *pkey)
 192 {
 193     datum rd;
 194
 195     rd = gdbm_firstkey(dbm->file);
 196
 197     pkey->dptr = rd.dptr;
 198     pkey->dsize = rd.dsize;
 199
 200     if (pkey->dptr)
 201         apr_pool_cleanup_register(dbm->pool, pkey->dptr, datum_cleanup,
 202                                   apr_pool_cleanup_null);
 203
 204     /* store any error info into DBM, and return a status code. */
 205     return set_error(dbm, APR_SUCCESS);
 206 }
 207
 208 static apr_status_t vt_gdbm_nextkey(apr_dbm_t *dbm, apr_datum_t *pkey)
 209 {
 210     datum kd, rd;
 211
 212     kd.dptr = pkey->dptr;
 213     kd.dsize = pkey->dsize;
 214
 215     rd = gdbm_nextkey(dbm->file, kd);
 216
 217     pkey->dptr = rd.dptr;
 218     pkey->dsize = rd.dsize;
 219
 220     if (pkey->dptr)
 221         apr_pool_cleanup_register(dbm->pool, pkey->dptr, datum_cleanup,
 222                                   apr_pool_cleanup_null);
 223
 224     /* store any error info into DBM, and return a status code. */
 225     return set_error(dbm, APR_SUCCESS);
 226 }
 227
 228 static void vt_gdbm_freedatum(apr_dbm_t *dbm, apr_datum_t data)
 229 {
 230     (void) apr_pool_cleanup_run(dbm->pool, data.dptr, datum_cleanup);
 231 }
 232
 233 static void vt_gdbm_usednames(apr_pool_t *pool, const char *pathname,
 234                               const char **used1, const char **used2)
 235 {
 236     *used1 = apr_pstrdup(pool, pathname);
 237     *used2 = NULL;
 238 }
 239
 240 APU_DECLARE_DATA const apr_dbm_type_t apr_dbm_type_gdbm = {
 241     "gdbm",
 242     vt_gdbm_open,
 243     vt_gdbm_close,
 244     vt_gdbm_fetch,
 245     vt_gdbm_store,
 246     vt_gdbm_del,
 247     vt_gdbm_exists,
 248     vt_gdbm_firstkey,
 249     vt_gdbm_nextkey,
 250     vt_gdbm_freedatum,
 251     vt_gdbm_usednames
 252 };
 253
 254 #endif /* APU_HAVE_GDBM */