lib/hdb/hdb-mdb.c

   1 /*
   2  * Copyright (c) 1997 - 2006 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * Copyright (c) 2011 - Howard Chu, Symas Corp.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * 3. Neither the name of the Institute nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include "hdb_locl.h"
  36
  37 #if HAVE_LMDB
  38
  39 /* LMDB */
  40
  41 #include <lmdb.h>
  42
  43 #define KILO    1024
  44
  45 typedef struct mdb_info {
  46     MDB_env *e;
  47     MDB_txn *t;
  48     MDB_dbi d;
  49     MDB_cursor *c;
  50 } mdb_info;
  51
  52 static krb5_error_code
  53 DB_close(krb5_context context, HDB *db)
  54 {
  55     mdb_info *mi = (mdb_info *)db->hdb_db;
  56
  57     mdb_cursor_close(mi->c);
  58     mdb_txn_abort(mi->t);
  59     mdb_env_close(mi->e);
  60     mi->c = 0;
  61     mi->t = 0;
  62     mi->e = 0;
  63     return 0;
  64 }
  65
  66 static krb5_error_code
  67 DB_destroy(krb5_context context, HDB *db)
  68 {
  69     krb5_error_code ret;
  70
  71     ret = hdb_clear_master_key (context, db);
  72     free(db->hdb_name);
  73     free(db->hdb_db);
  74     free(db);
  75     return ret;
  76 }
  77
  78 static krb5_error_code
  79 DB_lock(krb5_context context, HDB *db, int operation)
  80 {
  81     db->lock_count++;
  82     return 0;
  83 }
  84
  85 static krb5_error_code
  86 DB_unlock(krb5_context context, HDB *db)
  87 {
  88     if (db->lock_count > 1) {
  89         db->lock_count--;
  90         return 0;
  91     }
  92     heim_assert(db->lock_count == 1, "HDB lock/unlock sequence does not match");
  93     db->lock_count--;
  94     return 0;
  95 }
  96
  97
  98 static krb5_error_code
  99 DB_seq(krb5_context context, HDB *db,
 100        unsigned flags, hdb_entry_ex *entry, int flag)
 101 {
 102     mdb_info *mi = db->hdb_db;
 103     MDB_val key, value;
 104     krb5_data key_data, data;
 105     int code;
 106
 107     key.mv_size = 0;
 108     value.mv_size = 0;
 109     code = mdb_cursor_get(mi->c, &key, &value, flag);
 110     if (code == MDB_NOTFOUND)
 111         return HDB_ERR_NOENTRY;
 112     if (code)
 113         return code;
 114
 115     key_data.data = key.mv_data;
 116     key_data.length = key.mv_size;
 117     data.data = value.mv_data;
 118     data.length = value.mv_size;
 119     memset(entry, 0, sizeof(*entry));
 120     if (hdb_value2entry(context, &data, &entry->entry))
 121         return DB_seq(context, db, flags, entry, MDB_NEXT);
 122     if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) {
 123         code = hdb_unseal_keys (context, db, &entry->entry);
 124         if (code)
 125             hdb_free_entry (context, entry);
 126     }
 127     if (entry->entry.principal == NULL) {
 128         entry->entry.principal = malloc(sizeof(*entry->entry.principal));
 129         if (entry->entry.principal == NULL) {
 130             hdb_free_entry (context, entry);
 131             krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 132             return ENOMEM;
 133         } else {
 134             hdb_key2principal(context, &key_data, entry->entry.principal);
 135         }
 136     }
 137     return 0;
 138 }
 139
 140
 141 static krb5_error_code
 142 DB_firstkey(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
 143 {
 144     mdb_info *mi = db->hdb_db;
 145     int code;
 146
 147     /* Always start with a fresh cursor to pick up latest DB state */
 148     if (mi->t)
 149         mdb_txn_abort(mi->t);
 150
 151     code = mdb_txn_begin(mi->e, NULL, MDB_RDONLY, &mi->t);
 152     if (code)
 153         return code;
 154
 155     code = mdb_cursor_open(mi->t, mi->d, &mi->c);
 156     if (code)
 157         return code;
 158
 159     return DB_seq(context, db, flags, entry, MDB_FIRST);
 160 }
 161
 162
 163 static krb5_error_code
 164 DB_nextkey(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
 165 {
 166     return DB_seq(context, db, flags, entry, MDB_NEXT);
 167 }
 168
 169 static krb5_error_code
 170 DB_rename(krb5_context context, HDB *db, const char *new_name)
 171 {
 172     int ret;
 173     char *old, *new;
 174
 175     if (strncmp(new_name, "mdb:", sizeof("mdb:") - 1) == 0)
 176         new_name += sizeof("mdb:") - 1;
 177     else if (strncmp(new_name, "lmdb:", sizeof("lmdb:") - 1) == 0)
 178         new_name += sizeof("lmdb:") - 1;
 179     if (asprintf(&old, "%s.mdb", db->hdb_name) == -1)
 180                 return ENOMEM;
 181     if (asprintf(&new, "%s.mdb", new_name) == -1) {
 182                 free(old);
 183                 return ENOMEM;
 184     }
 185     ret = rename(old, new);
 186     free(old);
 187     free(new);
 188     if(ret)
 189         return errno;
 190
 191     free(db->hdb_name);
 192     db->hdb_name = strdup(new_name);
 193     return 0;
 194 }
 195
 196 static krb5_error_code
 197 DB__get(krb5_context context, HDB *db, krb5_data key, krb5_data *reply)
 198 {
 199     mdb_info *mi = (mdb_info*)db->hdb_db;
 200     MDB_txn *txn;
 201     MDB_val k, v;
 202     int code;
 203
 204     k.mv_data = key.data;
 205     k.mv_size = key.length;
 206
 207     code = mdb_txn_begin(mi->e, NULL, MDB_RDONLY, &txn);
 208     if (code)
 209         return code;
 210
 211     code = mdb_get(txn, mi->d, &k, &v);
 212     if (code == 0)
 213         krb5_data_copy(reply, v.mv_data, v.mv_size);
 214     mdb_txn_abort(txn);
 215     if(code == MDB_NOTFOUND)
 216         return HDB_ERR_NOENTRY;
 217     return code;
 218 }
 219
 220 static krb5_error_code
 221 DB__put(krb5_context context, HDB *db, int replace,
 222         krb5_data key, krb5_data value)
 223 {
 224     mdb_info *mi = (mdb_info*)db->hdb_db;
 225     MDB_txn *txn;
 226     MDB_val k, v;
 227     int code;
 228
 229     k.mv_data = key.data;
 230     k.mv_size = key.length;
 231     v.mv_data = value.data;
 232     v.mv_size = value.length;
 233
 234     code = mdb_txn_begin(mi->e, NULL, 0, &txn);
 235     if (code)
 236         return code;
 237
 238     code = mdb_put(txn, mi->d, &k, &v, replace ? 0 : MDB_NOOVERWRITE);
 239     if (code)
 240         mdb_txn_abort(txn);
 241     else
 242         code = mdb_txn_commit(txn);
 243     if(code == MDB_KEYEXIST)
 244         return HDB_ERR_EXISTS;
 245     return code;
 246 }
 247
 248 static krb5_error_code
 249 DB__del(krb5_context context, HDB *db, krb5_data key)
 250 {
 251     mdb_info *mi = (mdb_info*)db->hdb_db;
 252     MDB_txn *txn;
 253     MDB_val k;
 254     krb5_error_code code;
 255
 256     k.mv_data = key.data;
 257     k.mv_size = key.length;
 258
 259     code = mdb_txn_begin(mi->e, NULL, 0, &txn);
 260     if (code)
 261         return code;
 262
 263     code = mdb_del(txn, mi->d, &k, NULL);
 264     if (code)
 265         mdb_txn_abort(txn);
 266     else
 267         code = mdb_txn_commit(txn);
 268     if(code == MDB_NOTFOUND)
 269         return HDB_ERR_NOENTRY;
 270     return code;
 271 }
 272
 273 static krb5_error_code
 274 DB_open(krb5_context context, HDB *db, int flags, mode_t mode)
 275 {
 276     mdb_info *mi = (mdb_info *)db->hdb_db;
 277     MDB_txn *txn;
 278     char *fn;
 279     krb5_error_code ret;
 280     int myflags = MDB_NOSUBDIR, tmp;
 281
 282     if((flags & O_ACCMODE) == O_RDONLY)
 283       myflags |= MDB_RDONLY;
 284
 285     if (asprintf(&fn, "%s.mdb", db->hdb_name) == -1) {
 286         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 287         return ENOMEM;
 288     }
 289     if (mdb_env_create(&mi->e)) {
 290         free(fn);
 291         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 292         return ENOMEM;
 293     }
 294
 295     tmp = krb5_config_get_int_default(context, NULL, 0, "kdc",
 296         "hdb-mdb-maxreaders", NULL);
 297     if (tmp) {
 298         ret = mdb_env_set_maxreaders(mi->e, tmp);
 299         if (ret) {
 300             krb5_set_error_message(context, ret, "setting maxreaders on %s: %s",
 301                 db->hdb_name, mdb_strerror(ret));
 302             return ret;
 303         }
 304     }
 305
 306     tmp = krb5_config_get_int_default(context, NULL, 0, "kdc",
 307         "hdb-mdb-mapsize", NULL);
 308     if (tmp) {
 309         size_t maps = tmp;
 310         maps *= KILO;
 311         ret = mdb_env_set_mapsize(mi->e, maps);
 312         if (ret) {
 313             krb5_set_error_message(context, ret, "setting mapsize on %s: %s",
 314                 db->hdb_name, mdb_strerror(ret));
 315             return ret;
 316         }
 317     }
 318
 319     ret = mdb_env_open(mi->e, fn, myflags, mode);
 320     if (ret) {
 321 fail:
 322         mdb_env_close(mi->e);
 323         mi->e = 0;
 324         free(fn);
 325         krb5_set_error_message(context, ret, "opening %s: %s",
 326                               db->hdb_name, mdb_strerror(ret));
 327         return ret;
 328     }
 329     free(fn);
 330
 331     ret = mdb_txn_begin(mi->e, NULL, MDB_RDONLY, &txn);
 332     if (ret)
 333         goto fail;
 334
 335     ret = mdb_open(txn, NULL, 0, &mi->d);
 336     mdb_txn_abort(txn);
 337     if (ret)
 338         goto fail;
 339
 340     if((flags & O_ACCMODE) == O_RDONLY)
 341         ret = hdb_check_db_format(context, db);
 342     else
 343         ret = hdb_init_db(context, db);
 344     if(ret == HDB_ERR_NOENTRY)
 345         return 0;
 346     if (ret) {
 347         DB_close(context, db);
 348         krb5_set_error_message(context, ret, "hdb_open: failed %s database %s",
 349                                (flags & O_ACCMODE) == O_RDONLY ?
 350                                "checking format of" : "initialize",
 351                                db->hdb_name);
 352     }
 353
 354     return ret;
 355 }
 356
 357 krb5_error_code
 358 hdb_mdb_create(krb5_context context, HDB **db,
 359               const char *filename)
 360 {
 361     *db = calloc(1, sizeof(**db));
 362     if (*db == NULL) {
 363         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 364         return ENOMEM;
 365     }
 366
 367     (*db)->hdb_db = calloc(1, sizeof(mdb_info));
 368     if ((*db)->hdb_db == NULL) {
 369         free(*db);
 370         *db = NULL;
 371         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 372         return ENOMEM;
 373     }
 374     (*db)->hdb_name = strdup(filename);
 375     if ((*db)->hdb_name == NULL) {
 376         free((*db)->hdb_db);
 377         free(*db);
 378         *db = NULL;
 379         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 380         return ENOMEM;
 381     }
 382     (*db)->hdb_master_key_set = 0;
 383     (*db)->hdb_openp = 0;
 384     (*db)->hdb_capability_flags = HDB_CAP_F_HANDLE_ENTERPRISE_PRINCIPAL;
 385     (*db)->hdb_open  = DB_open;
 386     (*db)->hdb_close = DB_close;
 387     (*db)->hdb_fetch_kvno = _hdb_fetch_kvno;
 388     (*db)->hdb_store = _hdb_store;
 389     (*db)->hdb_remove = _hdb_remove;
 390     (*db)->hdb_firstkey = DB_firstkey;
 391     (*db)->hdb_nextkey= DB_nextkey;
 392     (*db)->hdb_lock = DB_lock;
 393     (*db)->hdb_unlock = DB_unlock;
 394     (*db)->hdb_rename = DB_rename;
 395     (*db)->hdb__get = DB__get;
 396     (*db)->hdb__put = DB__put;
 397     (*db)->hdb__del = DB__del;
 398     (*db)->hdb_destroy = DB_destroy;
 399     return 0;
 400 }
 401 #endif /* HAVE_LMDB */