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, 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 #define EXIM_DB       DB
 117
 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 (v3/4)"
 126
 127 /* Access functions */
 128
 129 /* EXIM_DBOPEN - sets *dbpp to point to an EXIM_DB, NULL if failed. The
 130 API changed for DB 4.1. */
 131
 132 #if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 1)
 133 #define EXIM_DBOPEN(name, flags, mode, dbpp) \
 134        if (db_create(dbpp, NULL, 0) != 0 || \
 135          ((*dbpp)->set_errcall(*dbpp, dbfn_bdb_error_callback), \
 136          ((*dbpp)->open)(*dbpp, NULL, CS name, NULL, \
 137          ((flags) == O_RDONLY)? DB_UNKNOWN : DB_HASH, \
 138          ((flags) == O_RDONLY)? DB_RDONLY : DB_CREATE, \
 139          mode)) != 0) *(dbpp) = NULL
 140 #else
 141 #define EXIM_DBOPEN(name, flags, mode, dbpp) \
 142        if (db_create(dbpp, NULL, 0) != 0 || \
 143          ((*dbpp)->set_errcall(*dbpp, dbfn_bdb_error_callback), \
 144          ((*dbpp)->open)(*dbpp, CS name, NULL, \
 145          ((flags) == O_RDONLY)? DB_UNKNOWN : DB_HASH, \
 146          ((flags) == O_RDONLY)? DB_RDONLY : DB_CREATE, \
 147          mode)) != 0) *(dbpp) = NULL
 148 #endif
 149
 150 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 151 #define EXIM_DBGET(db, key, data)      \
 152        ((db)->get(db, NULL, &key, &data, 0) == 0)
 153
 154 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 155 #define EXIM_DBPUT(db, key, data)      \
 156        (db)->put(db, NULL, &key, &data, 0)
 157
 158 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 159 #define EXIM_DBPUTB(db, key, data)      \
 160        (db)->put(db, NULL, &key, &data, DB_NOOVERWRITE)
 161
 162 /* Return values from EXIM_DBPUTB */
 163
 164 #define EXIM_DBPUTB_OK  0
 165 #define EXIM_DBPUTB_DUP DB_KEYEXIST
 166
 167 /* EXIM_DBDEL */
 168 #define EXIM_DBDEL(db, key)     (db)->del(db, NULL, &key, 0)
 169
 170 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation */
 171
 172 #define EXIM_DBCREATE_CURSOR(db, cursor) \
 173        (db)->cursor(db, NULL, cursor, 0)
 174
 175 /* EXIM_DBSCAN - returns TRUE if data is returned, FALSE at end */
 176 #define EXIM_DBSCAN(db, key, data, first, cursor)      \
 177        ((cursor)->c_get(cursor, &key, &data,         \
 178          (first? DB_FIRST : DB_NEXT)) == 0)
 179
 180 /* EXIM_DBDELETE_CURSOR - terminate scanning operation */
 181 #define EXIM_DBDELETE_CURSOR(cursor) \
 182        (cursor)->c_close(cursor)
 183
 184 /* EXIM_DBCLOSE */
 185 #define EXIM_DBCLOSE(db)        (db)->close(db, 0)
 186
 187 /* Datum access types - these are intended to be assignable. */
 188
 189 #define EXIM_DATUM_SIZE(datum)  (datum).size
 190 #define EXIM_DATUM_DATA(datum)  (datum).data
 191
 192 /* The whole datum structure contains other fields that must be cleared
 193 before use, but we don't have to free anything after reading data. */
 194
 195 #define EXIM_DATUM_INIT(datum)   memset(&datum, 0, sizeof(datum))
 196 #define EXIM_DATUM_FREE(datum)
 197
 198
 199 #else /* DB_VERSION_MAJOR >= 3 */
 200
 201 /******************* Berkeley db 2.x native definitions ********************/
 202
 203 /* Basic DB type */
 204 #define EXIM_DB       DB
 205
 206 /* Cursor type, for scanning */
 207 #define EXIM_CURSOR   DBC
 208
 209 /* The datum type used for queries */
 210 #define EXIM_DATUM    DBT
 211
 212 /* Some text for messages */
 213 #define EXIM_DBTYPE   "db (v2)"
 214
 215 /* Access functions */
 216
 217 /* EXIM_DBOPEN - sets *dbpp to point to an EXIM_DB, NULL if failed */
 218 #define EXIM_DBOPEN(name, flags, mode, dbpp)         \
 219        if ((errno = db_open(CS name, DB_HASH,           \
 220          ((flags) == O_RDONLY)? DB_RDONLY : DB_CREATE, \
 221          mode, NULL, NULL, dbpp)) != 0) *(dbpp) = NULL
 222
 223 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 224 #define EXIM_DBGET(db, key, data)      \
 225        ((db)->get(db, NULL, &key, &data, 0) == 0)
 226
 227 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 228 #define EXIM_DBPUT(db, key, data)      \
 229        (db)->put(db, NULL, &key, &data, 0)
 230
 231 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 232 #define EXIM_DBPUTB(db, key, data)      \
 233        (db)->put(db, NULL, &key, &data, DB_NOOVERWRITE)
 234
 235 /* Return values from EXIM_DBPUTB */
 236
 237 #define EXIM_DBPUTB_OK  0
 238 #define EXIM_DBPUTB_DUP DB_KEYEXIST
 239
 240 /* EXIM_DBDEL */
 241 #define EXIM_DBDEL(db, key)     (db)->del(db, NULL, &key, 0)
 242
 243 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation */
 244
 245 /* The API of this function was changed between releases 2.4.14 and 2.7.3. I do
 246 not know exactly where the change happened, but the Change Log for 2.5.9 lists
 247 the new option that is available, so I guess that it happened at 2.5.x. */
 248
 249 #if DB_VERSION_MINOR >= 5
 250 #define EXIM_DBCREATE_CURSOR(db, cursor) \
 251        (db)->cursor(db, NULL, cursor, 0)
 252 #else
 253 #define EXIM_DBCREATE_CURSOR(db, cursor) \
 254        (db)->cursor(db, NULL, cursor)
 255 #endif
 256
 257 /* EXIM_DBSCAN - returns TRUE if data is returned, FALSE at end */
 258 #define EXIM_DBSCAN(db, key, data, first, cursor)      \
 259        ((cursor)->c_get(cursor, &key, &data,         \
 260          (first? DB_FIRST : DB_NEXT)) == 0)
 261
 262 /* EXIM_DBDELETE_CURSOR - terminate scanning operation */
 263 #define EXIM_DBDELETE_CURSOR(cursor) \
 264        (cursor)->c_close(cursor)
 265
 266 /* EXIM_DBCLOSE */
 267 #define EXIM_DBCLOSE(db)        (db)->close(db, 0)
 268
 269 /* Datum access types - these are intended to be assignable. */
 270
 271 #define EXIM_DATUM_SIZE(datum)  (datum).size
 272 #define EXIM_DATUM_DATA(datum)  (datum).data
 273
 274 /* The whole datum structure contains other fields that must be cleared
 275 before use, but we don't have to free anything after reading data. */
 276
 277 #define EXIM_DATUM_INIT(datum)   memset(&datum, 0, sizeof(datum))
 278 #define EXIM_DATUM_FREE(datum)
 279
 280 #endif /* DB_VERSION_MAJOR >= 3 */
 281
 282
 283 /* If DB_VERSION_TYPE is not defined, we have version 1.x */
 284
 285 #else  /* DB_VERSION_TYPE */
 286
 287 /******************* Berkeley db 1.x native definitions ********************/
 288
 289 /* Basic DB type */
 290 #define EXIM_DB       DB
 291
 292 /* Cursor type, not used with DB 1.x: just set up a dummy */
 293 #define EXIM_CURSOR   int
 294
 295 /* The datum type used for queries */
 296 #define EXIM_DATUM    DBT
 297
 298 /* Some text for messages */
 299 #define EXIM_DBTYPE   "db (v1)"
 300
 301 /* When scanning, for the non-first case we historically just passed 0
 302 as the flags field and it worked.  On FreeBSD 8 it no longer works and
 303 instead leads to memory exhaustion.  The man-page on FreeBSD says to use
 304 R_NEXT, but this 1.x is a historical fallback and I've no idea how portable
 305 the use of that flag is; so the solution is to define R_NEXT here if it's not
 306 already defined, with a default value of 0 because that's what we've always
 307 before been able to pass successfully. */
 308 #ifndef R_NEXT
 309 #define R_NEXT 0
 310 #endif
 311
 312 /* Access functions */
 313
 314 /* EXIM_DBOPEN - sets *dbpp to point to an EXIM_DB, NULL if failed */
 315 #define EXIM_DBOPEN(name, flags, mode, dbpp) \
 316        *(dbpp) = dbopen(CS name, flags, mode, DB_HASH, NULL)
 317
 318 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 319 #define EXIM_DBGET(db, key, data)      \
 320        ((db)->get(db, &key, &data, 0) == 0)
 321
 322 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 323 #define EXIM_DBPUT(db, key, data)      \
 324        (db)->put(db, &key, &data, 0)
 325
 326 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 327 #define EXIM_DBPUTB(db, key, data)      \
 328        (db)->put(db, &key, &data, R_NOOVERWRITE)
 329
 330 /* Returns from EXIM_DBPUTB */
 331
 332 #define EXIM_DBPUTB_OK  0
 333 #define EXIM_DBPUTB_DUP 1
 334
 335 /* EXIM_DBDEL */
 336 #define EXIM_DBDEL(db, key)     (db)->del(db, &key, 0)
 337
 338 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation (null) */
 339 #define EXIM_DBCREATE_CURSOR(db, cursor) {}
 340
 341 /* EXIM_DBSCAN - returns TRUE if data is returned, FALSE at end */
 342 #define EXIM_DBSCAN(db, key, data, first, cursor)      \
 343        ((db)->seq(db, &key, &data, (first? R_FIRST : R_NEXT)) == 0)
 344
 345 /* EXIM_DBDELETE_CURSOR - terminate scanning operation (null). Make it
 346 refer to cursor, to keep picky compilers happy. */
 347 #define EXIM_DBDELETE_CURSOR(cursor) { cursor = cursor; }
 348
 349 /* EXIM_DBCLOSE */
 350 #define EXIM_DBCLOSE(db)        (db)->close(db)
 351
 352 /* Datum access types - these are intended to be assignable */
 353
 354 #define EXIM_DATUM_SIZE(datum)  (datum).size
 355 #define EXIM_DATUM_DATA(datum)  (datum).data
 356
 357 /* There's no clearing required before use, and we don't have to free anything
 358 after reading data. */
 359
 360 #define EXIM_DATUM_INIT(datum)
 361 #define EXIM_DATUM_FREE(datum)
 362
 363 #endif /* DB_VERSION_STRING */
 364
 365
 366
 367 /********************* gdbm interface definitions **********************/
 368
 369 #elif defined USE_GDBM
 370
 371 #include <gdbm.h>
 372
 373 /* Basic DB type */
 374 typedef struct {
 375        GDBM_FILE gdbm;  /* Database */
 376        datum lkey;      /* Last key, for scans */
 377 } EXIM_DB;
 378
 379 /* Cursor type, not used with gdbm: just set up a dummy */
 380 #define EXIM_CURSOR int
 381
 382 /* The datum type used for queries */
 383 #define EXIM_DATUM datum
 384
 385 /* Some text for messages */
 386
 387 #define EXIM_DBTYPE "gdbm"
 388
 389 /* Access functions */
 390
 391 /* EXIM_DBOPEN - returns a EXIM_DB *, NULL if failed */
 392 #define EXIM_DBOPEN(name, flags, mode, dbpp) \
 393      { (*(dbpp)) = (EXIM_DB *) malloc(sizeof(EXIM_DB));\
 394        if (*(dbpp) != NULL) { \
 395          (*(dbpp))->lkey.dptr = NULL;\
 396          (*(dbpp))->gdbm = gdbm_open(CS name, 0, (((flags) & O_CREAT))?GDBM_WRCREAT:(((flags) & (O_RDWR|O_WRONLY))?GDBM_WRITER:GDBM_READER), mode, 0);\
 397           if ((*(dbpp))->gdbm == NULL) {\
 398               free(*(dbpp));\
 399               *(dbpp) = NULL;\
 400           }\
 401        }\
 402      }
 403
 404 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 405 #define EXIM_DBGET(db, key, data)      \
 406        (data = gdbm_fetch(db->gdbm, key), data.dptr != NULL)
 407
 408 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 409 #define EXIM_DBPUT(db, key, data)      \
 410        gdbm_store(db->gdbm, key, data, GDBM_REPLACE)
 411
 412 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 413 #define EXIM_DBPUTB(db, key, data)      \
 414        gdbm_store(db->gdbm, key, data, GDBM_INSERT)
 415
 416 /* Returns from EXIM_DBPUTB */
 417
 418 #define EXIM_DBPUTB_OK  0
 419 #define EXIM_DBPUTB_DUP 1
 420
 421 /* EXIM_DBDEL */
 422 #define EXIM_DBDEL(db, key) gdbm_delete(db->gdbm, key)
 423
 424 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation (null) */
 425 #define EXIM_DBCREATE_CURSOR(db, cursor) {}
 426
 427 /* EXIM_DBSCAN */
 428 #define EXIM_DBSCAN(db, key, data, first, cursor)      \
 429   ( key = ((first)? gdbm_firstkey(db->gdbm) : gdbm_nextkey(db->gdbm, db->lkey)), \
 430     (((db)->lkey.dptr != NULL)? (free((db)->lkey.dptr),1) : 1),\
 431     db->lkey = key, key.dptr != NULL)
 432
 433 /* EXIM_DBDELETE_CURSOR - terminate scanning operation (null). Make it
 434 refer to cursor, to keep picky compilers happy. */
 435 #define EXIM_DBDELETE_CURSOR(cursor) { cursor = cursor; }
 436
 437 /* EXIM_DBCLOSE */
 438 #define EXIM_DBCLOSE(db) \
 439 { gdbm_close((db)->gdbm);\
 440   if ((db)->lkey.dptr != NULL) free((db)->lkey.dptr);\
 441   free(db); }
 442
 443 /* Datum access types - these are intended to be assignable */
 444
 445 #define EXIM_DATUM_SIZE(datum) (datum).dsize
 446 #define EXIM_DATUM_DATA(datum) (datum).dptr
 447
 448 /* There's no clearing required before use, but we have to free the dptr
 449 after reading data. */
 450
 451 #define EXIM_DATUM_INIT(datum)
 452 #define EXIM_DATUM_FREE(datum) free(datum.dptr)
 453
 454 #else  /* USE_GDBM */
 455
 456
 457 /* If none of USE_DB, USG_GDBM, or USE_TDB are set, the default is the NDBM
 458 interface */
 459
 460
 461 /********************* ndbm interface definitions **********************/
 462
 463 #include <ndbm.h>
 464
 465 /* Basic DB type */
 466 #define EXIM_DB DBM
 467
 468 /* Cursor type, not used with ndbm: 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 "ndbm"
 477
 478 /* Access functions */
 479
 480 /* EXIM_DBOPEN - returns a EXIM_DB *, NULL if failed */
 481 #define EXIM_DBOPEN(name, flags, mode, dbpp) \
 482        *(dbpp) = dbm_open(CS name, flags, mode)
 483
 484 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 485 #define EXIM_DBGET(db, key, data)      \
 486        (data = dbm_fetch(db, key), data.dptr != NULL)
 487
 488 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 489 #define EXIM_DBPUT(db, key, data)      \
 490        dbm_store(db, key, data, DBM_REPLACE)
 491
 492 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 493 #define EXIM_DBPUTB(db, key, data)      \
 494        dbm_store(db, key, data, DBM_INSERT)
 495
 496 /* Returns from EXIM_DBPUTB */
 497
 498 #define EXIM_DBPUTB_OK  0
 499 #define EXIM_DBPUTB_DUP 1
 500
 501 /* EXIM_DBDEL */
 502 #define EXIM_DBDEL(db, key) dbm_delete(db, key)
 503
 504 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation (null) */
 505 #define EXIM_DBCREATE_CURSOR(db, cursor) {}
 506
 507 /* EXIM_DBSCAN */
 508 #define EXIM_DBSCAN(db, key, data, first, cursor)      \
 509        (key = (first? dbm_firstkey(db) : dbm_nextkey(db)), key.dptr != NULL)
 510
 511 /* EXIM_DBDELETE_CURSOR - terminate scanning operation (null). Make it
 512 refer to cursor, to keep picky compilers happy. */
 513 #define EXIM_DBDELETE_CURSOR(cursor) { cursor = cursor; }
 514
 515 /* EXIM_DBCLOSE */
 516 #define EXIM_DBCLOSE(db) dbm_close(db)
 517
 518 /* Datum access types - these are intended to be assignable */
 519
 520 #define EXIM_DATUM_SIZE(datum) (datum).dsize
 521 #define EXIM_DATUM_DATA(datum) (datum).dptr
 522
 523 /* There's no clearing required before use, and we don't have to free anything
 524 after reading data. */
 525
 526 #define EXIM_DATUM_INIT(datum)
 527 #define EXIM_DATUM_FREE(datum)
 528
 529 #endif /* USE_GDBM */
 530
 531 /********************* End of dbm library definitions **********************/
 532
 533
 534 /* Structure for carrying around an open DBM file, and an open locking file
 535 that relates to it. */
 536
 537 typedef struct {
 538   EXIM_DB *dbptr;
 539   int lockfd;
 540 } open_db;
 541
 542
 543 /* Structures for records stored in exim database dbm files. They all
 544 start with the same fields, described in the generic type. */
 545
 546
 547 typedef struct {
 548   time_t time_stamp;      /* Timestamp of writing */
 549 } dbdata_generic;
 550
 551
 552 /* This structure keeps track of retry information for a host or a local
 553 address. */
 554
 555 typedef struct {
 556   time_t time_stamp;
 557   /*************/
 558   time_t first_failed;    /* Time of first failure */
 559   time_t last_try;        /* Time of last try */
 560   time_t next_try;        /* Time of next try */
 561   BOOL   expired;         /* Retry time has expired */
 562   int    basic_errno;     /* Errno of last failure */
 563   int    more_errno;      /* Additional information */
 564   uschar text[1];         /* Text message for last failure */
 565 } dbdata_retry;
 566
 567 /* These structures keep track of addresses that have had callout verification
 568 performed on them. There are two groups of records:
 569
 570 1. keyed by localpart@domain -
 571      Full address was tested and record holds result
 572
 573 2. keyed by domain -
 574      Domain response upto MAIL FROM:<>, postmaster, random local part;
 575
 576 If a record exists, the result field is either ccache_accept or ccache_reject,
 577 or, for a domain record only, ccache_reject_mfnull when MAIL FROM:<> was
 578 rejected. The other fields, however, (which are only relevant to domain
 579 records) may also contain ccache_unknown if that particular test has not been
 580 done.
 581
 582 Originally, there was only one structure, used for both types. However, it got
 583 expanded for domain records, so it got split. To make it possible for Exim to
 584 handle the old type of record, we retain the old definition. The different
 585 kinds of record can be distinguised by their different lengths. */
 586
 587 typedef struct {
 588   time_t time_stamp;
 589   /*************/
 590   int   result;
 591   int   postmaster_result; /* Postmaster is accepted */
 592   int   random_result;     /* Random local part was accepted */
 593 } dbdata_callout_cache_obs;
 594
 595 typedef struct {
 596   time_t time_stamp;       /* Timestamp of last address check */
 597   /*************/
 598   int   result;            /* accept or reject */
 599 } dbdata_callout_cache_address;
 600
 601 /* For this new layout, we put the additional fields (the timestamps)
 602 last so that if somebody reverts to an older Exim, the new records will
 603 still make sense because they match the old layout. */
 604
 605 typedef struct {
 606   time_t time_stamp;       /* Time stamp of last connection */
 607   /*************/
 608   int   result;            /* Domain reject or accept */
 609   int   postmaster_result; /* Postmaster result */
 610   int   random_result;     /* Random result */
 611   time_t postmaster_stamp; /* Timestamp of postmaster check */
 612   time_t random_stamp;     /* Timestamp of random check */
 613 } dbdata_callout_cache;
 614
 615 /* This structure keeps track of messages that are waiting for a particular
 616 host for a particular transport. */
 617
 618 typedef struct {
 619   time_t time_stamp;
 620   /*************/
 621   int    count;           /* Count of message ids */
 622   int    sequence;        /* Sequence for continued records */
 623   uschar text[1];         /* One long character string */
 624 } dbdata_wait;
 625
 626
 627 /* The contents of the "misc" database are a mixture of different kinds of
 628 record, as defined below. The keys used for a specific type all start with a
 629 given string such as "etrn-" or "host-serialize-". */
 630
 631
 632 /* This structure records a connection to a particular host, for the
 633 purpose of serializing access to certain hosts. For possible future extension,
 634 a field is defined for holding the count of connections, but it is not
 635 at present in use. The same structure is used for recording a running ETRN
 636 process. */
 637
 638 typedef struct {
 639   time_t time_stamp;
 640   /*************/
 641   int    count;           /* Reserved for possible connection count */
 642 } dbdata_serialize;
 643
 644
 645 /* This structure records the information required for the ratelimit
 646 ACL condition. */
 647
 648 typedef struct {
 649   time_t time_stamp;
 650   /*************/
 651   int    time_usec;       /* Fractional part of time, from gettimeofday() */
 652   double rate;            /* Smoothed sending rate at that time */
 653 } dbdata_ratelimit;
 654
 655 /* Same as above, plus a Bloom filter for uniquifying events. */
 656
 657 typedef struct {
 658   dbdata_ratelimit dbd;
 659   time_t   bloom_epoch;   /* When the Bloom filter was last reset */
 660   unsigned bloom_size;    /* Number of bytes in the Bloom filter */
 661   uschar   bloom[40];     /* Bloom filter which may be larger than this */
 662 } dbdata_ratelimit_unique;
 663
 664
 665 /* End of dbstuff.h */