citadel/database.c

   1 /*
   2  * $Id$
   3  *
   4  * GDBM database driver for Citadel/UX
   5  *
   6  */
   7
   8 /*
   9  * Note that each call to a GDBM function is wrapped in an S_DATABASE critical
  10  * section.  This is done because GDBM is not threadsafe.  This is the ONLY
  11  * place in the entire Citadel server where any code enters two different
  12  * classes of critical sections at the same time; this is why the GDBM calls
  13  * are *tightly* wrapped in S_DATABASE.  Opening multiple concurrent critical
  14  * sections elsewhere in the code can, and probably will, cause deadlock
  15  * conditions to occur.  (Deadlock is bad.  Eliminate.)
  16  */
  17
  18 #ifdef DLL_EXPORT
  19 #define IN_LIBCIT
  20 #endif
  21
  22 #include "sysdep.h"
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <stdio.h>
  26
  27 #if TIME_WITH_SYS_TIME
  28 # include <sys/time.h>
  29 # include <time.h>
  30 #else
  31 # if HAVE_SYS_TIME_H
  32 #  include <sys/time.h>
  33 # else
  34 #  include <time.h>
  35 # endif
  36 #endif
  37
  38 #include <ctype.h>
  39 #include <string.h>
  40 #include <errno.h>
  41 #include <gdbm.h>
  42 #include "citadel.h"
  43 #include "server.h"
  44 #include "database.h"
  45 #include "sysdep_decls.h"
  46
  47
  48 /*
  49  * This array holds one gdbm handle for each Citadel database.
  50  */
  51 GDBM_FILE gdbms[MAXCDB];
  52
  53 /*
  54  * We also keep these around, for sequential searches (one per session slot)
  55  */
  56 int max_keys = 0;
  57 datum *dtkey;
  58
  59
  60 /*
  61  * Reclaim unused space in the databases.  We need to do each one of
  62  * these discretely, rather than in a loop.
  63  */
  64 void defrag_databases(void)
  65 {
  66
  67         /* defrag the message base */
  68         lprintf(7, "Defragmenting message base\n");
  69         begin_critical_section(S_DATABASE);
  70         gdbm_reorganize(gdbms[CDB_MSGMAIN]);
  71         end_critical_section(S_DATABASE);
  72
  73         /* defrag the user file, mailboxes, and user/room relationships */
  74         lprintf(7, "Defragmenting user file\n");
  75         begin_critical_section(S_USERSUPP);
  76         begin_critical_section(S_DATABASE);
  77         gdbm_reorganize(gdbms[CDB_USERSUPP]);
  78         gdbm_reorganize(gdbms[CDB_VISIT]);
  79         end_critical_section(S_DATABASE);
  80         end_critical_section(S_USERSUPP);
  81
  82         /* defrag the room files and message lists */
  83         lprintf(7, "Defragmenting room files and message lists\n");
  84         begin_critical_section(S_QUICKROOM);
  85         begin_critical_section(S_DATABASE);
  86         gdbm_reorganize(gdbms[CDB_QUICKROOM]);
  87         gdbm_reorganize(gdbms[CDB_MSGLISTS]);
  88         end_critical_section(S_DATABASE);
  89         end_critical_section(S_QUICKROOM);
  90
  91         /* defrag the floor table */
  92         lprintf(7, "Defragmenting floor table\n");
  93         begin_critical_section(S_FLOORTAB);
  94         begin_critical_section(S_DATABASE);
  95         gdbm_reorganize(gdbms[CDB_FLOORTAB]);
  96         end_critical_section(S_DATABASE);
  97         end_critical_section(S_FLOORTAB);
  98 }
  99
 100
 101 /*
 102  * Open the various gdbm databases we'll be using.  Any database which
 103  * does not exist should be created.
 104  */
 105 void open_databases(void)
 106 {
 107         lprintf(7, "%s\n", gdbm_version);
 108
 109         /*
 110          * Silently try to create the database subdirectory.  If it's
 111          * already there, no problem.
 112          */
 113         system("exec mkdir data 2>/dev/null");
 114
 115         /* a critical section is unnecessary, as this function is called before
 116            any other threads are created. and it causes problems on BSDI.
 117
 118            begin_critical_section(S_DATABASE);
 119
 120          */
 121
 122         gdbms[CDB_MSGMAIN] = gdbm_open("data/msgmain.gdbm", 8192,
 123                                        GDBM_WRCREAT, 0600, NULL);
 124         if (gdbms[CDB_MSGMAIN] == NULL) {
 125                 lprintf(2, "Cannot open msgmain: %s\n",
 126                         gdbm_strerror(gdbm_errno));
 127                 exit(1);
 128         }
 129         gdbms[CDB_USERSUPP] = gdbm_open("data/usersupp.gdbm", 0,
 130                                         GDBM_WRCREAT, 0600, NULL);
 131         if (gdbms[CDB_USERSUPP] == NULL) {
 132                 lprintf(2, "Cannot open usersupp: %s\n",
 133                         gdbm_strerror(gdbm_errno));
 134                 exit(1);
 135         }
 136         gdbms[CDB_VISIT] = gdbm_open("data/visit.gdbm", 0,
 137                                      GDBM_WRCREAT, 0600, NULL);
 138         if (gdbms[CDB_VISIT] == NULL) {
 139                 lprintf(2, "Cannot open visit file: %s\n",
 140                         gdbm_strerror(gdbm_errno));
 141                 exit(1);
 142         }
 143         gdbms[CDB_QUICKROOM] = gdbm_open("data/quickroom.gdbm", 0,
 144                                          GDBM_WRCREAT, 0600, NULL);
 145         if (gdbms[CDB_QUICKROOM] == NULL) {
 146                 lprintf(2, "Cannot open quickroom: %s\n",
 147                         gdbm_strerror(gdbm_errno));
 148                 exit(1);
 149         }
 150         gdbms[CDB_FLOORTAB] = gdbm_open("data/floortab.gdbm", 0,
 151                                         GDBM_WRCREAT, 0600, NULL);
 152         if (gdbms[CDB_FLOORTAB] == NULL) {
 153                 lprintf(2, "Cannot open floortab: %s\n",
 154                         gdbm_strerror(gdbm_errno));
 155                 exit(1);
 156         }
 157         gdbms[CDB_MSGLISTS] = gdbm_open("data/msglists.gdbm", 0,
 158                                         GDBM_WRCREAT, 0600, NULL);
 159         if (gdbms[CDB_MSGLISTS] == NULL) {
 160                 lprintf(2, "Cannot open msglists: %s\n",
 161                         gdbm_strerror(gdbm_errno));
 162                 exit(1);
 163         }
 164         /*
 165            end_critical_section(S_DATABASE);
 166          */
 167
 168 }
 169
 170
 171 /*
 172  * Close all of the gdbm database files we've opened.  This can be done
 173  * in a loop, since it's just a bunch of closes.
 174  */
 175 void close_databases(void)
 176 {
 177         int a;
 178
 179         begin_critical_section(S_DATABASE);
 180         for (a = 0; a < MAXCDB; ++a) {
 181                 lprintf(7, "Closing database %d\n", a);
 182                 gdbm_close(gdbms[a]);
 183         }
 184         end_critical_section(S_DATABASE);
 185
 186         for (a = 0; a < max_keys; ++a) {
 187                 if (dtkey[a].dptr != NULL) {
 188                         phree(dtkey[a].dptr);
 189                 }
 190         }
 191
 192 }
 193
 194
 195 /*
 196  * Store a piece of data.  Returns 0 if the operation was successful.  If a
 197  * datum already exists it should be overwritten.
 198  */
 199 int cdb_store(int cdb,
 200               void *key, int keylen,
 201               void *data, int datalen)
 202 {
 203
 204         datum dkey, ddata;
 205         int retval;
 206
 207         dkey.dsize = keylen;
 208         dkey.dptr = key;
 209         ddata.dsize = datalen;
 210         ddata.dptr = data;
 211
 212         begin_critical_section(S_DATABASE);
 213         retval = gdbm_store(gdbms[cdb], dkey, ddata, GDBM_REPLACE);
 214         end_critical_section(S_DATABASE);
 215         if (retval < 0) {
 216                 lprintf(2, "gdbm error: %s\n", gdbm_strerror(gdbm_errno));
 217                 return (-1);
 218         }
 219         return (0);
 220 }
 221
 222
 223 /*
 224  * Delete a piece of data.  Returns 0 if the operation was successful.
 225  */
 226 int cdb_delete(int cdb, void *key, int keylen)
 227 {
 228
 229         datum dkey;
 230         int retval;
 231
 232         dkey.dsize = keylen;
 233         dkey.dptr = key;
 234
 235         begin_critical_section(S_DATABASE);
 236         retval = gdbm_delete(gdbms[cdb], dkey);
 237         end_critical_section(S_DATABASE);
 238         return (retval);
 239
 240 }
 241
 242
 243
 244
 245 /*
 246  * Fetch a piece of data.  If not found, returns NULL.  Otherwise, it returns
 247  * a struct cdbdata which it is the caller's responsibility to free later on
 248  * using the cdb_free() routine.
 249  */
 250 struct cdbdata *cdb_fetch(int cdb, void *key, int keylen)
 251 {
 252
 253         struct cdbdata *tempcdb;
 254         datum dkey, dret;
 255
 256         dkey.dsize = keylen;
 257         dkey.dptr = key;
 258
 259         begin_critical_section(S_DATABASE);
 260         dret = gdbm_fetch(gdbms[cdb], dkey);
 261         end_critical_section(S_DATABASE);
 262         if (dret.dptr == NULL) {
 263                 return NULL;
 264         }
 265         tempcdb = (struct cdbdata *) mallok(sizeof(struct cdbdata));
 266         if (tempcdb == NULL) {
 267                 lprintf(2, "Cannot allocate memory!\n");
 268         }
 269         tempcdb->len = dret.dsize;
 270         tempcdb->ptr = dret.dptr;
 271         return (tempcdb);
 272 }
 273
 274
 275 /*
 276  * Free a cdbdata item (ok, this is really no big deal, but we might need to do
 277  * more complex stuff with other database managers in the future).
 278  */
 279 void cdb_free(struct cdbdata *cdb)
 280 {
 281         phree(cdb->ptr);
 282         phree(cdb);
 283 }
 284
 285 void cdb_close_cursor(cdb)
 286 {
 287         while (max_keys <= CC->cs_pid) {
 288                 ++max_keys;
 289                 if (dtkey == NULL) {
 290                         dtkey = (datum *)
 291                             mallok((sizeof(datum) * max_keys));
 292                 } else {
 293                         dtkey = (datum *)
 294                             reallok(dtkey, (sizeof(datum) * max_keys));
 295                 }
 296                 dtkey[max_keys - 1].dsize = 0;
 297                 dtkey[max_keys - 1].dptr = NULL;
 298         }
 299
 300         if (dtkey[CC->cs_pid].dptr != NULL) {
 301                 phree(dtkey[CC->cs_pid].dptr);
 302         }
 303         dtkey[CC->cs_pid].dptr = NULL;
 304         dtkey[CC->cs_pid].dsize = 0;
 305 }
 306
 307
 308 /*
 309  * Prepare for a sequential search of an entire database.  (In the gdbm model,
 310  * we do this by keeping an array dtkey[] of "the next" key for each session
 311  * that is open.  There is guaranteed to be no more than one traversal in
 312  * progress per session at any given time.)
 313  */
 314 void cdb_rewind(int cdb)
 315 {
 316
 317         while (max_keys <= CC->cs_pid) {
 318                 ++max_keys;
 319                 if (dtkey == NULL) {
 320                         dtkey = (datum *)
 321                             mallok((sizeof(datum) * max_keys));
 322                 } else {
 323                         dtkey = (datum *)
 324                             reallok(dtkey, (sizeof(datum) * max_keys));
 325                 }
 326                 dtkey[max_keys - 1].dsize = 0;
 327                 dtkey[max_keys - 1].dptr = NULL;
 328         }
 329
 330         if (dtkey[CC->cs_pid].dptr != NULL) {
 331                 phree(dtkey[CC->cs_pid].dptr);
 332         }
 333         begin_critical_section(S_DATABASE);
 334         dtkey[CC->cs_pid] = gdbm_firstkey(gdbms[cdb]);
 335         end_critical_section(S_DATABASE);
 336 }
 337
 338
 339 /*
 340  * Fetch the next item in a sequential search.  Returns a pointer to a
 341  * cdbdata structure, or NULL if we've hit the end.
 342  */
 343 struct cdbdata *cdb_next_item(int cdb)
 344 {
 345         datum dret;
 346         struct cdbdata *cdbret;
 347         void *ptr = NULL;
 348
 349
 350         if (dtkey[CC->cs_pid].dptr == NULL) {   /* end of file */
 351                 return NULL;
 352         }
 353         begin_critical_section(S_DATABASE);
 354         dret = gdbm_fetch(gdbms[cdb], dtkey[CC->cs_pid]);
 355         end_critical_section(S_DATABASE);
 356         if (dret.dptr == NULL) {        /* bad read */
 357                 phree(dtkey[CC->cs_pid].dptr);
 358                 return NULL;
 359         }
 360         cdbret = (struct cdbdata *) mallok(sizeof(struct cdbdata));
 361         cdbret->len = dret.dsize;
 362         cdbret->ptr = dret.dptr;
 363
 364         ptr = dtkey[CC->cs_pid].dptr;
 365         begin_critical_section(S_DATABASE);
 366         dtkey[CC->cs_pid] = gdbm_nextkey(gdbms[cdb], dtkey[CC->cs_pid]);
 367         end_critical_section(S_DATABASE);
 368
 369         if (ptr != NULL) {      /* Free the previous key. */
 370                 free(ptr);
 371         }
 372
 373         return (cdbret);
 374 }
 375
 376
 377 /*
 378  * empty functions because GDBM doesn't have transaction support
 379  */
 380
 381 void cdb_begin_transaction(void) {
 382 }
 383
 384 void cdb_end_transaction(void) {
 385 }
 386
 387 void cdb_allocate_tsd(void) {
 388 }
 389
 390 void cdb_free_tsd(void) {
 391 }
 392
 393 void cdb_check_handles(void) {
 394 }