citadel/database.c

   1 /*
   2  * This is a data store backend for the Citadel server which uses Berkeley DB.
   3  *
   4  * Copyright (c) 1987-2017 by the citadel.org team
   5  *
   6  * This program is open source software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License version 3.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 /*****************************************************************************
  16        Tunable configuration parameters for the Berkeley DB back end
  17  *****************************************************************************/
  18
  19 /* Citadel will checkpoint the db at the end of every session, but only if
  20  * the specified number of kilobytes has been written, or if the specified
  21  * number of minutes has passed, since the last checkpoint.
  22  */
  23 #define MAX_CHECKPOINT_KBYTES   256
  24 #define MAX_CHECKPOINT_MINUTES  15
  25
  26 /*****************************************************************************/
  27
  28 #include "sysdep.h"
  29 #include <stdlib.h>
  30 #include <unistd.h>
  31 #include <sys/stat.h>
  32 #include <stdio.h>
  33 #include <dirent.h>
  34 #include <zlib.h>
  35
  36 #ifdef HAVE_DB_H
  37 #include <db.h>
  38 #elif defined(HAVE_DB4_DB_H)
  39 #include <db5/db.h>
  40 #else
  41 #error Neither <db.h> nor <db5/db.h> was found by configure. Install db5-devel.
  42 #endif
  43
  44 #if DB_VERSION_MAJOR < 5
  45 #error Citadel requires Berkeley DB v5.0 or newer.  Please upgrade.
  46 #endif
  47
  48 #include <libcitadel.h>
  49
  50 #include "ctdl_module.h"
  51 #include "control.h"
  52 #include "citserver.h"
  53 #include "config.h"
  54
  55 static DB *dbp[MAXCDB];         /* One DB handle for each Citadel database */
  56 static DB_ENV *dbenv;           /* The DB environment (global) */
  57
  58
  59 void cdb_abort(void) {
  60         syslog(LOG_DEBUG, "db: citserver is stopping in order to prevent data loss. uid=%d gid=%d euid=%d egid=%d",
  61                 getuid(),
  62                 getgid(),
  63                 geteuid(),
  64                 getegid()
  65         );
  66         cit_backtrace();
  67         exit(CTDLEXIT_DB);
  68 }
  69
  70
  71 /* Verbose logging callback */
  72 void cdb_verbose_log(const DB_ENV *dbenv, const char *msg)
  73 {
  74         if (!IsEmptyStr(msg)) {
  75                 syslog(LOG_DEBUG, "db: %s", msg);
  76                 cit_backtrace();
  77         }
  78 }
  79
  80
  81 /* Verbose logging callback */
  82 void cdb_verbose_err(const DB_ENV *dbenv, const char *errpfx, const char *msg)
  83 {
  84         int *FOO = NULL;
  85         syslog(LOG_ERR, "db: %s", msg);
  86         cit_backtrace();
  87         *FOO = 1;
  88 }
  89
  90
  91 /* just a little helper function */
  92 static void txabort(DB_TXN * tid)
  93 {
  94         int ret;
  95
  96         ret = tid->abort(tid);
  97
  98         if (ret) {
  99                 syslog(LOG_ERR, "db: txn_abort: %s", db_strerror(ret));
 100                 cdb_abort();
 101         }
 102 }
 103
 104 /* this one is even more helpful than the last. */
 105 static void txcommit(DB_TXN * tid)
 106 {
 107         int ret;
 108
 109         ret = tid->commit(tid, 0);
 110
 111         if (ret) {
 112                 syslog(LOG_ERR, "db: txn_commit: %s", db_strerror(ret));
 113                 cdb_abort();
 114         }
 115 }
 116
 117 /* are you sensing a pattern yet? */
 118 static void txbegin(DB_TXN ** tid)
 119 {
 120         int ret;
 121
 122         ret = dbenv->txn_begin(dbenv, NULL, tid, 0);
 123
 124         if (ret) {
 125                 syslog(LOG_ERR, "db: txn_begin: %s", db_strerror(ret));
 126                 cdb_abort();
 127         }
 128 }
 129
 130 static void dbpanic(DB_ENV * env, int errval)
 131 {
 132         syslog(LOG_ERR, "db: PANIC: %s", db_strerror(errval));
 133         cit_backtrace();
 134 }
 135
 136 static void cclose(DBC * cursor)
 137 {
 138         int ret;
 139
 140         if ((ret = cursor->c_close(cursor))) {
 141                 syslog(LOG_ERR, "db: c_close: %s", db_strerror(ret));
 142                 cdb_abort();
 143         }
 144 }
 145
 146 static void bailIfCursor(DBC ** cursors, const char *msg)
 147 {
 148         int i;
 149
 150         for (i = 0; i < MAXCDB; i++)
 151                 if (cursors[i] != NULL) {
 152                         syslog(LOG_ERR, "db: cursor still in progress on cdb %02x: %s", i, msg);
 153                         cdb_abort();
 154                 }
 155 }
 156
 157
 158 void cdb_check_handles(void)
 159 {
 160         bailIfCursor(TSD->cursors, "in check_handles");
 161
 162         if (TSD->tid != NULL) {
 163                 syslog(LOG_ERR, "db: transaction still in progress!");
 164                 cdb_abort();
 165         }
 166 }
 167
 168
 169 /*
 170  * Cull the database logs by removing log files that are no longer needed.
 171  * Note: this code will be removed once we are confident that Berkeley DB can do this on its own.
 172  */
 173 void cdb_cull_logs(void)
 174 {
 175         u_int32_t flags;
 176         int ret;
 177         char **file, **list;
 178         char errmsg[SIZ];
 179
 180         flags = DB_ARCH_ABS;
 181
 182         /* Get the list of names. */
 183         if ((ret = dbenv->log_archive(dbenv, &list, flags)) != 0) {
 184                 syslog(LOG_ERR, "db: cdb_cull_logs() %s", db_strerror(ret));
 185                 return;
 186         }
 187
 188         /* Print the list of names. */
 189         if (list != NULL) {
 190                 for (file = list; *file != NULL; ++file) {
 191                         syslog(LOG_DEBUG, "db: deleting log %s", *file);
 192                         ret = unlink(*file);
 193                         if (ret != 0) {
 194                                 snprintf(errmsg, sizeof(errmsg),
 195                                          " ** ERROR **\n \n \n "
 196                                          "Citadel was unable to delete the "
 197                                          "database log file '%s' because of the "
 198                                          "following error:\n \n %s\n \n"
 199                                          " This log file is no longer in use "
 200                                          "and may be safely deleted.\n",
 201                                          *file, strerror(errno));
 202                                 CtdlAideMessage(errmsg, "Database Warning Message");
 203                         }
 204                 }
 205                 free(list);
 206         }
 207 }
 208
 209
 210 /*
 211  * Request a checkpoint of the database.  Called once per minute by the thread manager.
 212  */
 213 void cdb_checkpoint(void)
 214 {
 215         int ret;
 216
 217         syslog(LOG_DEBUG, "db: -- checkpoint --");
 218         ret = dbenv->txn_checkpoint(dbenv, MAX_CHECKPOINT_KBYTES, MAX_CHECKPOINT_MINUTES, 0);
 219
 220         if (ret != 0) {
 221                 syslog(LOG_ERR, "db: cdb_checkpoint() txn_checkpoint: %s", db_strerror(ret));
 222                 cdb_abort();
 223         }
 224
 225         /* After a successful checkpoint, we can cull the unused logs */
 226         if (CtdlGetConfigInt("c_auto_cull")) {
 227 #ifdef DB_LOG_AUTO_REMOVE
 228                 ret = dbenv->log_set_config(dbenv, DB_LOG_AUTO_REMOVE, 1);      // This version of Berkeley DB can cull the logs on its own!
 229 #else
 230                 cdb_cull_logs();                                                // Citadel knows how to do it too.
 231 #endif
 232         }
 233 #ifdef DB_LOG_AUTO_REMOVE
 234         else {
 235                 ret = dbenv->log_set_config(dbenv, DB_LOG_AUTO_REMOVE, 0);
 236         }
 237 #endif
 238 }
 239
 240
 241
 242 /*
 243  * Open the various databases we'll be using.  Any database which
 244  * does not exist should be created.  Note that we don't need a
 245  * critical section here, because there aren't any active threads
 246  * manipulating the database yet.
 247  */
 248 void open_databases(void)
 249 {
 250         int ret;
 251         int i;
 252         char dbfilename[32];
 253         u_int32_t flags = 0;
 254         int dbversion_major, dbversion_minor, dbversion_patch;
 255
 256         syslog(LOG_DEBUG, "db: open_databases() starting");
 257         syslog(LOG_DEBUG, "db: Compiled libdb: %s", DB_VERSION_STRING);
 258         syslog(LOG_DEBUG, "db:   Linked libdb: %s", db_version(&dbversion_major, &dbversion_minor, &dbversion_patch));
 259         syslog(LOG_DEBUG, "db:    Linked zlib: %s", zlibVersion());
 260
 261         /*
 262          * Silently try to create the database subdirectory.  If it's
 263          * already there, no problem.
 264          */
 265         if ((mkdir(ctdl_data_dir, 0700) != 0) && (errno != EEXIST)){
 266                 syslog(LOG_ERR, "db: unable to create database directory [%s]: %m", ctdl_data_dir);
 267         }
 268         if (chmod(ctdl_data_dir, 0700) != 0){
 269                 syslog(LOG_ERR, "db: unable to set database directory accessrights [%s]: %m", ctdl_data_dir);
 270         }
 271         if (chown(ctdl_data_dir, CTDLUID, (-1)) != 0){
 272                 syslog(LOG_ERR, "db: unable to set the owner for [%s]: %m", ctdl_data_dir);
 273         }
 274         syslog(LOG_DEBUG, "db: Setting up DB environment\n");
 275         /* db_env_set_func_yield((int (*)(u_long,  u_long))sched_yield); */
 276         ret = db_env_create(&dbenv, 0);
 277         if (ret) {
 278                 syslog(LOG_ERR, "db: db_env_create: %s", db_strerror(ret));
 279                 syslog(LOG_ERR, "db: exit code %d", ret);
 280                 exit(CTDLEXIT_DB);
 281         }
 282         dbenv->set_errpfx(dbenv, "citserver");
 283         dbenv->set_paniccall(dbenv, dbpanic);
 284         dbenv->set_errcall(dbenv, cdb_verbose_err);
 285         dbenv->set_errpfx(dbenv, "ctdl");
 286         dbenv->set_msgcall(dbenv, cdb_verbose_log);
 287         dbenv->set_verbose(dbenv, DB_VERB_DEADLOCK, 1);
 288         dbenv->set_verbose(dbenv, DB_VERB_RECOVERY, 1);
 289
 290         /*
 291          * We want to specify the shared memory buffer pool cachesize,
 292          * but everything else is the default.
 293          */
 294         ret = dbenv->set_cachesize(dbenv, 0, 64 * 1024, 0);
 295         if (ret) {
 296                 syslog(LOG_ERR, "db: set_cachesize: %s", db_strerror(ret));
 297                 dbenv->close(dbenv, 0);
 298                 syslog(LOG_ERR, "db: exit code %d", ret);
 299                 exit(CTDLEXIT_DB);
 300         }
 301
 302         if ((ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT))) {
 303                 syslog(LOG_ERR, "db: set_lk_detect: %s", db_strerror(ret));
 304                 dbenv->close(dbenv, 0);
 305                 syslog(LOG_ERR, "db: exit code %d", ret);
 306                 exit(CTDLEXIT_DB);
 307         }
 308
 309         flags = DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE | DB_INIT_TXN | DB_INIT_LOCK | DB_THREAD | DB_RECOVER;
 310         syslog(LOG_DEBUG, "db: dbenv->open(dbenv, %s, %d, 0)", ctdl_data_dir, flags);
 311         ret = dbenv->open(dbenv, ctdl_data_dir, flags, 0);
 312         if (ret == DB_RUNRECOVERY) {
 313                 syslog(LOG_ERR, "db: dbenv->open: %s", db_strerror(ret));
 314                 syslog(LOG_ERR, "db: attempting recovery...");
 315                 flags |= DB_RECOVER;
 316                 ret = dbenv->open(dbenv, ctdl_data_dir, flags, 0);
 317         }
 318         if (ret == DB_RUNRECOVERY) {
 319                 syslog(LOG_ERR, "db: dbenv->open: %s", db_strerror(ret));
 320                 syslog(LOG_ERR, "db: attempting catastrophic recovery...");
 321                 flags &= ~DB_RECOVER;
 322                 flags |= DB_RECOVER_FATAL;
 323                 ret = dbenv->open(dbenv, ctdl_data_dir, flags, 0);
 324         }
 325         if (ret) {
 326                 syslog(LOG_ERR, "db: dbenv->open: %s", db_strerror(ret));
 327                 dbenv->close(dbenv, 0);
 328                 syslog(LOG_ERR, "db: exit code %d", ret);
 329                 exit(CTDLEXIT_DB);
 330         }
 331
 332         syslog(LOG_INFO, "db: mounting databases");
 333
 334         for (i = 0; i < MAXCDB; ++i) {
 335
 336                 /* Create a database handle */
 337                 ret = db_create(&dbp[i], dbenv, 0);
 338                 if (ret) {
 339                         syslog(LOG_ERR, "db: db_create: %s", db_strerror(ret));
 340                         syslog(LOG_ERR, "db: exit code %d", ret);
 341                         exit(CTDLEXIT_DB);
 342                 }
 343
 344
 345                 /* Arbitrary names for our tables -- we reference them by
 346                  * number, so we don't have string names for them.
 347                  */
 348                 snprintf(dbfilename, sizeof dbfilename, "cdb.%02x", i);
 349
 350                 ret = dbp[i]->open(dbp[i],
 351                                    NULL,
 352                                    dbfilename,
 353                                    NULL,
 354                                    DB_BTREE,
 355                                    DB_CREATE | DB_AUTO_COMMIT | DB_THREAD,
 356                                    0600
 357                 );
 358                 if (ret) {
 359                         syslog(LOG_ERR, "db: db_open[%02x]: %s", i, db_strerror(ret));
 360                         if (ret == ENOMEM) {
 361                                 syslog(LOG_ERR, "db: You may need to tune your database; please read http://www.citadel.org/doku.php?id=faq:troubleshooting:out_of_lock_entries for more information.");
 362                         }
 363                         syslog(LOG_ERR, "db: exit code %d", ret);
 364                         exit(CTDLEXIT_DB);
 365                 }
 366         }
 367
 368 }
 369
 370
 371 /* Make sure we own all the files, because in a few milliseconds
 372  * we're going to drop root privs.
 373  */
 374 void cdb_chmod_data(void) {
 375         DIR *dp;
 376         struct dirent *d;
 377         char filename[PATH_MAX];
 378
 379         dp = opendir(ctdl_data_dir);
 380         if (dp != NULL) {
 381                 while (d = readdir(dp), d != NULL) {
 382                         if (d->d_name[0] != '.') {
 383                                 snprintf(filename, sizeof filename, "%s/%s", ctdl_data_dir, d->d_name);
 384                                 syslog(LOG_DEBUG, "db: chmod(%s, 0600) returned %d", filename, chmod(filename, 0600));
 385                                 syslog(LOG_DEBUG, "db: chown(%s, CTDLUID, -1) returned %d",
 386                                         filename, chown(filename, CTDLUID, (-1))
 387                                 );
 388                         }
 389                 }
 390                 closedir(dp);
 391         }
 392
 393         syslog(LOG_DEBUG, "db: open_databases() finished");
 394 }
 395
 396
 397 /*
 398  * Close all of the db database files we've opened.  This can be done
 399  * in a loop, since it's just a bunch of closes.
 400  */
 401 void close_databases(void)
 402 {
 403         int a;
 404         int ret;
 405
 406         syslog(LOG_INFO, "db: performing final checkpoint");
 407         if ((ret = dbenv->txn_checkpoint(dbenv, 0, 0, 0))) {
 408                 syslog(LOG_ERR, "txn_checkpoint: %s", db_strerror(ret));
 409         }
 410
 411         syslog(LOG_INFO, "db: flushing the database logs");
 412         if ((ret = dbenv->log_flush(dbenv, NULL))) {
 413                 syslog(LOG_ERR, "db: log_flush: %s", db_strerror(ret));
 414         }
 415
 416         /* print some statistics... */
 417 #ifdef DB_STAT_ALL
 418         dbenv->lock_stat_print(dbenv, DB_STAT_ALL);
 419 #endif
 420
 421         /* close the tables */
 422         for (a = 0; a < MAXCDB; ++a) {
 423                 syslog(LOG_INFO, "db: closing database %02x", a);
 424                 ret = dbp[a]->close(dbp[a], 0);
 425                 if (ret) {
 426                         syslog(LOG_ERR, "db: db_close: %s", db_strerror(ret));
 427                 }
 428
 429         }
 430
 431         /* Close the handle. */
 432         ret = dbenv->close(dbenv, 0);
 433         if (ret) {
 434                 syslog(LOG_EMERG, "db: DBENV->close: %s", db_strerror(ret));
 435         }
 436 }
 437
 438
 439 /*
 440  * Decompress a database item if it was compressed on disk
 441  */
 442 void cdb_decompress_if_necessary(struct cdbdata *cdb)
 443 {
 444         static int magic = COMPRESS_MAGIC;
 445
 446         if ((cdb == NULL) ||
 447             (cdb->ptr == NULL) ||
 448             (cdb->len < sizeof(magic)) ||
 449             (memcmp(cdb->ptr, &magic, sizeof(magic))))
 450             return;
 451
 452         /* At this point we know we're looking at a compressed item. */
 453
 454         struct CtdlCompressHeader zheader;
 455         char *uncompressed_data;
 456         char *compressed_data;
 457         uLongf destLen, sourceLen;
 458         size_t cplen;
 459
 460         memset(&zheader, 0, sizeof(struct CtdlCompressHeader));
 461         cplen = sizeof(struct CtdlCompressHeader);
 462         if (sizeof(struct CtdlCompressHeader) > cdb->len)
 463                 cplen = cdb->len;
 464         memcpy(&zheader, cdb->ptr, cplen);
 465
 466         compressed_data = cdb->ptr;
 467         compressed_data += sizeof(struct CtdlCompressHeader);
 468
 469         sourceLen = (uLongf) zheader.compressed_len;
 470         destLen = (uLongf) zheader.uncompressed_len;
 471         uncompressed_data = malloc(zheader.uncompressed_len);
 472
 473         if (uncompress((Bytef *) uncompressed_data,
 474                        (uLongf *) & destLen,
 475                        (const Bytef *) compressed_data,
 476                        (uLong) sourceLen) != Z_OK)
 477         {
 478                 syslog(LOG_EMERG, "db: uncompress() error");
 479                 cdb_abort();
 480         }
 481
 482         free(cdb->ptr);
 483         cdb->len = (size_t) destLen;
 484         cdb->ptr = uncompressed_data;
 485 }
 486
 487
 488 /*
 489  * Store a piece of data.  Returns 0 if the operation was successful.  If a
 490  * key already exists it should be overwritten.
 491  */
 492 int cdb_store(int cdb, const void *ckey, int ckeylen, void *cdata, int cdatalen)
 493 {
 494
 495         DBT dkey, ddata;
 496         DB_TXN *tid;
 497         int ret = 0;
 498
 499         struct CtdlCompressHeader zheader;
 500         char *compressed_data = NULL;
 501         int compressing = 0;
 502         size_t buffer_len = 0;
 503         uLongf destLen = 0;
 504
 505         memset(&dkey, 0, sizeof(DBT));
 506         memset(&ddata, 0, sizeof(DBT));
 507         dkey.size = ckeylen;
 508         dkey.data = (void *)ckey;
 509         ddata.size = cdatalen;
 510         ddata.data = cdata;
 511
 512         /* Only compress Visit and UseTable records.  Everything else is uncompressed. */
 513         if ( (cdb == CDB_VISIT) || (cdb == CDB_USETABLE) ) {
 514                 compressing = 1;
 515                 zheader.magic = COMPRESS_MAGIC;
 516                 zheader.uncompressed_len = cdatalen;
 517                 buffer_len = ((cdatalen * 101) / 100) + 100 + sizeof(struct CtdlCompressHeader);
 518                 destLen = (uLongf) buffer_len;
 519                 compressed_data = malloc(buffer_len);
 520                 if (compress2((Bytef *) (compressed_data + sizeof(struct CtdlCompressHeader)),
 521                         &destLen, (Bytef *) cdata, (uLongf) cdatalen, 1) != Z_OK)
 522                 {
 523                         syslog(LOG_EMERG, "db: compress2() error");
 524                         cdb_abort();
 525                 }
 526                 zheader.compressed_len = (size_t) destLen;
 527                 memcpy(compressed_data, &zheader, sizeof(struct CtdlCompressHeader));
 528                 ddata.size = (size_t) (sizeof(struct CtdlCompressHeader) + zheader.compressed_len);
 529                 ddata.data = compressed_data;
 530         }
 531
 532         if (TSD->tid != NULL) {
 533                 ret = dbp[cdb]->put(dbp[cdb],   /* db */
 534                                     TSD->tid,   /* transaction ID */
 535                                     &dkey,      /* key */
 536                                     &ddata,     /* data */
 537                                     0); /* flags */
 538                 if (ret) {
 539                         syslog(LOG_EMERG, "db: cdb_store(%d): %s", cdb, db_strerror(ret));
 540                         cdb_abort();
 541                 }
 542                 if (compressing)
 543                         free(compressed_data);
 544                 return ret;
 545         }
 546         else {
 547                 bailIfCursor(TSD->cursors, "attempt to write during r/o cursor");
 548
 549               retry:
 550                 txbegin(&tid);
 551
 552                 if ((ret = dbp[cdb]->put(dbp[cdb],      /* db */
 553                                          tid,   /* transaction ID */
 554                                          &dkey, /* key */
 555                                          &ddata,        /* data */
 556                                          0))) { /* flags */
 557                         if (ret == DB_LOCK_DEADLOCK) {
 558                                 txabort(tid);
 559                                 goto retry;
 560                         } else {
 561                                 syslog(LOG_EMERG, "db: cdb_store(%d): %s", cdb, db_strerror(ret));
 562                                 cdb_abort();
 563                         }
 564                 } else {
 565                         txcommit(tid);
 566                         if (compressing) {
 567                                 free(compressed_data);
 568                         }
 569                         return ret;
 570                 }
 571         }
 572         return ret;
 573 }
 574
 575
 576 /*
 577  * Delete a piece of data.  Returns 0 if the operation was successful.
 578  */
 579 int cdb_delete(int cdb, void *key, int keylen)
 580 {
 581
 582         DBT dkey;
 583         DB_TXN *tid;
 584         int ret;
 585
 586         memset(&dkey, 0, sizeof dkey);
 587         dkey.size = keylen;
 588         dkey.data = key;
 589
 590         if (TSD->tid != NULL) {
 591                 ret = dbp[cdb]->del(dbp[cdb], TSD->tid, &dkey, 0);
 592                 if (ret) {
 593                         syslog(LOG_EMERG, "db: cdb_delete(%d): %s", cdb, db_strerror(ret));
 594                         if (ret != DB_NOTFOUND) {
 595                                 cdb_abort();
 596                         }
 597                 }
 598         } else {
 599                 bailIfCursor(TSD->cursors, "attempt to delete during r/o cursor");
 600
 601               retry:
 602                 txbegin(&tid);
 603
 604                 if ((ret = dbp[cdb]->del(dbp[cdb], tid, &dkey, 0))
 605                     && ret != DB_NOTFOUND) {
 606                         if (ret == DB_LOCK_DEADLOCK) {
 607                                 txabort(tid);
 608                                 goto retry;
 609                         } else {
 610                                 syslog(LOG_EMERG, "db: cdb_delete(%d): %s", cdb, db_strerror(ret));
 611                                 cdb_abort();
 612                         }
 613                 } else {
 614                         txcommit(tid);
 615                 }
 616         }
 617         return ret;
 618 }
 619
 620 static DBC *localcursor(int cdb)
 621 {
 622         int ret;
 623         DBC *curs;
 624
 625         if (TSD->cursors[cdb] == NULL)
 626                 ret = dbp[cdb]->cursor(dbp[cdb], TSD->tid, &curs, 0);
 627         else
 628                 ret = TSD->cursors[cdb]->c_dup(TSD->cursors[cdb], &curs, DB_POSITION);
 629
 630         if (ret) {
 631                 syslog(LOG_EMERG, "db: localcursor: %s", db_strerror(ret));
 632                 cdb_abort();
 633         }
 634
 635         return curs;
 636 }
 637
 638
 639 /*
 640  * Fetch a piece of data.  If not found, returns NULL.  Otherwise, it returns
 641  * a struct cdbdata which it is the caller's responsibility to free later on
 642  * using the cdb_free() routine.
 643  */
 644 struct cdbdata *cdb_fetch(int cdb, const void *key, int keylen)
 645 {
 646         struct cdbdata *tempcdb;
 647         DBT dkey, dret;
 648         int ret;
 649
 650         memset(&dkey, 0, sizeof(DBT));
 651         dkey.size = keylen;
 652         dkey.data = (void *)key;
 653
 654         if (TSD->tid != NULL) {
 655                 memset(&dret, 0, sizeof(DBT));
 656                 dret.flags = DB_DBT_MALLOC;
 657                 ret = dbp[cdb]->get(dbp[cdb], TSD->tid, &dkey, &dret, 0);
 658         } else {
 659                 DBC *curs;
 660
 661                 do {
 662                         memset(&dret, 0, sizeof(DBT));
 663                         dret.flags = DB_DBT_MALLOC;
 664
 665                         curs = localcursor(cdb);
 666
 667                         ret = curs->c_get(curs, &dkey, &dret, DB_SET);
 668                         cclose(curs);
 669                 }
 670                 while (ret == DB_LOCK_DEADLOCK);
 671
 672         }
 673
 674         if ((ret != 0) && (ret != DB_NOTFOUND)) {
 675                 syslog(LOG_EMERG, "db: cdb_fetch(%d): %s", cdb, db_strerror(ret));
 676                 cdb_abort();
 677         }
 678
 679         if (ret != 0)
 680                 return NULL;
 681         tempcdb = (struct cdbdata *) malloc(sizeof(struct cdbdata));
 682
 683         if (tempcdb == NULL) {
 684                 syslog(LOG_EMERG, "db: cdb_fetch: Cannot allocate memory for tempcdb");
 685                 cdb_abort();
 686                 return NULL; /* make it easier for static analysis... */
 687         }
 688         else
 689         {
 690                 tempcdb->len = dret.size;
 691                 tempcdb->ptr = dret.data;
 692                 cdb_decompress_if_necessary(tempcdb);
 693                 return (tempcdb);
 694         }
 695 }
 696
 697
 698 /*
 699  * Free a cdbdata item.
 700  *
 701  * Note that we only free the 'ptr' portion if it is not NULL.  This allows
 702  * other code to assume ownership of that memory simply by storing the
 703  * pointer elsewhere and then setting 'ptr' to NULL.  cdb_free() will then
 704  * avoid freeing it.
 705  */
 706 void cdb_free(struct cdbdata *cdb)
 707 {
 708         if (cdb->ptr) {
 709                 free(cdb->ptr);
 710         }
 711         free(cdb);
 712 }
 713
 714 void cdb_close_cursor(int cdb)
 715 {
 716         if (TSD->cursors[cdb] != NULL) {
 717                 cclose(TSD->cursors[cdb]);
 718         }
 719
 720         TSD->cursors[cdb] = NULL;
 721 }
 722
 723 /*
 724  * Prepare for a sequential search of an entire database.
 725  * (There is guaranteed to be no more than one traversal in
 726  * progress per thread at any given time.)
 727  */
 728 void cdb_rewind(int cdb)
 729 {
 730         int ret = 0;
 731
 732         if (TSD->cursors[cdb] != NULL) {
 733                 syslog(LOG_EMERG, "db: cdb_rewind: must close cursor on database %d before reopening", cdb);
 734                 cdb_abort();
 735                 /* cclose(TSD->cursors[cdb]); */
 736         }
 737
 738         /*
 739          * Now initialize the cursor
 740          */
 741         ret = dbp[cdb]->cursor(dbp[cdb], TSD->tid, &TSD->cursors[cdb], 0);
 742         if (ret) {
 743                 syslog(LOG_EMERG, "db: cdb_rewind: db_cursor: %s", db_strerror(ret));
 744                 cdb_abort();
 745         }
 746 }
 747
 748
 749 /*
 750  * Fetch the next item in a sequential search.  Returns a pointer to a
 751  * cdbdata structure, or NULL if we've hit the end.
 752  */
 753 struct cdbdata *cdb_next_item(int cdb)
 754 {
 755         DBT key, data;
 756         struct cdbdata *cdbret;
 757         int ret = 0;
 758
 759         /* Initialize the key/data pair so the flags aren't set. */
 760         memset(&key, 0, sizeof(key));
 761         memset(&data, 0, sizeof(data));
 762         data.flags = DB_DBT_MALLOC;
 763
 764         ret = TSD->cursors[cdb]->c_get(TSD->cursors[cdb], &key, &data, DB_NEXT);
 765
 766         if (ret) {
 767                 if (ret != DB_NOTFOUND) {
 768                         syslog(LOG_EMERG, "db: cdb_next_item(%d): %s", cdb, db_strerror(ret));
 769                         cdb_abort();
 770                 }
 771                 cdb_close_cursor(cdb);
 772                 return NULL;    /* presumably, end of file */
 773         }
 774
 775         cdbret = (struct cdbdata *) malloc(sizeof(struct cdbdata));
 776         cdbret->len = data.size;
 777         cdbret->ptr = data.data;
 778         cdb_decompress_if_necessary(cdbret);
 779
 780         return (cdbret);
 781 }
 782
 783
 784
 785 /*
 786  * Transaction-based stuff.  I'm writing this as I bake cookies...
 787  */
 788
 789 void cdb_begin_transaction(void)
 790 {
 791
 792         bailIfCursor(TSD->cursors, "can't begin transaction during r/o cursor");
 793
 794         if (TSD->tid != NULL) {
 795                 syslog(LOG_EMERG, "db: cdb_begin_transaction: ERROR: nested transaction");
 796                 cdb_abort();
 797         }
 798
 799         txbegin(&TSD->tid);
 800 }
 801
 802 void cdb_end_transaction(void)
 803 {
 804         int i;
 805
 806         for (i = 0; i < MAXCDB; i++)
 807                 if (TSD->cursors[i] != NULL) {
 808                         syslog(LOG_WARNING, "db: cdb_end_transaction: WARNING: cursor %d still open at transaction end", i);
 809                         cclose(TSD->cursors[i]);
 810                         TSD->cursors[i] = NULL;
 811                 }
 812
 813         if (TSD->tid == NULL) {
 814                 syslog(LOG_ERR, "db: cdb_end_transaction: ERROR: txcommit(NULL) !!");
 815                 cdb_abort();
 816         }
 817         else {
 818                 txcommit(TSD->tid);
 819         }
 820
 821         TSD->tid = NULL;
 822 }
 823
 824 /*
 825  * Truncate (delete every record)
 826  */
 827 void cdb_trunc(int cdb)
 828 {
 829         /* DB_TXN *tid; */
 830         int ret;
 831         u_int32_t count;
 832
 833         if (TSD->tid != NULL) {
 834                 syslog(LOG_EMERG, "db: cdb_trunc must not be called in a transaction.");
 835                 cdb_abort();
 836         }
 837         else {
 838                 bailIfCursor(TSD->cursors, "attempt to write during r/o cursor");
 839
 840               retry:
 841                 /* txbegin(&tid); */
 842
 843                 if ((ret = dbp[cdb]->truncate(dbp[cdb], /* db */
 844                                               NULL,     /* transaction ID */
 845                                               &count,   /* #rows deleted */
 846                                               0))) {    /* flags */
 847                         if (ret == DB_LOCK_DEADLOCK) {
 848                                 /* txabort(tid); */
 849                                 goto retry;
 850                         } else {
 851                                 syslog(LOG_EMERG, "db: cdb_truncate(%d): %s", cdb, db_strerror(ret));
 852                                 if (ret == ENOMEM) {
 853                                         syslog(LOG_EMERG, "db: You may need to tune your database; please read http://www.citadel.org/doku.php?id=faq:troubleshooting:out_of_lock_entries for more information.");
 854                                 }
 855                                 exit(CTDLEXIT_DB);
 856                         }
 857                 } else {
 858                         /* txcommit(tid); */
 859                 }
 860         }
 861 }
 862
 863
 864 /*
 865  * compact (defragment) the database , possibly returning space back to the underlying filesystem
 866  */
 867 void cdb_compact(void)
 868 {
 869         int ret;
 870         int i;
 871
 872         syslog(LOG_DEBUG, "db: cdb_compact() started");
 873         for (i = 0; i < MAXCDB; i++) {
 874                 syslog(LOG_DEBUG, "db: compacting database %d", i);
 875                 ret = dbp[i]->compact(dbp[i], NULL, NULL, NULL, NULL, DB_FREE_SPACE, NULL);
 876                 if (ret) {
 877                         syslog(LOG_ERR, "db: compact: %s", db_strerror(ret));
 878                 }
 879         }
 880         syslog(LOG_DEBUG, "db: cdb_compact() finished");
 881 }
 882
 883
 884 // Has an item already been seen (is it in the CDB_USETABLE) ?
 885 // Returns 0 if it hasn't, 1 if it has
 886 // In either case, writes the item to the database for next time.
 887 int CheckIfAlreadySeen(StrBuf *guid)
 888 {
 889         int found = 0;
 890         struct UseTable ut;
 891         struct cdbdata *cdbut;
 892
 893         syslog(LOG_DEBUG, "db: CheckIfAlreadySeen(%s)", ChrPtr(guid));
 894         cdbut = cdb_fetch(CDB_USETABLE, SKEY(guid));
 895         if (cdbut != NULL) {
 896                 found = 1;
 897                 cdb_free(cdbut);
 898         }
 899
 900         /* (Re)write the record, to update the timestamp.  Zeroing it out makes it compress better. */
 901         memset(&ut, 0, sizeof(struct UseTable));
 902         memcpy(ut.ut_msgid, SKEY(guid));
 903         ut.ut_timestamp = time(NULL);
 904         cdb_store(CDB_USETABLE, SKEY(guid), &ut, sizeof(struct UseTable));
 905         return(found);
 906 }
 907
 908
 909 void cmd_rsen(char *argbuf) {
 910         char Token[SIZ];
 911         long TLen;
 912         char Time[SIZ];
 913
 914         struct UseTable ut;
 915         struct cdbdata *cdbut;
 916
 917         if (CtdlAccessCheck(ac_aide)) return;
 918
 919         TLen = extract_token(Token, argbuf, 1, '|', sizeof Token);
 920         if (strncmp(argbuf, "GET", 3) == 0) {
 921                 cdbut = cdb_fetch(CDB_USETABLE, Token, TLen);
 922                 if (cdbut != NULL) {
 923                         memcpy(&ut, cdbut->ptr,
 924                                ((cdbut->len > sizeof(struct UseTable)) ?
 925                                 sizeof(struct UseTable) : cdbut->len));
 926
 927                         cprintf("%d %ld\n", CIT_OK, ut.ut_timestamp);
 928                 }
 929                 else {
 930                         cprintf("%d not found\n", ERROR + NOT_HERE);
 931                 }
 932
 933         }
 934         else if (strncmp(argbuf, "SET", 3) == 0) {
 935                 memcpy(ut.ut_msgid, Token, TLen);
 936                 extract_token(Time, argbuf, 2, '|', sizeof Time);
 937                 ut.ut_timestamp = atol(Time);
 938                 cdb_store(CDB_USETABLE,
 939                           Token, TLen,
 940                           &ut, sizeof(struct UseTable) );
 941                 cprintf("%d token updated\n", CIT_OK);
 942         }
 943         else if (strncmp(argbuf, "DEL", 3) == 0) {
 944                 if (cdb_delete(CDB_USETABLE, Token, TLen))
 945                         cprintf("%d not found\n", ERROR + NOT_HERE);
 946                 else
 947                         cprintf("%d deleted.\n", CIT_OK);
 948
 949         }
 950         else {
 951                 cprintf("%d Usage: [GET|SET|DEL]|Token|timestamp\n", ERROR);
 952         }
 953
 954 }
 955
 956 CTDL_MODULE_INIT(database)
 957 {
 958         if (!threading)
 959         {
 960                 CtdlRegisterProtoHook(cmd_rsen, "RSEN", "manipulate Aggregators seen database");
 961         }
 962
 963         /* return our module id for the log */
 964         return "database";
 965 }