src/src/hintsdb.h

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
   6 /* Copyright (c) University of Cambridge 1995 - 2018 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8 /* SPDX-License-Identifier: GPL-2.0-only */
   9
  10 /* This header file contains macro definitions so that a variety of DBM
  11 libraries can be used by Exim. Nigel Metheringham provided the original set for
  12 Berkeley DB 1.x in native mode and ndbm. Subsequently, versions for Berkeley DB
  13 2.x and 3.x were added. Later still, support for tdb was added, courtesy of
  14 James Antill. Most recently, support for native mode gdbm was added, with code
  15 from Pierre A. Humblet, so Exim could be made to work with Cygwin.
  16
  17 For convenience, the definitions of the structures used in the various hints
  18 databases are also kept in this file, which is used by the maintenance
  19 utilities as well as the main Exim binary. */
  20
  21 #ifndef HINTSDB_H
  22 #define HINTSDB_H
  23
  24
  25 #if defined(USE_TDB)
  26
  27 /* ************************* tdb interface ************************ */
  28 /*XXX https://manpages.org/tdb/3 mentions concurrent writes.
  29 Could we lose the file lock? */
  30
  31 # include <tdb.h>
  32
  33 /* Basic DB type */
  34 # define EXIM_DB TDB_CONTEXT
  35
  36 /* Cursor type: tdb uses the previous "key" in _nextkey() (really it wants
  37 tdb_traverse to be called) */
  38 # define EXIM_CURSOR TDB_DATA
  39
  40 /* The datum type used for queries */
  41 # define EXIM_DATUM TDB_DATA
  42
  43 /* Some text for messages */
  44 # define EXIM_DBTYPE "tdb"
  45
  46 /* Access functions */
  47
  48 /* EXIM_DBOPEN - return pointer to an EXIM_DB, NULL if failed */
  49 static inline EXIM_DB *
  50 exim_dbopen__(const uschar * name, const uschar * dirname, int flags,
  51   unsigned mode)
  52 {
  53 return tdb_open(CS name, 0, TDB_DEFAULT, flags, mode);
  54 }
  55
  56 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
  57 static inline BOOL
  58 exim_dbget(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * res)
  59 {
  60 *res = tdb_fetch(dbp, *key);    /* A struct arg and return!! */
  61 return res->dptr != NULL;
  62 }
  63
  64 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
  65 static inline int
  66 exim_dbput(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
  67 { return tdb_store(dbp, *key, *data, TDB_REPLACE); }
  68
  69 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
  70 static inline int
  71 exim_dbputb(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
  72 { return tdb_store(dbp, *key, *data, TDB_INSERT); }
  73
  74 /* Returns from EXIM_DBPUTB */
  75
  76 # define EXIM_DBPUTB_OK  0
  77 # define EXIM_DBPUTB_DUP (-1)
  78
  79 /* EXIM_DBDEL */
  80 static inline int
  81 exim_dbdel(EXIM_DB * dbp, EXIM_DATUM * key)
  82 { return tdb_delete(dbp, *key); }
  83
  84 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation */
  85 static inline EXIM_CURSOR *
  86 exim_dbcreate_cursor(EXIM_DB * dbp)
  87 {
  88 EXIM_CURSOR * c = store_malloc(sizeof(TDB_DATA));
  89 c->dptr = NULL;
  90 return c;
  91 }
  92
  93 /* EXIM_DBSCAN - This is complicated because we have to free the last datum
  94 free() must not die when passed NULL */
  95
  96 static inline BOOL
  97 exim_dbscan(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * res, BOOL first,
  98   EXIM_CURSOR * cursor)
  99 {
 100 *key = first ? tdb_firstkey(dbp) : tdb_nextkey(dbp, *cursor);
 101 free(cursor->dptr);
 102 *cursor = *key;
 103 return key->dptr != NULL;
 104 }
 105
 106 /* EXIM_DBDELETE_CURSOR - terminate scanning operation. */
 107 static inline void
 108 exim_dbdelete_cursor(EXIM_CURSOR * cursor)
 109 { store_free(cursor); }
 110
 111 /* EXIM_DBCLOSE */
 112 static inline void
 113 exim_dbclose__(EXIM_DB * db)
 114 { tdb_close(db); }
 115
 116 /* Datum access */
 117
 118 static inline uschar *
 119 exim_datum_data_get(EXIM_DATUM * dp)
 120 { return US dp->dptr; }
 121 static inline void
 122 exim_datum_data_set(EXIM_DATUM * dp, void * s)
 123 { dp->dptr = s; }
 124
 125 static inline unsigned
 126 exim_datum_size_get(EXIM_DATUM * dp)
 127 { return dp->dsize; }
 128 static inline void
 129 exim_datum_size_set(EXIM_DATUM * dp, unsigned n)
 130 { dp->dsize = n; }
 131
 132 /* No initialization is needed. */
 133
 134 static inline void
 135 exim_datum_init(EXIM_DATUM * d)
 136 { }
 137
 138 /* Free the stuff inside the datum. */
 139
 140 static inline void
 141 exim_datum_free(EXIM_DATUM * d)
 142 {
 143 free(d->dptr);
 144 d->dptr = NULL;
 145 }
 146
 147 /* size limit */
 148
 149 # define EXIM_DB_RLIMIT 150
 150
 151
 152
 153
 154
 155
 156 /********************* Berkeley db native definitions **********************/
 157
 158 #elif defined USE_DB
 159
 160 # include <db.h>
 161
 162 /* 1.x did no locking
 163    2.x had facilities, but exim does it's own
 164    3.x+ unknown
 165 */
 166
 167 /* We can distinguish between versions 1.x and 2.x/3.x by looking for a
 168 definition of DB_VERSION_STRING, which is present in versions 2.x onwards. */
 169
 170 # ifdef DB_VERSION_STRING
 171
 172 #  if DB_VERSION_MAJOR >= 6
 173 #   error Version 6 and later BDB API is not supported
 174 #  endif
 175
 176 /* The API changed (again!) between the 2.x and 3.x versions */
 177
 178 # if DB_VERSION_MAJOR >= 3
 179
 180 /***************** Berkeley db 3.x/4.x native definitions ******************/
 181
 182 /* Basic DB type */
 183 #  if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 1)
 184 #   define EXIM_DB       DB_ENV
 185 /* Cursor type, for scanning */
 186 #   define EXIM_CURSOR   DBC
 187
 188 /* The datum type used for queries */
 189 #   define EXIM_DATUM    DBT
 190
 191 /* Some text for messages */
 192 #   define EXIM_DBTYPE   "db (v4.1+)"
 193
 194 /* Only more-recent versions.  5+ ? */
 195 #   ifndef DB_FORCESYNC
 196 #    define DB_FORCESYNC 0
 197 #   endif
 198
 199 /* Error callback */
 200 /* For Berkeley DB >= 2, we can define a function to be called in case of DB
 201 errors. This should help with debugging strange DB problems, e.g. getting "File
 202 exists" when you try to open a db file. The API for this function was changed
 203 at DB release 4.3. */
 204
 205 static inline void
 206 dbfn_bdb_error_callback(const DB_ENV * dbenv, const char * pfx, const char * msg)
 207 {
 208 #ifndef MACRO_PREDEF
 209 log_write(0, LOG_MAIN, "Berkeley DB error: %s", msg);
 210 #endif
 211 }
 212
 213
 214
 215 /* Access functions */
 216
 217 /* EXIM_DBOPEN - return pointer to an EXIM_DB, NULL if failed */
 218 /* The API changed for DB 4.1. - and we also starting using the "env" with a
 219 specified working dir, to avoid the DBCONFIG file trap. */
 220
 221 #   define ENV_TO_DB(env) ((DB *)(((EXIM_DB *)env)->app_private))
 222
 223 static inline EXIM_DB *
 224 exim_dbopen__(const uschar * name, const uschar * dirname, int flags,
 225   unsigned mode)
 226 {
 227 EXIM_DB * dbp;
 228 DB * b;
 229 if (  db_env_create(&dbp, 0) != 0
 230    || (dbp->set_errcall(dbp, dbfn_bdb_error_callback), 0)
 231    || dbp->open(dbp, CS dirname, DB_CREATE|DB_INIT_MPOOL|DB_PRIVATE, 0) != 0
 232    )
 233   return NULL;
 234 if (db_create(&b, dbp, 0) == 0)
 235   {
 236   dbp->app_private = b;
 237   if (b->open(b, NULL, CS name, NULL,
 238               flags == O_RDONLY ? DB_UNKNOWN : DB_HASH,
 239               flags == O_RDONLY ? DB_RDONLY : DB_CREATE,
 240               mode) == 0
 241           )
 242     return dbp;
 243
 244   b->close(b, 0);
 245   }
 246 dbp->close(dbp, 0);
 247 return NULL;
 248 }
 249
 250 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 251 static inline BOOL
 252 exim_dbget(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * res)
 253 {
 254 DB * b = ENV_TO_DB(dbp);
 255 return b->get(b, NULL, key, res, 0) == 0;
 256 }
 257
 258 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 259 static inline int
 260 exim_dbput(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
 261 {
 262 DB * b = ENV_TO_DB(dbp);
 263 return b->put(b, NULL, key, data, 0);
 264 }
 265
 266 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 267 static inline int
 268 exim_dbputb(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
 269 {
 270 DB * b = ENV_TO_DB(dbp);
 271 return b->put(b, NULL, key, data, DB_NOOVERWRITE);
 272 }
 273
 274 /* Return values from EXIM_DBPUTB */
 275
 276 #   define EXIM_DBPUTB_OK  0
 277 #   define EXIM_DBPUTB_DUP DB_KEYEXIST
 278
 279 /* EXIM_DBDEL */
 280 static inline int
 281 exim_dbdel(EXIM_DB * dbp, EXIM_DATUM * key)
 282 {
 283 DB * b = ENV_TO_DB(dbp);
 284 return b->del(b, NULL, key, 0);
 285 }
 286
 287 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation */
 288
 289 static inline EXIM_CURSOR *
 290 exim_dbcreate_cursor(EXIM_DB * dbp)
 291 {
 292 DB * b = ENV_TO_DB(dbp);
 293 EXIM_CURSOR * c;
 294 b->cursor(b, NULL, &c, 0);
 295 return c;
 296 }
 297
 298 /* EXIM_DBSCAN - returns TRUE if data is returned, FALSE at end */
 299 static inline BOOL
 300 exim_dbscan(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data, BOOL first,
 301   EXIM_CURSOR * cursor)
 302 {
 303 return cursor->c_get(cursor, key, data, first ? DB_FIRST : DB_NEXT) == 0;
 304 }
 305
 306 /* EXIM_DBDELETE_CURSOR - terminate scanning operation */
 307 static inline void
 308 exim_dbdelete_cursor(EXIM_CURSOR * cursor)
 309 { cursor->c_close(cursor); }
 310
 311 /* EXIM_DBCLOSE */
 312 static inline void
 313 exim_dbclose__(EXIM_DB * dbp_o)
 314 {
 315 DB_ENV * dbp = dbp_o;
 316 DB * b = ENV_TO_DB(dbp);
 317 b->close(b, 0);
 318 dbp->close(dbp, DB_FORCESYNC);
 319 }
 320
 321 /* Datum access */
 322
 323 static inline uschar *
 324 exim_datum_data_get(EXIM_DATUM * dp)
 325 { return dp->data; }
 326 static inline void
 327 exim_datum_data_set(EXIM_DATUM * dp, void * s)
 328 { dp->data = s; }
 329
 330 static inline unsigned
 331 exim_datum_size_get(EXIM_DATUM * dp)
 332 { return dp->size; }
 333 static inline void
 334 exim_datum_size_set(EXIM_DATUM * dp, unsigned n)
 335 { dp->size = n; }
 336
 337 /* The whole datum structure contains other fields that must be cleared
 338 before use, but we don't have to free anything after reading data. */
 339
 340 static inline void
 341 exim_datum_init(EXIM_DATUM * d)
 342 { memset(d, 0, sizeof(*d)); }
 343
 344 static inline void
 345 exim_datum_free(EXIM_DATUM * d)
 346 { }
 347
 348 #  else /* pre- 4.1 */
 349
 350 #   define EXIM_DB       DB
 351
 352 /* Cursor type, for scanning */
 353 #   define EXIM_CURSOR   DBC
 354
 355 /* The datum type used for queries */
 356 #   define EXIM_DATUM    DBT
 357
 358 /* Some text for messages */
 359 #   define EXIM_DBTYPE   "db (v3/4)"
 360
 361 /* Access functions */
 362
 363 /* EXIM_DBOPEN - return pointer to an EXIM_DB, NULL if failed */
 364 static inline EXIM_DB *
 365 exim_dbopen__(const uschar * name, const uschar * dirname, int flags,
 366   unsigned mode)
 367 {
 368 EXIM_DB * dbp;
 369 return db_create(&dbp, NULL, 0) == 0
 370   && (  dbp->set_errcall(dbp, dbfn_bdb_error_callback),
 371         dbp->open(dbp, CS name, NULL,
 372           flags == O_RDONLY ? DB_UNKNOWN : DB_HASH,
 373           flags == O_RDONLY ? DB_RDONLY : DB_CREATE,
 374           mode)
 375      ) == 0
 376   ? dbp : NULL;
 377 }
 378
 379 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 380 static inline BOOL
 381 exim_dbget(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * res)
 382 { return dbp->get(dbp, NULL, key, res, 0) == 0; }
 383
 384 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 385 static inline int
 386 exim_dbput(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
 387 { return dbp->put(dbp, NULL, key, data, 0); }
 388
 389 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 390 static inline int
 391 exim_dbputb(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
 392 { return dbp->put(dbp, NULL, key, data, DB_NOOVERWRITE); }
 393
 394 /* Return values from EXIM_DBPUTB */
 395
 396 #   define EXIM_DBPUTB_OK  0
 397 #   define EXIM_DBPUTB_DUP DB_KEYEXIST
 398
 399 /* EXIM_DBDEL */
 400 static inline int
 401 exim_dbdel(EXIM_DB * dbp, EXIM_DATUM * key)
 402 { return dbp->del(dbp, NULL, key, 0); }
 403
 404 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation */
 405
 406 static inline EXIM_CURSOR *
 407 exim_dbcreate_cursor(EXIM_DB * dbp)
 408 {
 409 EXIM_CURSOR * c;
 410 dbp->cursor(dbp, NULL, &c, 0);
 411 return c;
 412 }
 413
 414 /* EXIM_DBSCAN - returns TRUE if data is returned, FALSE at end */
 415 static inline BOOL
 416 exim_dbscan(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data, BOOL first,
 417   EXIM_CURSOR * cursor)
 418 {
 419 return cursor->c_get(cursor, key, data, first ? DB_FIRST : DB_NEXT) == 0;
 420 }
 421
 422 /* EXIM_DBDELETE_CURSOR - terminate scanning operation */
 423 static inline void
 424 exim_dbdelete_cursor(EXIM_CURSOR * cursor)
 425 { cursor->c_close(cursor); }
 426
 427 /* EXIM_DBCLOSE */
 428 static inline void
 429 exim_dbclose__(EXIM_DB * dbp)
 430 { dbp->close(dbp, 0); }
 431
 432 /* Datum access */
 433
 434 static inline uschar *
 435 exim_datum_data_get(EXIM_DATUM * dp)
 436 { return US dp->dptr; }
 437 static inline void
 438 exim_datum_data_set(EXIM_DATUM * dp, void * s)
 439 { dp->dptr = s; }
 440
 441 static inline uschar *
 442 exim_datum_size_get(EXIM_DATUM * dp)
 443 { return US dp->size; }
 444 static inline void
 445 exim_datum_size_set(EXIM_DATUM * dp, uschar * s)
 446 { dp->size = CS s; }
 447
 448 /* The whole datum structure contains other fields that must be cleared
 449 before use, but we don't have to free anything after reading data. */
 450
 451 static inline void
 452 exim_datum_init(EXIM_DATUM * d)
 453 { memset(d, 0, sizeof(*d)); }
 454
 455 static inline void
 456 exim_datum_free(EXIM_DATUM * d)
 457 { }
 458
 459 #  endif
 460
 461
 462 #  else /* DB_VERSION_MAJOR >= 3 */
 463 #   error Berkeley DB versions earlier than 3 are not supported */
 464 #  endif /* DB_VERSION_MAJOR */
 465 # else
 466 #  error Berkeley DB version 1 is no longer supported
 467 # endif /* DB_VERSION_STRING */
 468
 469
 470 /* all BDB versions */
 471 /* size limit */
 472
 473 # define EXIM_DB_RLIMIT 150
 474
 475
 476
 477
 478
 479
 480 /********************* gdbm interface definitions **********************/
 481
 482 #elif defined USE_GDBM
 483 /*XXX TODO: exim's locfile not needed */
 484
 485 # include <gdbm.h>
 486
 487 /* Basic DB type */
 488 typedef struct {
 489        GDBM_FILE gdbm;  /* Database */
 490        datum lkey;      /* Last key, for scans */
 491 } EXIM_DB;
 492
 493 /* Cursor type, not used with gdbm: just set up a dummy */
 494 # define EXIM_CURSOR int
 495
 496 /* The datum type used for queries */
 497 # define EXIM_DATUM datum
 498
 499 /* Some text for messages */
 500
 501 # define EXIM_DBTYPE "gdbm"
 502
 503 /* Access functions */
 504
 505 /* EXIM_DBOPEN - return pointer to an EXIM_DB, NULL if failed */
 506 static inline EXIM_DB *
 507 exim_dbopen__(const uschar * name, const uschar * dirname, int flags,
 508   unsigned mode)
 509 {
 510 EXIM_DB * dbp = malloc(sizeof(EXIM_DB));        /*XXX why not exim mem-mgmt? */
 511 if (dbp)
 512   {
 513   dbp->lkey.dptr = NULL;
 514   dbp->gdbm = gdbm_open(CS name, 0,
 515     flags & O_CREAT ? GDBM_WRCREAT
 516     : flags & (O_RDWR|O_WRONLY) ? GDBM_WRITER
 517     : GDBM_READER,
 518     mode, 0);
 519   if (dbp->gdbm) return dbp;
 520   free(dbp);
 521   }
 522 return NULL;
 523 }
 524
 525 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 526 static inline BOOL
 527 exim_dbget(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * res)
 528 {
 529 *res = gdbm_fetch(dbp->gdbm, *key);     /* A struct arg & return! */
 530 return res->dptr != NULL;
 531 }
 532
 533 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 534 static inline int
 535 exim_dbput(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
 536 { return gdbm_store(dbp->gdbm, *key, *data, GDBM_REPLACE); }
 537
 538 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 539 static inline int
 540 exim_dbputb(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
 541 { return gdbm_store(dbp->gdbm, *key, *data, GDBM_INSERT); }
 542
 543 /* Returns from EXIM_DBPUTB */
 544
 545 # define EXIM_DBPUTB_OK  0
 546 # define EXIM_DBPUTB_DUP 1
 547
 548 /* EXIM_DBDEL */
 549 static inline int
 550 exim_dbdel(EXIM_DB * dbp, EXIM_DATUM * key)
 551 { return gdbm_delete(dbp->gdbm, *key); }
 552
 553 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation (null) */
 554 static inline EXIM_CURSOR *
 555 exim_dbcreate_cursor(EXIM_DB * dbp)
 556 { return NULL; }
 557
 558 /* EXIM_DBSCAN */
 559 static inline BOOL
 560 exim_dbscan(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data, BOOL first,
 561   EXIM_CURSOR * cursor)
 562 {
 563 char * s;
 564 *key = first ? gdbm_firstkey(dbp->gdbm) : gdbm_nextkey(dbp->gdbm, dbp->lkey);
 565 if ((s = dbp->lkey.dptr)) free(s);
 566 dbp->lkey = *key;
 567 return key->dptr != NULL;
 568 }
 569
 570 /* EXIM_DBDELETE_CURSOR - terminate scanning operation (null). */
 571 static inline void
 572 exim_dbdelete_cursor(EXIM_CURSOR * cursor)
 573 { }
 574
 575 /* EXIM_DBCLOSE */
 576 static inline void
 577 exim_dbclose__(EXIM_DB * dbp)
 578 {
 579 char * s;
 580 gdbm_close(dbp->gdbm);
 581 if ((s = dbp->lkey.dptr)) free(s);
 582 free(dbp);
 583 }
 584
 585 /* Datum access types */
 586
 587 static inline uschar *
 588 exim_datum_data_get(EXIM_DATUM * dp)
 589 { return US dp->dptr; }
 590 static inline void
 591 exim_datum_data_set(EXIM_DATUM * dp, void * s)
 592 { dp->dptr = s; }
 593
 594 static inline unsigned
 595 exim_datum_size_get(EXIM_DATUM * dp)
 596 { return dp->dsize; }
 597 static inline void
 598 exim_datum_size_set(EXIM_DATUM * dp, unsigned n)
 599 { dp->dsize = n; }
 600
 601 /* There's no clearing required before use, but we have to free the dptr
 602 after reading data. */
 603
 604 static inline void
 605 exim_datum_init(EXIM_DATUM * d)
 606 { }
 607
 608 static inline void
 609 exim_datum_free(EXIM_DATUM * d)
 610 { free(d->dptr); }
 611
 612 /* size limit */
 613
 614 # define EXIM_DB_RLIMIT 150
 615
 616 #else  /* USE_GDBM */
 617
 618
 619
 620
 621
 622
 623 /* If none of USE_DB, USG_GDBM, or USE_TDB are set, the default is the NDBM
 624 interface */
 625
 626
 627 /********************* ndbm interface definitions **********************/
 628
 629 # include <ndbm.h>
 630
 631 /* Basic DB type */
 632 # define EXIM_DB DBM
 633
 634 /* Cursor type, not used with ndbm: just set up a dummy */
 635 # define EXIM_CURSOR int
 636
 637 /* The datum type used for queries */
 638 # define EXIM_DATUM datum
 639
 640 /* Some text for messages */
 641
 642 # define EXIM_DBTYPE "ndbm"
 643
 644 /* Access functions */
 645
 646 /* EXIM_DBOPEN - returns a EXIM_DB *, NULL if failed */
 647 /* Check that the name given is not present. This catches
 648 a directory name; otherwise we would create the name.pag and
 649 name.dir files in the directory's parent. */
 650
 651 static inline EXIM_DB *
 652 exim_dbopen__(const uschar * name, const uschar * dirname, int flags,
 653   unsigned mode)
 654 {
 655 struct stat st;
 656 if (!(flags & O_CREAT) || lstat(CCS name, &st) != 0 && errno == ENOENT)
 657   return dbm_open(CS name, flags, mode);
 658 #ifndef COMPILE_UTILITY
 659 debug_printf("%s %d errno %s\n", __FUNCTION__, __LINE__, strerror(errno));
 660 #endif
 661 errno = (st.st_mode & S_IFMT) == S_IFDIR ? EISDIR : EEXIST;
 662 return NULL;
 663 }
 664
 665 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
 666 static inline BOOL
 667 exim_dbget(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * res)
 668 {
 669 *res = dbm_fetch(dbp, *key);    /* A struct arg & return! */
 670 return res->dptr != NULL;
 671 }
 672
 673 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 674 static inline int
 675 exim_dbput(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
 676 { return dbm_store(dbp, *key, *data, DBM_REPLACE); }
 677
 678 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 679 static inline int
 680 exim_dbputb(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
 681 { return dbm_store(dbp, *key, *data, DBM_INSERT); }
 682
 683 /* Returns from EXIM_DBPUTB */
 684
 685 # define EXIM_DBPUTB_OK  0
 686 # define EXIM_DBPUTB_DUP 1
 687
 688 /* EXIM_DBDEL */
 689 static inline int
 690 exim_dbdel(EXIM_DB * dbp, EXIM_DATUM * key)
 691 { return dbm_delete(dbp, *key); }
 692
 693 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation (null) */
 694 static inline EXIM_CURSOR *
 695 exim_dbcreate_cursor(EXIM_DB * dbp)
 696 { return NULL; }
 697
 698 /* EXIM_DBSCAN */
 699 static inline BOOL
 700 exim_dbscan(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data, BOOL first,
 701   EXIM_CURSOR * cursor)
 702 {
 703 *key = first ? dbm_firstkey(dbp) : dbm_nextkey(dbp);
 704 return key->dptr != NULL;
 705 }
 706
 707 /* EXIM_DBDELETE_CURSOR - terminate scanning operation (null). */
 708 static inline void
 709 exim_dbdelete_cursor(EXIM_CURSOR * cursor)
 710 { }
 711
 712 /* EXIM_DBCLOSE */
 713 static inline void
 714 exim_dbclose__(EXIM_DB * dbp)
 715 { dbm_close(dbp); }
 716
 717 /* Datum access types */
 718
 719 static inline uschar *
 720 exim_datum_data_get(EXIM_DATUM * dp)
 721 { return US dp->dptr; }
 722 static inline void
 723 exim_datum_data_set(EXIM_DATUM * dp, void * s)
 724 { dp->dptr = s; }
 725
 726 static inline unsigned
 727 exim_datum_size_get(EXIM_DATUM * dp)
 728 { return dp->dsize; }
 729 static inline void
 730 exim_datum_size_set(EXIM_DATUM * dp, unsigned n)
 731 { dp->dsize = n; }
 732
 733 /* There's no clearing required before use, and we don't have to free anything
 734 after reading data. */
 735
 736 static inline void
 737 exim_datum_init(EXIM_DATUM * d)
 738 { }
 739
 740 static inline void
 741 exim_datum_free(EXIM_DATUM * d)
 742 { }
 743
 744 /* size limit */
 745
 746 # define EXIM_DB_RLIMIT 150
 747
 748 #endif /* USE_GDBM */
 749
 750
 751
 752
 753
 754 #if defined(COMPILE_UTILITY) || defined(MACRO_PREDEF)
 755
 756 static inline EXIM_DB *
 757 exim_dbopen(const uschar * name, const uschar * dirname, int flags,
 758   unsigned mode)
 759 {
 760 return exim_dbopen__(name, dirname, flags, mode);
 761 }
 762
 763 static inline void
 764 exim_dbclose(EXIM_DB * dbp)
 765 { exim_dbclose__(dbp); }
 766
 767 #else   /*  exim mainline code */
 768
 769 /* Wrappers for open/close with debug tracing */
 770
 771 extern void debug_printf_indent(const char *, ...);
 772 static inline BOOL is_tainted(const void *);
 773
 774 static inline EXIM_DB *
 775 exim_dbopen(const uschar * name, const uschar * dirname, int flags,
 776   unsigned mode)
 777 {
 778 void * dbp;
 779 DEBUG(D_hints_lookup)
 780   debug_printf_indent("EXIM_DBOPEN: file <%s> dir <%s> flags=%s\n",
 781     name, dirname,
 782     flags == O_RDONLY ? "O_RDONLY"
 783     : flags == O_RDWR ? "O_RDWR"
 784     : flags == (O_RDWR|O_CREAT) ? "O_RDWR|O_CREAT"
 785     : "??");
 786 if (is_tainted(name) || is_tainted(dirname))
 787   {
 788   log_write(0, LOG_MAIN|LOG_PANIC, "Tainted name for DB file not permitted");
 789   dbp = NULL;
 790   }
 791 else
 792   dbp = exim_dbopen__(name, dirname, flags, mode);
 793
 794 DEBUG(D_hints_lookup) debug_printf_indent("returned from EXIM_DBOPEN: %p\n", dbp);
 795 return dbp;
 796 }
 797
 798 static inline void
 799 exim_dbclose(EXIM_DB * dbp)
 800 {
 801 DEBUG(D_hints_lookup) debug_printf_indent("EXIM_DBCLOSE(%p)\n", dbp);
 802 exim_dbclose__(dbp);
 803 }
 804
 805 # endif         /* defined(COMPILE_UTILITY) || defined(MACRO_PREDEF) */
 806
 807 /********************* End of dbm library definitions **********************/
 808
 809
 810 #endif  /* whole file */
 811 /* End of hintsdb.h */