1 /* $NetBSD: dict_db.c,v 1.1.1.1 2009/06/23 10:08:59 tron Exp $ */ 2 3 /*++ 4 /* NAME 5 /* dict_db 3 6 /* SUMMARY 7 /* dictionary manager interface to DB files 8 /* SYNOPSIS 9 /* #include <dict_db.h> 10 /* 11 /* int dict_db_cache_size; 12 /* 13 /* DICT *dict_hash_open(path, open_flags, dict_flags) 14 /* const char *path; 15 /* int open_flags; 16 /* int dict_flags; 17 /* 18 /* DICT *dict_btree_open(path, open_flags, dict_flags) 19 /* const char *path; 20 /* int open_flags; 21 /* int dict_flags; 22 /* DESCRIPTION 23 /* dict_XXX_open() opens the specified DB database. The result is 24 /* a pointer to a structure that can be used to access the dictionary 25 /* using the generic methods documented in dict_open(3). 26 /* 27 /* The dict_db_cache_size variable specifies a non-default per-table 28 /* I/O buffer size. The default buffer size is adequate for reading. 29 /* For better performance while creating a large table, specify a large 30 /* buffer size before opening the file. 31 /* 32 /* Arguments: 33 /* .IP path 34 /* The database pathname, not including the ".db" suffix. 35 /* .IP open_flags 36 /* Flags passed to dbopen(). 37 /* .IP dict_flags 38 /* Flags used by the dictionary interface. 39 /* SEE ALSO 40 /* dict(3) generic dictionary manager 41 /* DIAGNOSTICS 42 /* Fatal errors: cannot open file, write error, out of memory. 43 /* LICENSE 44 /* .ad 45 /* .fi 46 /* The Secure Mailer license must be distributed with this software. 47 /* AUTHOR(S) 48 /* Wietse Venema 49 /* IBM T.J. Watson Research 50 /* P.O. Box 704 51 /* Yorktown Heights, NY 10598, USA 52 /*--*/ 53 54 #include "sys_defs.h" 55 56 #ifdef HAS_DB 57 58 /* System library. */ 59 60 #include <sys/stat.h> 61 #include <limits.h> 62 #ifdef PATH_DB_H 63 #include PATH_DB_H 64 #else 65 #include <db.h> 66 #endif 67 #include <string.h> 68 #include <unistd.h> 69 #include <errno.h> 70 71 #if defined(_DB_185_H_) && defined(USE_FCNTL_LOCK) 72 #error "Error: this system must not use the db 1.85 compatibility interface" 73 #endif 74 75 #ifndef DB_VERSION_MAJOR 76 #define DB_VERSION_MAJOR 1 77 #define DICT_DB_GET(db, key, val, flag) db->get(db, key, val, flag) 78 #define DICT_DB_PUT(db, key, val, flag) db->put(db, key, val, flag) 79 #define DICT_DB_DEL(db, key, flag) db->del(db, key, flag) 80 #define DICT_DB_SYNC(db, flag) db->sync(db, flag) 81 #define DICT_DB_CLOSE(db) db->close(db) 82 #define DONT_CLOBBER R_NOOVERWRITE 83 #endif 84 85 #if DB_VERSION_MAJOR > 1 86 #define DICT_DB_GET(db, key, val, flag) sanitize(db->get(db, 0, key, val, flag)) 87 #define DICT_DB_PUT(db, key, val, flag) sanitize(db->put(db, 0, key, val, flag)) 88 #define DICT_DB_DEL(db, key, flag) sanitize(db->del(db, 0, key, flag)) 89 #define DICT_DB_SYNC(db, flag) ((errno = db->sync(db, flag)) ? -1 : 0) 90 #define DICT_DB_CLOSE(db) ((errno = db->close(db, 0)) ? -1 : 0) 91 #define DONT_CLOBBER DB_NOOVERWRITE 92 #endif 93 94 #if (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6) 95 #define DICT_DB_CURSOR(db, curs) (db)->cursor((db), NULL, (curs)) 96 #else 97 #define DICT_DB_CURSOR(db, curs) (db)->cursor((db), NULL, (curs), 0) 98 #endif 99 100 #ifndef DB_FCNTL_LOCKING 101 #define DB_FCNTL_LOCKING 0 102 #endif 103 104 /* Utility library. */ 105 106 #include "msg.h" 107 #include "mymalloc.h" 108 #include "vstring.h" 109 #include "stringops.h" 110 #include "iostuff.h" 111 #include "myflock.h" 112 #include "dict.h" 113 #include "dict_db.h" 114 115 /* Application-specific. */ 116 117 typedef struct { 118 DICT dict; /* generic members */ 119 DB *db; /* open db file */ 120 #if DB_VERSION_MAJOR > 1 121 DBC *cursor; /* dict_db_sequence() */ 122 #endif 123 VSTRING *key_buf; /* key result */ 124 VSTRING *val_buf; /* value result */ 125 } DICT_DB; 126 127 #define SCOPY(buf, data, size) \ 128 vstring_str(vstring_strncpy(buf ? buf : (buf = vstring_alloc(10)), data, size)) 129 130 /* 131 * You can override the default dict_db_cache_size setting before calling 132 * dict_hash_open() or dict_btree_open(). This is done in mkmap_db_open() to 133 * set a larger memory pool for database (re)builds. 134 * 135 * XXX This should be specified via the DICT interface so that it becomes an 136 * object property, instead of being specified by poking a global variable 137 * so that it becomes a class property. 138 */ 139 int dict_db_cache_size = (128 * 1024); /* 128K default memory pool */ 140 141 #define DICT_DB_NELM 4096 142 143 #if DB_VERSION_MAJOR > 1 144 145 /* sanitize - sanitize db_get/put/del result */ 146 147 static int sanitize(int status) 148 { 149 150 /* 151 * XXX This is unclean but avoids a lot of clutter elsewhere. Categorize 152 * results into non-fatal errors (i.e., errors that we can deal with), 153 * success, or fatal error (i.e., all other errors). 154 */ 155 switch (status) { 156 157 case DB_NOTFOUND: /* get, del */ 158 case DB_KEYEXIST: /* put */ 159 return (1); /* non-fatal */ 160 161 case 0: 162 return (0); /* success */ 163 164 case DB_KEYEMPTY: /* get, others? */ 165 status = EINVAL; 166 /* FALLTHROUGH */ 167 default: 168 errno = status; 169 return (-1); /* fatal */ 170 } 171 } 172 173 #endif 174 175 /* dict_db_lookup - find database entry */ 176 177 static const char *dict_db_lookup(DICT *dict, const char *name) 178 { 179 DICT_DB *dict_db = (DICT_DB *) dict; 180 DB *db = dict_db->db; 181 DBT db_key; 182 DBT db_value; 183 int status; 184 const char *result = 0; 185 186 /* 187 * Sanity check. 188 */ 189 if ((dict->flags & (DICT_FLAG_TRY1NULL | DICT_FLAG_TRY0NULL)) == 0) 190 msg_panic("dict_db_lookup: no DICT_FLAG_TRY1NULL | DICT_FLAG_TRY0NULL flag"); 191 192 dict_errno = 0; 193 memset(&db_key, 0, sizeof(db_key)); 194 memset(&db_value, 0, sizeof(db_value)); 195 196 /* 197 * Optionally fold the key. 198 */ 199 if (dict->flags & DICT_FLAG_FOLD_FIX) { 200 if (dict->fold_buf == 0) 201 dict->fold_buf = vstring_alloc(10); 202 vstring_strcpy(dict->fold_buf, name); 203 name = lowercase(vstring_str(dict->fold_buf)); 204 } 205 206 /* 207 * Acquire a shared lock. 208 */ 209 if ((dict->flags & DICT_FLAG_LOCK) 210 && myflock(dict->lock_fd, INTERNAL_LOCK, MYFLOCK_OP_SHARED) < 0) 211 msg_fatal("%s: lock dictionary: %m", dict_db->dict.name); 212 213 /* 214 * See if this DB file was written with one null byte appended to key and 215 * value. 216 */ 217 if (dict->flags & DICT_FLAG_TRY1NULL) { 218 db_key.data = (void *) name; 219 db_key.size = strlen(name) + 1; 220 if ((status = DICT_DB_GET(db, &db_key, &db_value, 0)) < 0) 221 msg_fatal("error reading %s: %m", dict_db->dict.name); 222 if (status == 0) { 223 dict->flags &= ~DICT_FLAG_TRY0NULL; 224 result = SCOPY(dict_db->val_buf, db_value.data, db_value.size); 225 } 226 } 227 228 /* 229 * See if this DB file was written with no null byte appended to key and 230 * value. 231 */ 232 if (result == 0 && (dict->flags & DICT_FLAG_TRY0NULL)) { 233 db_key.data = (void *) name; 234 db_key.size = strlen(name); 235 if ((status = DICT_DB_GET(db, &db_key, &db_value, 0)) < 0) 236 msg_fatal("error reading %s: %m", dict_db->dict.name); 237 if (status == 0) { 238 dict->flags &= ~DICT_FLAG_TRY1NULL; 239 result = SCOPY(dict_db->val_buf, db_value.data, db_value.size); 240 } 241 } 242 243 /* 244 * Release the shared lock. 245 */ 246 if ((dict->flags & DICT_FLAG_LOCK) 247 && myflock(dict->lock_fd, INTERNAL_LOCK, MYFLOCK_OP_NONE) < 0) 248 msg_fatal("%s: unlock dictionary: %m", dict_db->dict.name); 249 250 return (result); 251 } 252 253 /* dict_db_update - add or update database entry */ 254 255 static void dict_db_update(DICT *dict, const char *name, const char *value) 256 { 257 DICT_DB *dict_db = (DICT_DB *) dict; 258 DB *db = dict_db->db; 259 DBT db_key; 260 DBT db_value; 261 int status; 262 263 /* 264 * Sanity check. 265 */ 266 if ((dict->flags & (DICT_FLAG_TRY1NULL | DICT_FLAG_TRY0NULL)) == 0) 267 msg_panic("dict_db_update: no DICT_FLAG_TRY1NULL | DICT_FLAG_TRY0NULL flag"); 268 269 /* 270 * Optionally fold the key. 271 */ 272 if (dict->flags & DICT_FLAG_FOLD_FIX) { 273 if (dict->fold_buf == 0) 274 dict->fold_buf = vstring_alloc(10); 275 vstring_strcpy(dict->fold_buf, name); 276 name = lowercase(vstring_str(dict->fold_buf)); 277 } 278 memset(&db_key, 0, sizeof(db_key)); 279 memset(&db_value, 0, sizeof(db_value)); 280 db_key.data = (void *) name; 281 db_value.data = (void *) value; 282 db_key.size = strlen(name); 283 db_value.size = strlen(value); 284 285 /* 286 * If undecided about appending a null byte to key and value, choose a 287 * default depending on the platform. 288 */ 289 if ((dict->flags & DICT_FLAG_TRY1NULL) 290 && (dict->flags & DICT_FLAG_TRY0NULL)) { 291 #ifdef DB_NO_TRAILING_NULL 292 dict->flags &= ~DICT_FLAG_TRY1NULL; 293 #else 294 dict->flags &= ~DICT_FLAG_TRY0NULL; 295 #endif 296 } 297 298 /* 299 * Optionally append a null byte to key and value. 300 */ 301 if (dict->flags & DICT_FLAG_TRY1NULL) { 302 db_key.size++; 303 db_value.size++; 304 } 305 306 /* 307 * Acquire an exclusive lock. 308 */ 309 if ((dict->flags & DICT_FLAG_LOCK) 310 && myflock(dict->lock_fd, INTERNAL_LOCK, MYFLOCK_OP_EXCLUSIVE) < 0) 311 msg_fatal("%s: lock dictionary: %m", dict_db->dict.name); 312 313 /* 314 * Do the update. 315 */ 316 if ((status = DICT_DB_PUT(db, &db_key, &db_value, 317 (dict->flags & DICT_FLAG_DUP_REPLACE) ? 0 : DONT_CLOBBER)) < 0) 318 msg_fatal("error writing %s: %m", dict_db->dict.name); 319 if (status) { 320 if (dict->flags & DICT_FLAG_DUP_IGNORE) 321 /* void */ ; 322 else if (dict->flags & DICT_FLAG_DUP_WARN) 323 msg_warn("%s: duplicate entry: \"%s\"", dict_db->dict.name, name); 324 else 325 msg_fatal("%s: duplicate entry: \"%s\"", dict_db->dict.name, name); 326 } 327 if (dict->flags & DICT_FLAG_SYNC_UPDATE) 328 if (DICT_DB_SYNC(db, 0) < 0) 329 msg_fatal("%s: flush dictionary: %m", dict_db->dict.name); 330 331 /* 332 * Release the exclusive lock. 333 */ 334 if ((dict->flags & DICT_FLAG_LOCK) 335 && myflock(dict->lock_fd, INTERNAL_LOCK, MYFLOCK_OP_NONE) < 0) 336 msg_fatal("%s: unlock dictionary: %m", dict_db->dict.name); 337 } 338 339 /* delete one entry from the dictionary */ 340 341 static int dict_db_delete(DICT *dict, const char *name) 342 { 343 DICT_DB *dict_db = (DICT_DB *) dict; 344 DB *db = dict_db->db; 345 DBT db_key; 346 int status = 1; 347 int flags = 0; 348 349 /* 350 * Sanity check. 351 */ 352 if ((dict->flags & (DICT_FLAG_TRY1NULL | DICT_FLAG_TRY0NULL)) == 0) 353 msg_panic("dict_db_delete: no DICT_FLAG_TRY1NULL | DICT_FLAG_TRY0NULL flag"); 354 355 /* 356 * Optionally fold the key. 357 */ 358 if (dict->flags & DICT_FLAG_FOLD_FIX) { 359 if (dict->fold_buf == 0) 360 dict->fold_buf = vstring_alloc(10); 361 vstring_strcpy(dict->fold_buf, name); 362 name = lowercase(vstring_str(dict->fold_buf)); 363 } 364 memset(&db_key, 0, sizeof(db_key)); 365 366 /* 367 * Acquire an exclusive lock. 368 */ 369 if ((dict->flags & DICT_FLAG_LOCK) 370 && myflock(dict->lock_fd, INTERNAL_LOCK, MYFLOCK_OP_EXCLUSIVE) < 0) 371 msg_fatal("%s: lock dictionary: %m", dict_db->dict.name); 372 373 /* 374 * See if this DB file was written with one null byte appended to key and 375 * value. 376 */ 377 if (dict->flags & DICT_FLAG_TRY1NULL) { 378 db_key.data = (void *) name; 379 db_key.size = strlen(name) + 1; 380 if ((status = DICT_DB_DEL(db, &db_key, flags)) < 0) 381 msg_fatal("error deleting from %s: %m", dict_db->dict.name); 382 if (status == 0) 383 dict->flags &= ~DICT_FLAG_TRY0NULL; 384 } 385 386 /* 387 * See if this DB file was written with no null byte appended to key and 388 * value. 389 */ 390 if (status > 0 && (dict->flags & DICT_FLAG_TRY0NULL)) { 391 db_key.data = (void *) name; 392 db_key.size = strlen(name); 393 if ((status = DICT_DB_DEL(db, &db_key, flags)) < 0) 394 msg_fatal("error deleting from %s: %m", dict_db->dict.name); 395 if (status == 0) 396 dict->flags &= ~DICT_FLAG_TRY1NULL; 397 } 398 if (dict->flags & DICT_FLAG_SYNC_UPDATE) 399 if (DICT_DB_SYNC(db, 0) < 0) 400 msg_fatal("%s: flush dictionary: %m", dict_db->dict.name); 401 402 /* 403 * Release the exclusive lock. 404 */ 405 if ((dict->flags & DICT_FLAG_LOCK) 406 && myflock(dict->lock_fd, INTERNAL_LOCK, MYFLOCK_OP_NONE) < 0) 407 msg_fatal("%s: unlock dictionary: %m", dict_db->dict.name); 408 409 return status; 410 } 411 412 /* dict_db_sequence - traverse the dictionary */ 413 414 static int dict_db_sequence(DICT *dict, int function, 415 const char **key, const char **value) 416 { 417 const char *myname = "dict_db_sequence"; 418 DICT_DB *dict_db = (DICT_DB *) dict; 419 DB *db = dict_db->db; 420 DBT db_key; 421 DBT db_value; 422 int status = 0; 423 int db_function; 424 425 #if DB_VERSION_MAJOR > 1 426 427 /* 428 * Initialize. 429 */ 430 dict_errno = 0; 431 memset(&db_key, 0, sizeof(db_key)); 432 memset(&db_value, 0, sizeof(db_value)); 433 434 /* 435 * Determine the function. 436 */ 437 switch (function) { 438 case DICT_SEQ_FUN_FIRST: 439 if (dict_db->cursor == 0) 440 DICT_DB_CURSOR(db, &(dict_db->cursor)); 441 db_function = DB_FIRST; 442 break; 443 case DICT_SEQ_FUN_NEXT: 444 if (dict_db->cursor == 0) 445 msg_panic("%s: no cursor", myname); 446 db_function = DB_NEXT; 447 break; 448 default: 449 msg_panic("%s: invalid function %d", myname, function); 450 } 451 452 /* 453 * Acquire a shared lock. 454 */ 455 if ((dict->flags & DICT_FLAG_LOCK) 456 && myflock(dict->lock_fd, INTERNAL_LOCK, MYFLOCK_OP_SHARED) < 0) 457 msg_fatal("%s: lock dictionary: %m", dict_db->dict.name); 458 459 /* 460 * Database lookup. 461 */ 462 status = 463 dict_db->cursor->c_get(dict_db->cursor, &db_key, &db_value, db_function); 464 if (status != 0 && status != DB_NOTFOUND) 465 msg_fatal("error [%d] seeking %s: %m", status, dict_db->dict.name); 466 467 /* 468 * Release the shared lock. 469 */ 470 if ((dict->flags & DICT_FLAG_LOCK) 471 && myflock(dict->lock_fd, INTERNAL_LOCK, MYFLOCK_OP_NONE) < 0) 472 msg_fatal("%s: unlock dictionary: %m", dict_db->dict.name); 473 474 if (status == 0) { 475 476 /* 477 * Copy the result so it is guaranteed null terminated. 478 */ 479 *key = SCOPY(dict_db->key_buf, db_key.data, db_key.size); 480 *value = SCOPY(dict_db->val_buf, db_value.data, db_value.size); 481 } 482 return (status); 483 #else 484 485 /* 486 * determine the function 487 */ 488 switch (function) { 489 case DICT_SEQ_FUN_FIRST: 490 db_function = R_FIRST; 491 break; 492 case DICT_SEQ_FUN_NEXT: 493 db_function = R_NEXT; 494 break; 495 default: 496 msg_panic("%s: invalid function %d", myname, function); 497 } 498 499 /* 500 * Acquire a shared lock. 501 */ 502 if ((dict->flags & DICT_FLAG_LOCK) 503 && myflock(dict->lock_fd, INTERNAL_LOCK, MYFLOCK_OP_SHARED) < 0) 504 msg_fatal("%s: lock dictionary: %m", dict_db->dict.name); 505 506 if ((status = db->seq(db, &db_key, &db_value, db_function)) < 0) 507 msg_fatal("error seeking %s: %m", dict_db->dict.name); 508 509 /* 510 * Release the shared lock. 511 */ 512 if ((dict->flags & DICT_FLAG_LOCK) 513 && myflock(dict->lock_fd, INTERNAL_LOCK, MYFLOCK_OP_NONE) < 0) 514 msg_fatal("%s: unlock dictionary: %m", dict_db->dict.name); 515 516 if (status == 0) { 517 518 /* 519 * Copy the result so that it is guaranteed null terminated. 520 */ 521 *key = SCOPY(dict_db->key_buf, db_key.data, db_key.size); 522 *value = SCOPY(dict_db->val_buf, db_value.data, db_value.size); 523 } 524 return status; 525 #endif 526 } 527 528 /* dict_db_close - close data base */ 529 530 static void dict_db_close(DICT *dict) 531 { 532 DICT_DB *dict_db = (DICT_DB *) dict; 533 534 #if DB_VERSION_MAJOR > 1 535 if (dict_db->cursor) 536 dict_db->cursor->c_close(dict_db->cursor); 537 #endif 538 if (DICT_DB_SYNC(dict_db->db, 0) < 0) 539 msg_fatal("flush database %s: %m", dict_db->dict.name); 540 if (DICT_DB_CLOSE(dict_db->db) < 0) 541 msg_fatal("close database %s: %m", dict_db->dict.name); 542 if (dict_db->key_buf) 543 vstring_free(dict_db->key_buf); 544 if (dict_db->val_buf) 545 vstring_free(dict_db->val_buf); 546 if (dict->fold_buf) 547 vstring_free(dict->fold_buf); 548 dict_free(dict); 549 } 550 551 /* dict_db_open - open data base */ 552 553 static DICT *dict_db_open(const char *class, const char *path, int open_flags, 554 int type, void *tweak, int dict_flags) 555 { 556 DICT_DB *dict_db; 557 struct stat st; 558 DB *db; 559 char *db_path; 560 int lock_fd = -1; 561 int dbfd; 562 563 #if DB_VERSION_MAJOR > 1 564 int db_flags; 565 566 #endif 567 568 /* 569 * Mismatches between #include file and library are a common cause for 570 * trouble. 571 */ 572 #if DB_VERSION_MAJOR > 1 573 int major_version; 574 int minor_version; 575 int patch_version; 576 577 (void) db_version(&major_version, &minor_version, &patch_version); 578 if (major_version != DB_VERSION_MAJOR || minor_version != DB_VERSION_MINOR) 579 msg_fatal("incorrect version of Berkeley DB: " 580 "compiled against %d.%d.%d, run-time linked against %d.%d.%d", 581 DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH, 582 major_version, minor_version, patch_version); 583 if (msg_verbose) { 584 msg_info("Compiled against Berkeley DB: %d.%d.%d\n", 585 DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH); 586 msg_info("Run-time linked against Berkeley DB: %d.%d.%d\n", 587 major_version, minor_version, patch_version); 588 } 589 #else 590 if (msg_verbose) 591 msg_info("Compiled against Berkeley DB version 1"); 592 #endif 593 594 db_path = concatenate(path, ".db", (char *) 0); 595 596 /* 597 * Note: DICT_FLAG_LOCK is used only by programs that do fine-grained (in 598 * the time domain) locking while accessing individual database records. 599 * 600 * Programs such as postmap/postalias use their own large-grained (in the 601 * time domain) locks while rewriting the entire file. 602 * 603 * XXX DB version 4.1 will not open a zero-length file. This means we must 604 * open an existing file without O_CREAT|O_TRUNC, and that we must let 605 * db_open() create a non-existent file for us. 606 */ 607 #define LOCK_OPEN_FLAGS(f) ((f) & ~(O_CREAT|O_TRUNC)) 608 609 if (dict_flags & DICT_FLAG_LOCK) { 610 if ((lock_fd = open(db_path, LOCK_OPEN_FLAGS(open_flags), 0644)) < 0) { 611 if (errno != ENOENT) 612 msg_fatal("open database %s: %m", db_path); 613 } else { 614 if (myflock(lock_fd, INTERNAL_LOCK, MYFLOCK_OP_SHARED) < 0) 615 msg_fatal("shared-lock database %s for open: %m", db_path); 616 } 617 } 618 619 /* 620 * Use the DB 1.x programming interface. This is the default interface 621 * with 4.4BSD systems. It is also available via the db_185 compatibility 622 * interface, but that interface does not have the undocumented feature 623 * that we need to make file locking safe with POSIX fcntl() locking. 624 */ 625 #if DB_VERSION_MAJOR < 2 626 if ((db = dbopen(db_path, open_flags, 0644, type, tweak)) == 0) 627 msg_fatal("open database %s: %m", db_path); 628 dbfd = db->fd(db); 629 #endif 630 631 /* 632 * Use the DB 2.x programming interface. Jump a couple extra hoops. 633 */ 634 #if DB_VERSION_MAJOR == 2 635 db_flags = DB_FCNTL_LOCKING; 636 if (open_flags == O_RDONLY) 637 db_flags |= DB_RDONLY; 638 if (open_flags & O_CREAT) 639 db_flags |= DB_CREATE; 640 if (open_flags & O_TRUNC) 641 db_flags |= DB_TRUNCATE; 642 if ((errno = db_open(db_path, type, db_flags, 0644, 0, tweak, &db)) != 0) 643 msg_fatal("open database %s: %m", db_path); 644 if (db == 0) 645 msg_panic("db_open null result"); 646 if ((errno = db->fd(db, &dbfd)) != 0) 647 msg_fatal("get database file descriptor: %m"); 648 #endif 649 650 /* 651 * Use the DB 3.x programming interface. Jump even more hoops. 652 */ 653 #if DB_VERSION_MAJOR > 2 654 db_flags = DB_FCNTL_LOCKING; 655 if (open_flags == O_RDONLY) 656 db_flags |= DB_RDONLY; 657 if (open_flags & O_CREAT) 658 db_flags |= DB_CREATE; 659 if (open_flags & O_TRUNC) 660 db_flags |= DB_TRUNCATE; 661 if ((errno = db_create(&db, 0, 0)) != 0) 662 msg_fatal("create DB database: %m"); 663 if (db == 0) 664 msg_panic("db_create null result"); 665 if ((errno = db->set_cachesize(db, 0, dict_db_cache_size, 0)) != 0) 666 msg_fatal("set DB cache size %d: %m", dict_db_cache_size); 667 if (type == DB_HASH && db->set_h_nelem(db, DICT_DB_NELM) != 0) 668 msg_fatal("set DB hash element count %d: %m", DICT_DB_NELM); 669 #if (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR > 0) 670 if ((errno = db->open(db, 0, db_path, 0, type, db_flags, 0644)) != 0) 671 msg_fatal("open database %s: %m", db_path); 672 #elif (DB_VERSION_MAJOR == 3 || DB_VERSION_MAJOR == 4) 673 if ((errno = db->open(db, db_path, 0, type, db_flags, 0644)) != 0) 674 msg_fatal("open database %s: %m", db_path); 675 #else 676 #error "Unsupported Berkeley DB version" 677 #endif 678 if ((errno = db->fd(db, &dbfd)) != 0) 679 msg_fatal("get database file descriptor: %m"); 680 #endif 681 if ((dict_flags & DICT_FLAG_LOCK) && lock_fd >= 0) { 682 if (myflock(lock_fd, INTERNAL_LOCK, MYFLOCK_OP_NONE) < 0) 683 msg_fatal("unlock database %s for open: %m", db_path); 684 if (close(lock_fd) < 0) 685 msg_fatal("close database %s: %m", db_path); 686 } 687 dict_db = (DICT_DB *) dict_alloc(class, db_path, sizeof(*dict_db)); 688 dict_db->dict.lookup = dict_db_lookup; 689 dict_db->dict.update = dict_db_update; 690 dict_db->dict.delete = dict_db_delete; 691 dict_db->dict.sequence = dict_db_sequence; 692 dict_db->dict.close = dict_db_close; 693 dict_db->dict.lock_fd = dbfd; 694 dict_db->dict.stat_fd = dbfd; 695 if (fstat(dict_db->dict.stat_fd, &st) < 0) 696 msg_fatal("dict_db_open: fstat: %m"); 697 dict_db->dict.mtime = st.st_mtime; 698 699 /* 700 * Warn if the source file is newer than the indexed file, except when 701 * the source file changed only seconds ago. 702 */ 703 if ((dict_flags & DICT_FLAG_LOCK) != 0 704 && stat(path, &st) == 0 705 && st.st_mtime > dict_db->dict.mtime 706 && st.st_mtime < time((time_t *) 0) - 100) 707 msg_warn("database %s is older than source file %s", db_path, path); 708 709 close_on_exec(dict_db->dict.lock_fd, CLOSE_ON_EXEC); 710 close_on_exec(dict_db->dict.stat_fd, CLOSE_ON_EXEC); 711 dict_db->dict.flags = dict_flags | DICT_FLAG_FIXED; 712 if ((dict_flags & (DICT_FLAG_TRY1NULL | DICT_FLAG_TRY0NULL)) == 0) 713 dict_db->dict.flags |= (DICT_FLAG_TRY1NULL | DICT_FLAG_TRY0NULL); 714 if (dict_flags & DICT_FLAG_FOLD_FIX) 715 dict_db->dict.fold_buf = vstring_alloc(10); 716 dict_db->db = db; 717 #if DB_VERSION_MAJOR > 1 718 dict_db->cursor = 0; 719 #endif 720 dict_db->key_buf = 0; 721 dict_db->val_buf = 0; 722 723 myfree(db_path); 724 return (DICT_DEBUG (&dict_db->dict)); 725 } 726 727 /* dict_hash_open - create association with data base */ 728 729 DICT *dict_hash_open(const char *path, int open_flags, int dict_flags) 730 { 731 #if DB_VERSION_MAJOR < 2 732 HASHINFO tweak; 733 734 memset((char *) &tweak, 0, sizeof(tweak)); 735 tweak.nelem = DICT_DB_NELM; 736 tweak.cachesize = dict_db_cache_size; 737 #endif 738 #if DB_VERSION_MAJOR == 2 739 DB_INFO tweak; 740 741 memset((char *) &tweak, 0, sizeof(tweak)); 742 tweak.h_nelem = DICT_DB_NELM; 743 tweak.db_cachesize = dict_db_cache_size; 744 #endif 745 #if DB_VERSION_MAJOR > 2 746 void *tweak; 747 748 tweak = 0; 749 #endif 750 return (dict_db_open(DICT_TYPE_HASH, path, open_flags, DB_HASH, 751 (void *) &tweak, dict_flags)); 752 } 753 754 /* dict_btree_open - create association with data base */ 755 756 DICT *dict_btree_open(const char *path, int open_flags, int dict_flags) 757 { 758 #if DB_VERSION_MAJOR < 2 759 BTREEINFO tweak; 760 761 memset((char *) &tweak, 0, sizeof(tweak)); 762 tweak.cachesize = dict_db_cache_size; 763 #endif 764 #if DB_VERSION_MAJOR == 2 765 DB_INFO tweak; 766 767 memset((char *) &tweak, 0, sizeof(tweak)); 768 tweak.db_cachesize = dict_db_cache_size; 769 #endif 770 #if DB_VERSION_MAJOR > 2 771 void *tweak; 772 773 tweak = 0; 774 #endif 775 776 return (dict_db_open(DICT_TYPE_BTREE, path, open_flags, DB_BTREE, 777 (void *) &tweak, dict_flags)); 778 } 779 780 #endif 781