etc/cnid_dbd/dbif.c

   1 /*
   2  * $Id: dbif.c,v 1.6 2009-04-21 10:18: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) {
 208         if (db_env->log_archive(db_env, &logfiles, 0)) {
 209             LOG(log_error, logtype_cnid, "error getting list of stale logfiles: %s",
 210                 db_strerror(ret));
 211             db_env->close(db_env, 0);
 212             db_env = NULL;
 213             return -1;
 214         }
 215         if (logfiles != NULL) {
 216             for (file = logfiles; *file != NULL; file++) {
 217                 if (unlink(*file) < 0)
 218                     LOG(log_warning, logtype_cnid, "Error removing stale logfile %s: %s", *file, strerror(errno));
 219             }
 220             free(logfiles);
 221         }
 222
 223 #if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 7)
 224         if ((ret = db_env->log_set_config(db_env, DB_LOG_AUTO_REMOVE, 1))) {
 225             LOG(log_error, logtype_cnid, "error setting DB_LOG_AUTO_REMOVE flag: %s",
 226             db_strerror(ret));
 227             db_env->close(db_env, 0);
 228             db_env = NULL;
 229             return -1;
 230         }
 231 #else
 232         if ((ret = db_env->set_flags(db_env, DB_LOG_AUTOREMOVE, 1))) {
 233             LOG(log_error, logtype_cnid, "error setting DB_LOG_AUTOREMOVE flag: %s",
 234                 db_strerror(ret));
 235             db_env->close(db_env, 0);
 236             db_env = NULL;
 237             return -1;
 238         }
 239 #endif
 240     }
 241
 242     return 0;
 243 }
 244
 245 /* --------------- */
 246 int dbif_open(struct db_param *dbp _U_, int do_truncate)
 247 {
 248     int ret;
 249     int i;
 250     u_int32_t count;
 251
 252     for (i = 0; i != DBIF_DB_CNT; i++) {
 253         if ((ret = db_create(&(db_table[i].db), db_env, 0))) {
 254             LOG(log_error, logtype_cnid, "error creating handle for database %s: %s",
 255                 db_table[i].name, db_strerror(ret));
 256             return -1;
 257         }
 258
 259         if (db_table[i].general_flags) {
 260             if ((ret = db_table[i].db->set_flags(db_table[i].db, db_table[i].general_flags))) {
 261                 LOG(log_error, logtype_cnid, "error setting flags for database %s: %s",
 262                     db_table[i].name, db_strerror(ret));
 263                 return -1;
 264             }
 265         }
 266
 267         if (db_compat_open(db_table[i].db, db_table[0].name, db_table[i].name, db_table[i].type, 0664) < 0)
 268             return -1;
 269         if (db_errlog != NULL)
 270             db_table[i].db->set_errfile(db_table[i].db, db_errlog);
 271
 272         if (do_truncate && i > 0) {
 273             if ((ret = db_table[i].db->truncate(db_table[i].db, NULL, &count, 0))) {
 274                 LOG(log_error, logtype_cnid, "error truncating database %s: %s",
 275                     db_table[i].name, db_strerror(ret));
 276                 return -1;
 277             }
 278         }
 279     }
 280
 281     /* TODO: Implement CNID DB versioning info on new databases. */
 282
 283     /* Associate the secondary with the primary. */
 284     if ((ret = db_compat_associate(db_table[0].db, db_table[DBIF_IDX_DIDNAME].db, didname, (do_truncate)?DB_CREATE:0)) != 0) {
 285         LOG(log_error, logtype_cnid, "Failed to associate didname database: %s",db_strerror(ret));
 286         return -1;
 287     }
 288
 289     if ((ret = db_compat_associate(db_table[0].db, db_table[DBIF_IDX_DEVINO].db, devino, (do_truncate)?DB_CREATE:0)) != 0) {
 290         LOG(log_error, logtype_cnid, "Failed to associate devino database: %s",db_strerror(ret));
 291         return -1;
 292     }
 293
 294     return 0;
 295 }
 296
 297 /* ------------------------ */
 298 int dbif_closedb()
 299 {
 300     int i;
 301     int ret;
 302     int err = 0;
 303
 304     for (i = DBIF_DB_CNT -1; i >= 0; i--) {
 305         if (db_table[i].db != NULL && (ret = db_table[i].db->close(db_table[i].db, 0))) {
 306             LOG(log_error, logtype_cnid, "error closing database %s: %s", db_table[i].name, db_strerror(ret));
 307             err++;
 308         }
 309     }
 310     if (err)
 311         return -1;
 312     return 0;
 313 }
 314
 315 /* ------------------------ */
 316 int dbif_close()
 317 {
 318     int ret;
 319     int err = 0;
 320
 321     if (dbif_closedb())
 322         err++;
 323
 324     if (db_env != NULL && (ret = db_env->close(db_env, 0))) {
 325         LOG(log_error, logtype_cnid, "error closing DB environment: %s", db_strerror(ret));
 326         err++;
 327     }
 328     if (db_errlog != NULL && fclose(db_errlog) == EOF) {
 329         LOG(log_error, logtype_cnid, "error closing DB logfile: %s", strerror(errno));
 330         err++;
 331     }
 332     if (err)
 333         return -1;
 334     return 0;
 335 }
 336
 337 /*
 338  *  The following three functions are wrappers for DB->get(), DB->put() and DB->del().
 339  *  All three return -1 on error. dbif_get()/dbif_del return 1 if the key was found and 0
 340  *  otherwise. dbif_put() returns 0 if key/val was successfully updated and 1 if
 341  *  the DB_NOOVERWRITE flag was specified and the key already exists.
 342  *
 343  *  All return codes other than DB_NOTFOUND and DB_KEYEXIST from the DB->()
 344  *  functions are not expected and therefore error conditions.
 345  */
 346
 347 int dbif_get(const int dbi, DBT *key, DBT *val, u_int32_t flags)
 348 {
 349     int ret;
 350     DB *db = db_table[dbi].db;
 351
 352     ret = db->get(db, db_txn, key, val, flags);
 353
 354     if (ret == DB_NOTFOUND)
 355         return 0;
 356     if (ret) {
 357         LOG(log_error, logtype_cnid, "error retrieving value from %s: %s", db_table[dbi].name, db_strerror(errno));
 358         return -1;
 359     } else
 360         return 1;
 361 }
 362
 363 /* search by secondary return primary */
 364 int dbif_pget(const int dbi, DBT *key, DBT *pkey, DBT *val, u_int32_t flags)
 365 {
 366     int ret;
 367     DB *db = db_table[dbi].db;
 368
 369     ret = db->pget(db, db_txn, key, pkey, val, flags);
 370
 371     if (ret == DB_NOTFOUND || ret == DB_SECONDARY_BAD) {
 372         return 0;
 373     }
 374     if (ret) {
 375         LOG(log_error, logtype_cnid, "error retrieving value from %s: %s", db_table[dbi].name, db_strerror(errno));
 376         return -1;
 377    } else
 378         return 1;
 379 }
 380
 381 /* -------------------------- */
 382 int dbif_put(const int dbi, DBT *key, DBT *val, u_int32_t flags)
 383 {
 384     int ret;
 385     DB *db = db_table[dbi].db;
 386
 387     if (dbif_txn_begin() < 0) {
 388         LOG(log_error, logtype_cnid, "error setting key/value in %s: %s", db_table[dbi].name, db_strerror(errno));
 389         return -1;
 390     }
 391
 392     ret = db->put(db, db_txn, key, val, flags);
 393
 394     if (ret) {
 395         if ((flags & DB_NOOVERWRITE) && ret == DB_KEYEXIST) {
 396             return 1;
 397         } else {
 398             LOG(log_error, logtype_cnid, "error setting key/value in %s: %s", db_table[dbi].name, db_strerror(errno));
 399             return -1;
 400         }
 401     } else
 402         return 0;
 403 }
 404
 405 int dbif_del(const int dbi, DBT *key, u_int32_t flags)
 406 {
 407     int ret;
 408     DB *db = db_table[dbi].db;
 409
 410     if (dbif_txn_begin() < 0) {
 411         LOG(log_error, logtype_cnid, "error deleting key/value from %s: %s", db_table[dbi].name, db_strerror(errno));
 412         return -1;
 413     }
 414
 415     ret = db->del(db, db_txn, key, flags);
 416
 417     if (ret == DB_NOTFOUND || ret == DB_SECONDARY_BAD)
 418         return 0;
 419     if (ret) {
 420         LOG(log_error, logtype_cnid, "error deleting key/value from %s: %s", db_table[dbi].name, db_strerror(errno));
 421         return -1;
 422     } else
 423         return 1;
 424 }
 425
 426 int dbif_txn_begin()
 427 {
 428     int ret;
 429
 430     /* If we already have a acitve txn, just return */
 431     if (db_txn)
 432         return 0;
 433
 434     ret = db_env->txn_begin(db_env, NULL, &db_txn, 0);
 435
 436     if (ret) {
 437         LOG(log_error, logtype_cnid, "error starting transaction: %s", db_strerror(errno));
 438         return -1;
 439     } else
 440         return 0;
 441 }
 442
 443 int dbif_txn_commit()
 444 {
 445     int ret;
 446
 447     if (!db_txn)
 448         return 0;
 449
 450     ret = db_txn->commit(db_txn, 0);
 451     db_txn = NULL;
 452
 453     if (ret) {
 454         LOG(log_error, logtype_cnid, "error committing transaction: %s", db_strerror(errno));
 455         return -1;
 456     } else
 457         return 1;
 458 }
 459
 460 int dbif_txn_abort()
 461 {
 462     int ret;
 463
 464     if (!db_txn)
 465         return 0;
 466
 467     ret = db_txn->abort(db_txn);
 468     db_txn = NULL;
 469
 470     if (ret) {
 471         LOG(log_error, logtype_cnid, "error aborting transaction: %s", db_strerror(errno));
 472         return -1;
 473     } else
 474         return 0;
 475 }
 476
 477 int dbif_txn_checkpoint(u_int32_t kbyte, u_int32_t min, u_int32_t flags)
 478 {
 479     int ret;
 480     ret = db_env->txn_checkpoint(db_env, kbyte, min, flags);
 481     if (ret) {
 482         LOG(log_error, logtype_cnid, "error checkpointing transaction susystem: %s", db_strerror(errno));
 483         return -1;
 484     } else
 485         return 0;
 486 }
 487
 488 int dbif_count(const int dbi, u_int32_t *count)
 489 {
 490     int ret;
 491     DB_BTREE_STAT *sp;
 492     DB *db = db_table[dbi].db;
 493
 494     ret = db->stat(db, NULL, &sp, 0);
 495
 496     if (ret) {
 497         LOG(log_error, logtype_cnid, "error getting stat infotmation on database: %s", db_strerror(errno));
 498         return -1;
 499     }
 500
 501     *count = sp->bt_ndata;
 502     free(sp);
 503
 504     return 0;
 505 }
 506
 507