etc/cnid_dbd/dbif.c

   1 /*
   2  * $Id: dbif.c,v 1.5 2009-04-21 08:55:44 franklahm Exp $
   3  *
   4  * Copyright (C) Joerg Lenneis 2003
   5  * All Rights Reserved.  See COPYING.
   6  */
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include "config.h"
  10 #endif /* HAVE_CONFIG_H */
  11
  12 #include <stdio.h>
  13 #include <errno.h>
  14 #include <stdlib.h>
  15 #ifdef HAVE_SYS_TYPES_H
  16 #include <sys/types.h>
  17 #endif /* HAVE_SYS_TYPES_H */
  18 #include <string.h>
  19 #include <sys/types.h>
  20 #include <sys/stat.h>
  21 #include <sys/cdefs.h>
  22 #include <unistd.h>
  23 #include <atalk/logger.h>
  24 #include <db.h>
  25 #include "db_param.h"
  26 #include "dbif.h"
  27
  28 #define DB_ERRLOGFILE "db_errlog"
  29
  30 static DB_ENV *db_env = NULL;
  31 static DB_TXN *db_txn = NULL;
  32 static FILE   *db_errlog = NULL;
  33
  34 /*
  35    Note: DB_INIT_LOCK is here so we can run the db_* utilities while netatalk is running.
  36    It's a likey performance hit, but it might we worth it.
  37  */
  38 #define DBOPTIONS    (DB_CREATE | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_LOCK | DB_INIT_TXN)
  39
  40 static struct db_table {
  41     char            *name;
  42     DB              *db;
  43     u_int32_t       general_flags;
  44     DBTYPE          type;
  45 } db_table[] =
  46 {
  47     { "cnid2.db",       NULL,      0, DB_BTREE},
  48     { "devino.db",      NULL,      0, DB_BTREE},
  49     { "didname.db",     NULL,      0, DB_BTREE},
  50 };
  51
  52 static char *old_dbfiles[] = {"cnid.db", NULL};
  53
  54 extern int didname(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey);
  55 extern int devino(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey);
  56
  57 /* --------------- */
  58 static int  db_compat_associate (DB *p, DB *s,
  59                                  int (*callback)(DB *, const DBT *,const DBT *, DBT *),
  60                                  u_int32_t flags)
  61 {
  62     return p->associate(p, NULL, s, callback, flags);
  63 }
  64
  65 /* --------------- */
  66 static int db_compat_open(DB *db, char *file, char *name, DBTYPE type, int mode)
  67 {
  68     int ret;
  69
  70     ret = db->open(db, NULL, file, name, type, DB_CREATE, mode);
  71
  72     if (ret) {
  73         LOG(log_error, logtype_cnid, "error opening database %s: %s", name, db_strerror(ret));
  74         return -1;
  75     } else {
  76         return 0;
  77     }
  78 }
  79
  80 /* --------------- */
  81 static int upgrade_required()
  82 {
  83     int i;
  84     int found = 0;
  85     struct stat st;
  86
  87     for (i = 0; old_dbfiles[i] != NULL; i++) {
  88         if ( !(stat(old_dbfiles[i], &st) < 0) ) {
  89             found++;
  90             continue;
  91         }
  92         if (errno != ENOENT) {
  93             LOG(log_error, logtype_cnid, "cnid_open: Checking %s gave %s", old_dbfiles[i], strerror(errno));
  94             found++;
  95         }
  96     }
  97     return found;
  98 }
  99
 100 /* --------------- */
 101 int dbif_stamp(void *buffer, int size)
 102 {
 103     struct stat st;
 104     int         rc;
 105
 106     if (size < 8)
 107         return -1;
 108
 109     if ((rc = stat(db_table[0].name, &st)) < 0) {
 110         LOG(log_error, logtype_cnid, "error stating database %s: %s", db_table[0].name, db_strerror(rc));
 111         return -1;
 112     }
 113     memset(buffer, 0, size);
 114     memcpy(buffer, &st.st_ctime, sizeof(st.st_ctime));
 115
 116     return 0;
 117 }
 118
 119 /* --------------- */
 120 /*
 121  *  We assume our current directory is already the BDB homedir. Otherwise
 122  *  opening the databases will not work as expected.
 123  */
 124 int dbif_env_init(struct db_param *dbp)
 125 {
 126     int ret;
 127     char **logfiles = NULL;
 128     char **file;
 129
 130     /* Refuse to do anything if this is an old version of the CNID database */
 131     if (upgrade_required()) {
 132         LOG(log_error, logtype_cnid, "Found version 1 of the CNID database. Please upgrade to version 2");
 133         return -1;
 134     }
 135
 136     if ((db_errlog = fopen(DB_ERRLOGFILE, "a")) == NULL)
 137         LOG(log_warning, logtype_cnid, "error creating/opening DB errlogfile: %s", strerror(errno));
 138
 139     if ((ret = db_env_create(&db_env, 0))) {
 140         LOG(log_error, logtype_cnid, "error creating DB environment: %s",
 141             db_strerror(ret));
 142         db_env = NULL;
 143         return -1;
 144     }
 145
 146     if (db_errlog != NULL) {
 147         db_env->set_errfile(db_env, db_errlog);
 148         db_env->set_msgfile(db_env, db_errlog);
 149     }
 150
 151     db_env->set_verbose(db_env, DB_VERB_RECOVERY, 1);
 152
 153     /* Open the database for recovery using DB_PRIVATE option which is faster */
 154     if ((ret = db_env->open(db_env, ".", DBOPTIONS | DB_PRIVATE | DB_RECOVER, 0))) {
 155         LOG(log_error, logtype_cnid, "error opening DB environment: %s",
 156             db_strerror(ret));
 157         db_env->close(db_env, 0);
 158         db_env = NULL;
 159         return -1;
 160     }
 161
 162     if (db_errlog != NULL)
 163         fflush(db_errlog);
 164
 165     if ((ret = db_env->close(db_env, 0))) {
 166         LOG(log_error, logtype_cnid, "error closing DB environment after recovery: %s",
 167             db_strerror(ret));
 168         db_env = NULL;
 169         return -1;
 170     }
 171
 172     if ((ret = db_env_create(&db_env, 0))) {
 173         LOG(log_error, logtype_cnid, "error creating DB environment after recovery: %s",
 174             db_strerror(ret));
 175         db_env = NULL;
 176         return -1;
 177     }
 178
 179     if ((ret = db_env->set_cachesize(db_env, 0, 1024 * dbp->cachesize, 0))) {
 180         LOG(log_error, logtype_cnid, "error setting DB environment cachesize to %i: %s",
 181             dbp->cachesize, db_strerror(ret));
 182         db_env->close(db_env, 0);
 183         db_env = NULL;
 184         return -1;
 185     }
 186
 187     if (db_errlog != NULL) {
 188         db_env->set_errfile(db_env, db_errlog);
 189         db_env->set_msgfile(db_env, db_errlog);
 190     }
 191     if ((ret = db_env->open(db_env, ".", DBOPTIONS , 0))) {
 192         LOG(log_error, logtype_cnid, "error opening DB environment after recovery: %s",
 193             db_strerror(ret));
 194         db_env->close(db_env, 0);
 195         db_env = NULL;
 196         return -1;
 197     }
 198
 199     if ((ret = db_env->set_flags(db_env, DB_AUTO_COMMIT, 1))) {
 200         LOG(log_error, logtype_cnid, "error setting DB_AUTO_COMMIT flag: %s",
 201             db_strerror(ret));
 202         db_env->close(db_env, 0);
 203         db_env = NULL;
 204         return -1;
 205     }
 206
 207     if (dbp->logfile_autoremove && db_env->log_archive(db_env, &logfiles, 0)) {
 208         LOG(log_error, logtype_cnid, "error getting list of stale logfiles: %s",
 209             db_strerror(ret));
 210         db_env->close(db_env, 0);
 211         db_env = NULL;
 212         return -1;
 213     }
 214     if (logfiles != NULL) {
 215         for (file = logfiles; *file != NULL; file++) {
 216             if (unlink(*file) < 0)
 217                 LOG(log_warning, logtype_cnid, "Error removing stale logfile %s: %s", *file, strerror(errno));
 218         }
 219         free(logfiles);
 220     }
 221
 222     return 0;
 223 }
 224
 225 /* --------------- */
 226 int dbif_open(struct db_param *dbp _U_, int do_truncate)
 227 {
 228     int ret;
 229     int i;
 230     u_int32_t count;
 231
 232     for (i = 0; i != DBIF_DB_CNT; i++) {
 233         if ((ret = db_create(&(db_table[i].db), db_env, 0))) {
 234             LOG(log_error, logtype_cnid, "error creating handle for database %s: %s",
 235                 db_table[i].name, db_strerror(ret));
 236             return -1;
 237         }
 238
 239         if (db_table[i].general_flags) {
 240             if ((ret = db_table[i].db->set_flags(db_table[i].db, db_table[i].general_flags))) {
 241                 LOG(log_error, logtype_cnid, "error setting flags for database %s: %s",
 242                     db_table[i].name, db_strerror(ret));
 243                 return -1;
 244             }
 245         }
 246
 247         if (db_compat_open(db_table[i].db, db_table[0].name, db_table[i].name, db_table[i].type, 0664) < 0)
 248             return -1;
 249         if (db_errlog != NULL)
 250             db_table[i].db->set_errfile(db_table[i].db, db_errlog);
 251
 252         if (do_truncate && i > 0) {
 253             if ((ret = db_table[i].db->truncate(db_table[i].db, NULL, &count, 0))) {
 254                 LOG(log_error, logtype_cnid, "error truncating database %s: %s",
 255                     db_table[i].name, db_strerror(ret));
 256                 return -1;
 257             }
 258         }
 259     }
 260
 261     /* TODO: Implement CNID DB versioning info on new databases. */
 262
 263     /* Associate the secondary with the primary. */
 264     if ((ret = db_compat_associate(db_table[0].db, db_table[DBIF_IDX_DIDNAME].db, didname, (do_truncate)?DB_CREATE:0)) != 0) {
 265         LOG(log_error, logtype_cnid, "Failed to associate didname database: %s",db_strerror(ret));
 266         return -1;
 267     }
 268
 269     if ((ret = db_compat_associate(db_table[0].db, db_table[DBIF_IDX_DEVINO].db, devino, (do_truncate)?DB_CREATE:0)) != 0) {
 270         LOG(log_error, logtype_cnid, "Failed to associate devino database: %s",db_strerror(ret));
 271         return -1;
 272     }
 273
 274     return 0;
 275 }
 276
 277 /* ------------------------ */
 278 int dbif_closedb()
 279 {
 280     int i;
 281     int ret;
 282     int err = 0;
 283
 284     for (i = DBIF_DB_CNT -1; i >= 0; i--) {
 285         if (db_table[i].db != NULL && (ret = db_table[i].db->close(db_table[i].db, 0))) {
 286             LOG(log_error, logtype_cnid, "error closing database %s: %s", db_table[i].name, db_strerror(ret));
 287             err++;
 288         }
 289     }
 290     if (err)
 291         return -1;
 292     return 0;
 293 }
 294
 295 /* ------------------------ */
 296 int dbif_close()
 297 {
 298     int ret;
 299     int err = 0;
 300
 301     if (dbif_closedb())
 302         err++;
 303
 304     if (db_env != NULL && (ret = db_env->close(db_env, 0))) {
 305         LOG(log_error, logtype_cnid, "error closing DB environment: %s", db_strerror(ret));
 306         err++;
 307     }
 308     if (db_errlog != NULL && fclose(db_errlog) == EOF) {
 309         LOG(log_error, logtype_cnid, "error closing DB logfile: %s", strerror(errno));
 310         err++;
 311     }
 312     if (err)
 313         return -1;
 314     return 0;
 315 }
 316
 317 /*
 318  *  The following three functions are wrappers for DB->get(), DB->put() and DB->del().
 319  *  All three return -1 on error. dbif_get()/dbif_del return 1 if the key was found and 0
 320  *  otherwise. dbif_put() returns 0 if key/val was successfully updated and 1 if
 321  *  the DB_NOOVERWRITE flag was specified and the key already exists.
 322  *
 323  *  All return codes other than DB_NOTFOUND and DB_KEYEXIST from the DB->()
 324  *  functions are not expected and therefore error conditions.
 325  */
 326
 327 int dbif_get(const int dbi, DBT *key, DBT *val, u_int32_t flags)
 328 {
 329     int ret;
 330     DB *db = db_table[dbi].db;
 331
 332     ret = db->get(db, db_txn, key, val, flags);
 333
 334     if (ret == DB_NOTFOUND)
 335         return 0;
 336     if (ret) {
 337         LOG(log_error, logtype_cnid, "error retrieving value from %s: %s", db_table[dbi].name, db_strerror(errno));
 338         return -1;
 339     } else
 340         return 1;
 341 }
 342
 343 /* search by secondary return primary */
 344 int dbif_pget(const int dbi, DBT *key, DBT *pkey, DBT *val, u_int32_t flags)
 345 {
 346     int ret;
 347     DB *db = db_table[dbi].db;
 348
 349     ret = db->pget(db, db_txn, key, pkey, val, flags);
 350
 351     if (ret == DB_NOTFOUND || ret == DB_SECONDARY_BAD) {
 352         return 0;
 353     }
 354     if (ret) {
 355         LOG(log_error, logtype_cnid, "error retrieving value from %s: %s", db_table[dbi].name, db_strerror(errno));
 356         return -1;
 357    } else
 358         return 1;
 359 }
 360
 361 /* -------------------------- */
 362 int dbif_put(const int dbi, DBT *key, DBT *val, u_int32_t flags)
 363 {
 364     int ret;
 365     DB *db = db_table[dbi].db;
 366
 367     if (dbif_txn_begin() < 0) {
 368         LOG(log_error, logtype_cnid, "error setting key/value in %s: %s", db_table[dbi].name, db_strerror(errno));
 369         return -1;
 370     }
 371
 372     ret = db->put(db, db_txn, key, val, flags);
 373
 374     if (ret) {
 375         if ((flags & DB_NOOVERWRITE) && ret == DB_KEYEXIST) {
 376             return 1;
 377         } else {
 378             LOG(log_error, logtype_cnid, "error setting key/value in %s: %s", db_table[dbi].name, db_strerror(errno));
 379             return -1;
 380         }
 381     } else
 382         return 0;
 383 }
 384
 385 int dbif_del(const int dbi, DBT *key, u_int32_t flags)
 386 {
 387     int ret;
 388     DB *db = db_table[dbi].db;
 389
 390     if (dbif_txn_begin() < 0) {
 391         LOG(log_error, logtype_cnid, "error deleting key/value from %s: %s", db_table[dbi].name, db_strerror(errno));
 392         return -1;
 393     }
 394
 395     ret = db->del(db, db_txn, key, flags);
 396
 397     if (ret == DB_NOTFOUND || ret == DB_SECONDARY_BAD)
 398         return 0;
 399     if (ret) {
 400         LOG(log_error, logtype_cnid, "error deleting key/value from %s: %s", db_table[dbi].name, db_strerror(errno));
 401         return -1;
 402     } else
 403         return 1;
 404 }
 405
 406 int dbif_txn_begin()
 407 {
 408     int ret;
 409
 410     /* If we already have a acitve txn, just return */
 411     if (db_txn)
 412         return 0;
 413
 414     ret = db_env->txn_begin(db_env, NULL, &db_txn, 0);
 415
 416     if (ret) {
 417         LOG(log_error, logtype_cnid, "error starting transaction: %s", db_strerror(errno));
 418         return -1;
 419     } else
 420         return 0;
 421 }
 422
 423 int dbif_txn_commit()
 424 {
 425     int ret;
 426
 427     if (!db_txn)
 428         return 0;
 429
 430     ret = db_txn->commit(db_txn, 0);
 431     db_txn = NULL;
 432
 433     if (ret) {
 434         LOG(log_error, logtype_cnid, "error committing transaction: %s", db_strerror(errno));
 435         return -1;
 436     } else
 437         return 1;
 438 }
 439
 440 int dbif_txn_abort()
 441 {
 442     int ret;
 443
 444     if (!db_txn)
 445         return 0;
 446
 447     ret = db_txn->abort(db_txn);
 448     db_txn = NULL;
 449
 450     if (ret) {
 451         LOG(log_error, logtype_cnid, "error aborting transaction: %s", db_strerror(errno));
 452         return -1;
 453     } else
 454         return 0;
 455 }
 456
 457 int dbif_txn_checkpoint(u_int32_t kbyte, u_int32_t min, u_int32_t flags)
 458 {
 459     int ret;
 460     ret = db_env->txn_checkpoint(db_env, kbyte, min, flags);
 461     if (ret) {
 462         LOG(log_error, logtype_cnid, "error checkpointing transaction susystem: %s", db_strerror(errno));
 463         return -1;
 464     } else
 465         return 0;
 466 }
 467
 468 int dbif_count(const int dbi, u_int32_t *count)
 469 {
 470     int ret;
 471     DB_BTREE_STAT *sp;
 472     DB *db = db_table[dbi].db;
 473
 474     ret = db->stat(db, NULL, &sp, 0);
 475
 476     if (ret) {
 477         LOG(log_error, logtype_cnid, "error getting stat infotmation on database: %s", db_strerror(errno));
 478         return -1;
 479     }
 480
 481     *count = sp->bt_ndata;
 482     free(sp);
 483
 484     return 0;
 485 }
 486
 487