etc/cnid_dbd/dbif.c

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