src/src/dbstuff.h

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2009 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* This header file contains macro definitions so that a variety of DBM
   9 libraries can be used by Exim. Nigel Metheringham provided the original set for
  10 Berkeley DB 1.x in native mode and ndbm. Subsequently, versions for Berkeley DB
  11 2.x and 3.x were added. Later still, support for tdb was added, courtesy of
  12 James Antill. Most recently, support for native mode gdbm was added, with code
  13 from Pierre A. Humblet, so Exim could be made to work with Cygwin.
  14
  15 For convenience, the definitions of the structures used in the various hints
  16 databases are also kept in this file, which is used by the maintenance
  17 utilities as well as the main Exim binary. */
  18
  19
  20 # ifdef USE_TDB
  21
  22 /* ************************* tdb interface ************************ */
  23
  24 #include <tdb.h>
  25
  26 /* Basic DB type */
  27 #define EXIM_DB TDB_CONTEXT
  28
  29 /* Cursor type: tdb uses the previous "key" in _nextkey() (really it wants
  30 tdb_traverse to be called) */
  31 #define EXIM_CURSOR TDB_DATA
  32
  33 /* The datum type used for queries */
  34 #define EXIM_DATUM TDB_DATA
  35
  36 /* Some text for messages */
  37 #define EXIM_DBTYPE "tdb"
  38
  39 /* Access functions */
  40
  41 /* EXIM_DBOPEN - sets *dbpp to point to an EXIM_DB, NULL if failed */
  42 #define EXIM_DBOPEN__(name, dirname, flags, mode, dbpp) \
  43        *(dbpp) = tdb_open(CS name, 0, TDB_DEFAULT, flags, mode)
  44
  45 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
  46 #define EXIM_DBGET(db, key, data)      \
  47        (data = tdb_fetch(db, key), data.dptr != NULL)
  48
  49 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
  50 #define EXIM_DBPUT(db, key, data)      \
  51        tdb_store(db, key, data, TDB_REPLACE)
  52
  53 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
  54 #define EXIM_DBPUTB(db, key, data)      \
  55        tdb_store(db, key, data, TDB_INSERT)
  56
  57 /* Returns from EXIM_DBPUTB */
  58
  59 #define EXIM_DBPUTB_OK  0
  60 #define EXIM_DBPUTB_DUP (-1)
  61
  62 /* EXIM_DBDEL */
  63 #define EXIM_DBDEL(db, key) tdb_delete(db, key)
  64
  65 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation */
  66 #define EXIM_DBCREATE_CURSOR(db, cursor) { \
  67    *(cursor) = store_malloc(sizeof(TDB_DATA)); (*(cursor))->dptr = NULL; }
  68
  69 /* EXIM_DBSCAN - This is complicated because we have to free the last datum
  70 free() must not die when passed NULL */
  71 #define EXIM_DBSCAN(db, key, data, first, cursor)      \
  72        (key = (first ? tdb_firstkey(db) : tdb_nextkey(db, *(cursor))), \
  73         free((cursor)->dptr), *(cursor) = key, \
  74         key.dptr != NULL)
  75
  76 /* EXIM_DBDELETE_CURSOR - terminate scanning operation. */
  77 #define EXIM_DBDELETE_CURSOR(cursor) free(cursor)
  78
  79 /* EXIM_DBCLOSE */
  80 #define EXIM_DBCLOSE__(db)        tdb_close(db)
  81
  82 /* Datum access types - these are intended to be assignable */
  83
  84 #define EXIM_DATUM_SIZE(datum)  (datum).dsize
  85 #define EXIM_DATUM_DATA(datum)  (datum).dptr
  86
  87 /* Free the stuff inside the datum. */
  88
  89 #define EXIM_DATUM_FREE(datum)  (free((datum).dptr), (datum).dptr = NULL)
  90
  91 /* No initialization is needed. */
  92
  93 #define EXIM_DATUM_INIT(datum)
  94
  95
  96
  97 /********************* Berkeley db native definitions **********************/
  98
  99 #elif defined USE_DB
 100
 101 #include <db.h>
 102
 103
 104 /* We can distinguish between versions 1.x and 2.x/3.x by looking for a
 105 definition of DB_VERSION_STRING, which is present in versions 2.x onwards. */
 106
 107 #ifdef DB_VERSION_STRING
 108
 109 /* The API changed (again!) between the 2.x and 3.x versions */
 110
 111 #if DB_VERSION_MAJOR >= 3
 112
 113 /***************** Berkeley db 3.x/4.x native definitions ******************/
 114
 115 /* Basic DB type */
 116 #if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 1)
 117 # define EXIM_DB       DB_ENV
 118 /* Cursor type, for scanning */
 119 # define EXIM_CURSOR   DBC
 120
 121 /* The datum type used for queries */
 122 # define EXIM_DATUM    DBT
 123
 124 /* Some text for messages */
 125 # define EXIM_DBTYPE   "db (v4.1+)"
 126
 127 /* Only more-recent versions.  5+ ? */
 128 # ifndef DB_FORCESYNC
 129 #  define DB_FORCESYNC 0
 130 # endif
 131
 132
 133 /* Access functions */
 134
 135 /* EXIM_DBOPEN - sets *dbpp to point to an EXIM_DB, NULL if failed. The
 136 API changed for DB 4.1. - and we also starting using the "env" with a
 137 specified working dir, to avoid the DBCONFIG file trap. */
 138
 139 # define ENV_TO_DB(env) ((DB *)((env)->app_private))
 140
 141 # define EXIM_DBOPEN__(name, dirname, flags, mode, dbpp) \
 142   if (  db_env_create(dbpp, 0) != 0                                             \
 143      || ((*dbpp)->set_errcall(*dbpp, dbfn_bdb_error_callback), 0)               \
 144      || (*dbpp)->open(*dbpp, CS dirname, DB_CREATE|DB_INIT_MPOOL|DB_PRIVATE, 0) != 0\
 145      )                                                                          \
 146     *dbpp = NULL;                                       \
 147   else if (db_create((DB **) &((*dbpp)->app_private), *dbpp, 0) != 0)           \
 148     {                                                   \
 149     ((DB_ENV *)(*dbpp))->close((DB_ENV *)(*dbpp), 0);   \
 150     *dbpp = NULL;                                       \
 151     }                                                   \
 152   else if (ENV_TO_DB(*dbpp)->open(ENV_TO_DB(*dbpp), NULL, CS name, NULL,        \
 153               (flags) == O_RDONLY ? DB_UNKNOWN : DB_HASH,                       \
 154               (flags) == O_RDONLY ? DB_RDONLY : DB_CREATE,                      \
 155               mode) != 0                                                        \
 156           )                                                                     \
 157     {                                                   \
 158     ENV_TO_DB(*dbpp)->close(ENV_TO_DB(*dbpp), 0);       \
 159     ((DB_ENV *)(*dbpp))->close((DB_ENV *)(*dbpp), 0);   \
 160     *dbpp = NULL;                                       \
 161     }
 162
 163 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 164 # define EXIM_DBGET(db, key, data)      \
 165        (ENV_TO_DB(db)->get(ENV_TO_DB(db), NULL, &key, &data, 0) == 0)
 166
 167 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 168 # define EXIM_DBPUT(db, key, data)      \
 169        ENV_TO_DB(db)->put(ENV_TO_DB(db), NULL, &key, &data, 0)
 170
 171 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 172 # define EXIM_DBPUTB(db, key, data)      \
 173        ENV_TO_DB(db)->put(ENV_TO_DB(db), NULL, &key, &data, DB_NOOVERWRITE)
 174
 175 /* Return values from EXIM_DBPUTB */
 176
 177 # define EXIM_DBPUTB_OK  0
 178 # define EXIM_DBPUTB_DUP DB_KEYEXIST
 179
 180 /* EXIM_DBDEL */
 181 # define EXIM_DBDEL(db, key)     ENV_TO_DB(db)->del(ENV_TO_DB(db), NULL, &key, 0)
 182
 183 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation */
 184
 185 # define EXIM_DBCREATE_CURSOR(db, cursor) \
 186        ENV_TO_DB(db)->cursor(ENV_TO_DB(db), NULL, cursor, 0)
 187
 188 /* EXIM_DBSCAN - returns TRUE if data is returned, FALSE at end */
 189 # define EXIM_DBSCAN(db, key, data, first, cursor)      \
 190        ((cursor)->c_get(cursor, &key, &data,         \
 191          (first? DB_FIRST : DB_NEXT)) == 0)
 192
 193 /* EXIM_DBDELETE_CURSOR - terminate scanning operation */
 194 # define EXIM_DBDELETE_CURSOR(cursor) \
 195        (cursor)->c_close(cursor)
 196
 197 /* EXIM_DBCLOSE */
 198 # define EXIM_DBCLOSE__(db) \
 199         (ENV_TO_DB(db)->close(ENV_TO_DB(db), 0) , ((DB_ENV *)(db))->close((DB_ENV *)(db), DB_FORCESYNC))
 200
 201 /* Datum access types - these are intended to be assignable. */
 202
 203 # define EXIM_DATUM_SIZE(datum)  (datum).size
 204 # define EXIM_DATUM_DATA(datum)  (datum).data
 205
 206 /* The whole datum structure contains other fields that must be cleared
 207 before use, but we don't have to free anything after reading data. */
 208
 209 # define EXIM_DATUM_INIT(datum)   memset(&datum, 0, sizeof(datum))
 210 # define EXIM_DATUM_FREE(datum)
 211
 212 #else   /* pre- 4.1 */
 213
 214 # define EXIM_DB       DB
 215
 216 /* Cursor type, for scanning */
 217 # define EXIM_CURSOR   DBC
 218
 219 /* The datum type used for queries */
 220 # define EXIM_DATUM    DBT
 221
 222 /* Some text for messages */
 223 # define EXIM_DBTYPE   "db (v3/4)"
 224
 225 /* Access functions */
 226
 227 /* EXIM_DBOPEN - sets *dbpp to point to an EXIM_DB, NULL if failed. */
 228
 229 # define EXIM_DBOPEN__(name, dirname, flags, mode, dbpp) \
 230        if (db_create(dbpp, NULL, 0) != 0 || \
 231          ((*dbpp)->set_errcall(*dbpp, dbfn_bdb_error_callback), \
 232          ((*dbpp)->open)(*dbpp, CS name, NULL, \
 233          ((flags) == O_RDONLY)? DB_UNKNOWN : DB_HASH, \
 234          ((flags) == O_RDONLY)? DB_RDONLY : DB_CREATE, \
 235          mode)) != 0) *(dbpp) = NULL
 236
 237 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 238 # define EXIM_DBGET(db, key, data)      \
 239        ((db)->get(db, NULL, &key, &data, 0) == 0)
 240
 241 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 242 # define EXIM_DBPUT(db, key, data)      \
 243        (db)->put(db, NULL, &key, &data, 0)
 244
 245 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 246 # define EXIM_DBPUTB(db, key, data)      \
 247        (db)->put(db, NULL, &key, &data, DB_NOOVERWRITE)
 248
 249 /* Return values from EXIM_DBPUTB */
 250
 251 # define EXIM_DBPUTB_OK  0
 252 # define EXIM_DBPUTB_DUP DB_KEYEXIST
 253
 254 /* EXIM_DBDEL */
 255 # define EXIM_DBDEL(db, key)     (db)->del(db, NULL, &key, 0)
 256
 257 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation */
 258
 259 # define EXIM_DBCREATE_CURSOR(db, cursor) \
 260        (db)->cursor(db, NULL, cursor, 0)
 261
 262 /* EXIM_DBSCAN - returns TRUE if data is returned, FALSE at end */
 263 # define EXIM_DBSCAN(db, key, data, first, cursor)      \
 264        ((cursor)->c_get(cursor, &key, &data,         \
 265          (first? DB_FIRST : DB_NEXT)) == 0)
 266
 267 /* EXIM_DBDELETE_CURSOR - terminate scanning operation */
 268 # define EXIM_DBDELETE_CURSOR(cursor) \
 269        (cursor)->c_close(cursor)
 270
 271 /* EXIM_DBCLOSE */
 272 # define EXIM_DBCLOSE__(db)        (db)->close(db, 0)
 273
 274 /* Datum access types - these are intended to be assignable. */
 275
 276 # define EXIM_DATUM_SIZE(datum)  (datum).size
 277 # define EXIM_DATUM_DATA(datum)  (datum).data
 278
 279 /* The whole datum structure contains other fields that must be cleared
 280 before use, but we don't have to free anything after reading data. */
 281
 282 # define EXIM_DATUM_INIT(datum)   memset(&datum, 0, sizeof(datum))
 283 # define EXIM_DATUM_FREE(datum)
 284
 285 #endif
 286
 287
 288 #else /* DB_VERSION_MAJOR >= 3 */
 289
 290 /******************* Berkeley db 2.x native definitions ********************/
 291
 292 /* Basic DB type */
 293 #define EXIM_DB       DB
 294
 295 /* Cursor type, for scanning */
 296 #define EXIM_CURSOR   DBC
 297
 298 /* The datum type used for queries */
 299 #define EXIM_DATUM    DBT
 300
 301 /* Some text for messages */
 302 #define EXIM_DBTYPE   "db (v2)"
 303
 304 /* Access functions */
 305
 306 /* EXIM_DBOPEN - sets *dbpp to point to an EXIM_DB, NULL if failed */
 307 #define EXIM_DBOPEN__(name, dirname, flags, mode, dbpp)         \
 308        if ((errno = db_open(CS name, DB_HASH,           \
 309          ((flags) == O_RDONLY)? DB_RDONLY : DB_CREATE, \
 310          mode, NULL, NULL, dbpp)) != 0) *(dbpp) = NULL
 311
 312 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 313 #define EXIM_DBGET(db, key, data)      \
 314        ((db)->get(db, NULL, &key, &data, 0) == 0)
 315
 316 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 317 #define EXIM_DBPUT(db, key, data)      \
 318        (db)->put(db, NULL, &key, &data, 0)
 319
 320 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 321 #define EXIM_DBPUTB(db, key, data)      \
 322        (db)->put(db, NULL, &key, &data, DB_NOOVERWRITE)
 323
 324 /* Return values from EXIM_DBPUTB */
 325
 326 #define EXIM_DBPUTB_OK  0
 327 #define EXIM_DBPUTB_DUP DB_KEYEXIST
 328
 329 /* EXIM_DBDEL */
 330 #define EXIM_DBDEL(db, key)     (db)->del(db, NULL, &key, 0)
 331
 332 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation */
 333
 334 /* The API of this function was changed between releases 2.4.14 and 2.7.3. I do
 335 not know exactly where the change happened, but the Change Log for 2.5.9 lists
 336 the new option that is available, so I guess that it happened at 2.5.x. */
 337
 338 #if DB_VERSION_MINOR >= 5
 339 #define EXIM_DBCREATE_CURSOR(db, cursor) \
 340        (db)->cursor(db, NULL, cursor, 0)
 341 #else
 342 #define EXIM_DBCREATE_CURSOR(db, cursor) \
 343        (db)->cursor(db, NULL, cursor)
 344 #endif
 345
 346 /* EXIM_DBSCAN - returns TRUE if data is returned, FALSE at end */
 347 #define EXIM_DBSCAN(db, key, data, first, cursor)      \
 348        ((cursor)->c_get(cursor, &key, &data,         \
 349          (first? DB_FIRST : DB_NEXT)) == 0)
 350
 351 /* EXIM_DBDELETE_CURSOR - terminate scanning operation */
 352 #define EXIM_DBDELETE_CURSOR(cursor) \
 353        (cursor)->c_close(cursor)
 354
 355 /* EXIM_DBCLOSE */
 356 #define EXIM_DBCLOSE__(db)        (db)->close(db, 0)
 357
 358 /* Datum access types - these are intended to be assignable. */
 359
 360 #define EXIM_DATUM_SIZE(datum)  (datum).size
 361 #define EXIM_DATUM_DATA(datum)  (datum).data
 362
 363 /* The whole datum structure contains other fields that must be cleared
 364 before use, but we don't have to free anything after reading data. */
 365
 366 #define EXIM_DATUM_INIT(datum)   memset(&datum, 0, sizeof(datum))
 367 #define EXIM_DATUM_FREE(datum)
 368
 369 #endif /* DB_VERSION_MAJOR >= 3 */
 370
 371
 372 /* If DB_VERSION_TYPE is not defined, we have version 1.x */
 373
 374 #else  /* DB_VERSION_TYPE */
 375
 376 /******************* Berkeley db 1.x native definitions ********************/
 377
 378 /* Basic DB type */
 379 #define EXIM_DB       DB
 380
 381 /* Cursor type, not used with DB 1.x: just set up a dummy */
 382 #define EXIM_CURSOR   int
 383
 384 /* The datum type used for queries */
 385 #define EXIM_DATUM    DBT
 386
 387 /* Some text for messages */
 388 #define EXIM_DBTYPE   "db (v1)"
 389
 390 /* When scanning, for the non-first case we historically just passed 0
 391 as the flags field and it worked.  On FreeBSD 8 it no longer works and
 392 instead leads to memory exhaustion.  The man-page on FreeBSD says to use
 393 R_NEXT, but this 1.x is a historical fallback and I've no idea how portable
 394 the use of that flag is; so the solution is to define R_NEXT here if it's not
 395 already defined, with a default value of 0 because that's what we've always
 396 before been able to pass successfully. */
 397 #ifndef R_NEXT
 398 #define R_NEXT 0
 399 #endif
 400
 401 /* Access functions */
 402
 403 /* EXIM_DBOPEN - sets *dbpp to point to an EXIM_DB, NULL if failed */
 404 #define EXIM_DBOPEN__(name, dirname, flags, mode, dbpp) \
 405        *(dbpp) = dbopen(CS name, flags, mode, DB_HASH, NULL)
 406
 407 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 408 #define EXIM_DBGET(db, key, data)      \
 409        ((db)->get(db, &key, &data, 0) == 0)
 410
 411 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 412 #define EXIM_DBPUT(db, key, data)      \
 413        (db)->put(db, &key, &data, 0)
 414
 415 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 416 #define EXIM_DBPUTB(db, key, data)      \
 417        (db)->put(db, &key, &data, R_NOOVERWRITE)
 418
 419 /* Returns from EXIM_DBPUTB */
 420
 421 #define EXIM_DBPUTB_OK  0
 422 #define EXIM_DBPUTB_DUP 1
 423
 424 /* EXIM_DBDEL */
 425 #define EXIM_DBDEL(db, key)     (db)->del(db, &key, 0)
 426
 427 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation (null) */
 428 #define EXIM_DBCREATE_CURSOR(db, cursor) {}
 429
 430 /* EXIM_DBSCAN - returns TRUE if data is returned, FALSE at end */
 431 #define EXIM_DBSCAN(db, key, data, first, cursor)      \
 432        ((db)->seq(db, &key, &data, (first? R_FIRST : R_NEXT)) == 0)
 433
 434 /* EXIM_DBDELETE_CURSOR - terminate scanning operation (null). Make it
 435 refer to cursor, to keep picky compilers happy. */
 436 #define EXIM_DBDELETE_CURSOR(cursor) { cursor = cursor; }
 437
 438 /* EXIM_DBCLOSE */
 439 #define EXIM_DBCLOSE__(db)        (db)->close(db)
 440
 441 /* Datum access types - these are intended to be assignable */
 442
 443 #define EXIM_DATUM_SIZE(datum)  (datum).size
 444 #define EXIM_DATUM_DATA(datum)  (datum).data
 445
 446 /* There's no clearing required before use, and we don't have to free anything
 447 after reading data. */
 448
 449 #define EXIM_DATUM_INIT(datum)
 450 #define EXIM_DATUM_FREE(datum)
 451
 452 #endif /* DB_VERSION_STRING */
 453
 454
 455
 456 /********************* gdbm interface definitions **********************/
 457
 458 #elif defined USE_GDBM
 459
 460 #include <gdbm.h>
 461
 462 /* Basic DB type */
 463 typedef struct {
 464        GDBM_FILE gdbm;  /* Database */
 465        datum lkey;      /* Last key, for scans */
 466 } EXIM_DB;
 467
 468 /* Cursor type, not used with gdbm: just set up a dummy */
 469 #define EXIM_CURSOR int
 470
 471 /* The datum type used for queries */
 472 #define EXIM_DATUM datum
 473
 474 /* Some text for messages */
 475
 476 #define EXIM_DBTYPE "gdbm"
 477
 478 /* Access functions */
 479
 480 /* EXIM_DBOPEN - returns a EXIM_DB *, NULL if failed */
 481 #define EXIM_DBOPEN__(name, dirname, flags, mode, dbpp) \
 482      { (*(dbpp)) = (EXIM_DB *) malloc(sizeof(EXIM_DB));\
 483        if (*(dbpp) != NULL) { \
 484          (*(dbpp))->lkey.dptr = NULL;\
 485          (*(dbpp))->gdbm = gdbm_open(CS name, 0, (((flags) & O_CREAT))?GDBM_WRCREAT:(((flags) & (O_RDWR|O_WRONLY))?GDBM_WRITER:GDBM_READER), mode, 0);\
 486           if ((*(dbpp))->gdbm == NULL) {\
 487               free(*(dbpp));\
 488               *(dbpp) = NULL;\
 489           }\
 490        }\
 491      }
 492
 493 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 494 #define EXIM_DBGET(db, key, data)      \
 495        (data = gdbm_fetch(db->gdbm, key), data.dptr != NULL)
 496
 497 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 498 #define EXIM_DBPUT(db, key, data)      \
 499        gdbm_store(db->gdbm, key, data, GDBM_REPLACE)
 500
 501 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 502 #define EXIM_DBPUTB(db, key, data)      \
 503        gdbm_store(db->gdbm, key, data, GDBM_INSERT)
 504
 505 /* Returns from EXIM_DBPUTB */
 506
 507 #define EXIM_DBPUTB_OK  0
 508 #define EXIM_DBPUTB_DUP 1
 509
 510 /* EXIM_DBDEL */
 511 #define EXIM_DBDEL(db, key) gdbm_delete(db->gdbm, key)
 512
 513 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation (null) */
 514 #define EXIM_DBCREATE_CURSOR(db, cursor) {}
 515
 516 /* EXIM_DBSCAN */
 517 #define EXIM_DBSCAN(db, key, data, first, cursor)      \
 518   ( key = ((first)? gdbm_firstkey(db->gdbm) : gdbm_nextkey(db->gdbm, db->lkey)), \
 519     (((db)->lkey.dptr != NULL)? (free((db)->lkey.dptr),1) : 1),\
 520     db->lkey = key, key.dptr != NULL)
 521
 522 /* EXIM_DBDELETE_CURSOR - terminate scanning operation (null). Make it
 523 refer to cursor, to keep picky compilers happy. */
 524 #define EXIM_DBDELETE_CURSOR(cursor) { cursor = cursor; }
 525
 526 /* EXIM_DBCLOSE */
 527 #define EXIM_DBCLOSE__(db) \
 528 { gdbm_close((db)->gdbm);\
 529   if ((db)->lkey.dptr != NULL) free((db)->lkey.dptr);\
 530   free(db); }
 531
 532 /* Datum access types - these are intended to be assignable */
 533
 534 #define EXIM_DATUM_SIZE(datum) (datum).dsize
 535 #define EXIM_DATUM_DATA(datum) (datum).dptr
 536
 537 /* There's no clearing required before use, but we have to free the dptr
 538 after reading data. */
 539
 540 #define EXIM_DATUM_INIT(datum)
 541 #define EXIM_DATUM_FREE(datum) free(datum.dptr)
 542
 543 #else  /* USE_GDBM */
 544
 545
 546 /* If none of USE_DB, USG_GDBM, or USE_TDB are set, the default is the NDBM
 547 interface */
 548
 549
 550 /********************* ndbm interface definitions **********************/
 551
 552 #include <ndbm.h>
 553
 554 /* Basic DB type */
 555 #define EXIM_DB DBM
 556
 557 /* Cursor type, not used with ndbm: just set up a dummy */
 558 #define EXIM_CURSOR int
 559
 560 /* The datum type used for queries */
 561 #define EXIM_DATUM datum
 562
 563 /* Some text for messages */
 564
 565 #define EXIM_DBTYPE "ndbm"
 566
 567 /* Access functions */
 568
 569 /* EXIM_DBOPEN - returns a EXIM_DB *, NULL if failed */
 570 #define EXIM_DBOPEN__(name, dirname, flags, mode, dbpp) \
 571        *(dbpp) = dbm_open(CS name, flags, mode)
 572
 573 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 574 #define EXIM_DBGET(db, key, data)      \
 575        (data = dbm_fetch(db, key), data.dptr != NULL)
 576
 577 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 578 #define EXIM_DBPUT(db, key, data)      \
 579        dbm_store(db, key, data, DBM_REPLACE)
 580
 581 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 582 #define EXIM_DBPUTB(db, key, data)      \
 583        dbm_store(db, key, data, DBM_INSERT)
 584
 585 /* Returns from EXIM_DBPUTB */
 586
 587 #define EXIM_DBPUTB_OK  0
 588 #define EXIM_DBPUTB_DUP 1
 589
 590 /* EXIM_DBDEL */
 591 #define EXIM_DBDEL(db, key) dbm_delete(db, key)
 592
 593 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation (null) */
 594 #define EXIM_DBCREATE_CURSOR(db, cursor) {}
 595
 596 /* EXIM_DBSCAN */
 597 #define EXIM_DBSCAN(db, key, data, first, cursor)      \
 598        (key = (first? dbm_firstkey(db) : dbm_nextkey(db)), key.dptr != NULL)
 599
 600 /* EXIM_DBDELETE_CURSOR - terminate scanning operation (null). Make it
 601 refer to cursor, to keep picky compilers happy. */
 602 #define EXIM_DBDELETE_CURSOR(cursor) { cursor = cursor; }
 603
 604 /* EXIM_DBCLOSE */
 605 #define EXIM_DBCLOSE__(db) dbm_close(db)
 606
 607 /* Datum access types - these are intended to be assignable */
 608
 609 #define EXIM_DATUM_SIZE(datum) (datum).dsize
 610 #define EXIM_DATUM_DATA(datum) (datum).dptr
 611
 612 /* There's no clearing required before use, and we don't have to free anything
 613 after reading data. */
 614
 615 #define EXIM_DATUM_INIT(datum)
 616 #define EXIM_DATUM_FREE(datum)
 617
 618 #endif /* USE_GDBM */
 619
 620
 621
 622
 623
 624 # ifdef COMPILE_UTILITY
 625
 626 #  define EXIM_DBOPEN(name, dirname, flags, mode, dbpp) \
 627   EXIM_DBOPEN__(name, dirname, flags, mode, dbpp)
 628 #  define EXIM_DBCLOSE(db) EXIM_DBCLOSE__(db)
 629
 630 # else
 631
 632 #  define EXIM_DBOPEN(name, dirname, flags, mode, dbpp) \
 633   do { \
 634   DEBUG(D_hints_lookup) \
 635     debug_printf("EXIM_DBOPEN: file <%s> dir <%s> flags=%s\n", \
 636       (name), (dirname),                \
 637       (flags) == O_RDONLY ? "O_RDONLY"  \
 638       : (flags) == O_RDWR ? "O_RDWR"    \
 639       : (flags) == (O_RDWR|O_CREAT) ? "O_RDWR|O_CREAT"  \
 640       : "??");  \
 641   EXIM_DBOPEN__(name, dirname, flags, mode, dbpp); \
 642   DEBUG(D_hints_lookup) debug_printf("returned from EXIM_DBOPEN: %p\n", *dbpp); \
 643   } while(0)
 644 #  define EXIM_DBCLOSE(db) \
 645   do { \
 646   DEBUG(D_hints_lookup) debug_printf("EXIM_DBCLOSE(%p)\n", db); \
 647   EXIM_DBCLOSE__(db); \
 648   } while(0)
 649
 650 #  endif
 651
 652 /********************* End of dbm library definitions **********************/
 653
 654
 655 /* Structure for carrying around an open DBM file, and an open locking file
 656 that relates to it. */
 657
 658 typedef struct {
 659   EXIM_DB *dbptr;
 660   int lockfd;
 661 } open_db;
 662
 663
 664 /* Structures for records stored in exim database dbm files. They all
 665 start with the same fields, described in the generic type. */
 666
 667
 668 typedef struct {
 669   time_t time_stamp;      /* Timestamp of writing */
 670 } dbdata_generic;
 671
 672
 673 /* This structure keeps track of retry information for a host or a local
 674 address. */
 675
 676 typedef struct {
 677   time_t time_stamp;
 678   /*************/
 679   time_t first_failed;    /* Time of first failure */
 680   time_t last_try;        /* Time of last try */
 681   time_t next_try;        /* Time of next try */
 682   BOOL   expired;         /* Retry time has expired */
 683   int    basic_errno;     /* Errno of last failure */
 684   int    more_errno;      /* Additional information */
 685   uschar text[1];         /* Text message for last failure */
 686 } dbdata_retry;
 687
 688 /* These structures keep track of addresses that have had callout verification
 689 performed on them. There are two groups of records:
 690
 691 1. keyed by localpart@domain -
 692      Full address was tested and record holds result
 693
 694 2. keyed by domain -
 695      Domain response upto MAIL FROM:<>, postmaster, random local part;
 696
 697 If a record exists, the result field is either ccache_accept or ccache_reject,
 698 or, for a domain record only, ccache_reject_mfnull when MAIL FROM:<> was
 699 rejected. The other fields, however, (which are only relevant to domain
 700 records) may also contain ccache_unknown if that particular test has not been
 701 done.
 702
 703 Originally, there was only one structure, used for both types. However, it got
 704 expanded for domain records, so it got split. To make it possible for Exim to
 705 handle the old type of record, we retain the old definition. The different
 706 kinds of record can be distinguished by their different lengths. */
 707
 708 typedef struct {
 709   time_t time_stamp;
 710   /*************/
 711   int   result;
 712   int   postmaster_result; /* Postmaster is accepted */
 713   int   random_result;     /* Random local part was accepted */
 714 } dbdata_callout_cache_obs;
 715
 716 typedef struct {
 717   time_t time_stamp;       /* Timestamp of last address check */
 718   /*************/
 719   int   result;            /* accept or reject */
 720 } dbdata_callout_cache_address;
 721
 722 /* For this new layout, we put the additional fields (the timestamps)
 723 last so that if somebody reverts to an older Exim, the new records will
 724 still make sense because they match the old layout. */
 725
 726 typedef struct {
 727   time_t time_stamp;       /* Time stamp of last connection */
 728   /*************/
 729   int   result;            /* Domain reject or accept */
 730   int   postmaster_result; /* Postmaster result */
 731   int   random_result;     /* Random result */
 732   time_t postmaster_stamp; /* Timestamp of postmaster check */
 733   time_t random_stamp;     /* Timestamp of random check */
 734 } dbdata_callout_cache;
 735
 736 /* This structure keeps track of messages that are waiting for a particular
 737 host for a particular transport. */
 738
 739 typedef struct {
 740   time_t time_stamp;
 741   /*************/
 742   int    count;           /* Count of message ids */
 743   int    sequence;        /* Sequence for continued records */
 744   uschar text[1];         /* One long character string */
 745 } dbdata_wait;
 746
 747
 748 /* The contents of the "misc" database are a mixture of different kinds of
 749 record, as defined below. The keys used for a specific type all start with a
 750 given string such as "etrn-" or "host-serialize-". */
 751
 752
 753 /* This structure records a connection to a particular host, for the
 754 purpose of serializing access to certain hosts. For possible future extension,
 755 a field is defined for holding the count of connections, but it is not
 756 at present in use. The same structure is used for recording a running ETRN
 757 process. */
 758
 759 typedef struct {
 760   time_t time_stamp;
 761   /*************/
 762   int    count;           /* Reserved for possible connection count */
 763 } dbdata_serialize;
 764
 765
 766 /* This structure records the information required for the ratelimit
 767 ACL condition. */
 768
 769 typedef struct {
 770   time_t time_stamp;
 771   /*************/
 772   int    time_usec;       /* Fractional part of time, from gettimeofday() */
 773   double rate;            /* Smoothed sending rate at that time */
 774 } dbdata_ratelimit;
 775
 776 /* Same as above, plus a Bloom filter for uniquifying events. */
 777
 778 typedef struct {
 779   dbdata_ratelimit dbd;
 780   time_t   bloom_epoch;   /* When the Bloom filter was last reset */
 781   unsigned bloom_size;    /* Number of bytes in the Bloom filter */
 782   uschar   bloom[40];     /* Bloom filter which may be larger than this */
 783 } dbdata_ratelimit_unique;
 784
 785
 786 /* End of dbstuff.h */