src/src/exim_dbutil.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2023 */
   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-or-later */
   9
  10
  11 /* This single source file is used to compile three utility programs for
  12 maintaining Exim hints databases.
  13
  14   exim_dumpdb     dumps out the contents
  15   exim_fixdb      patches the database (really for Exim maintenance/testing)
  16   exim_tidydb     removed obsolete data
  17
  18 In all cases, the first argument is the name of the spool directory. The second
  19 argument is the name of the database file. The available names are:
  20
  21   callout:      callout verification cache
  22   misc:         miscellaneous hints data
  23   ratelimit:    record for ACL "ratelimit" condition
  24   retry:        etry delivery information
  25   seen:         imestamp records for ACL "seen" condition
  26   tls:          TLS session resumption cache
  27   wait-<t>:     message waiting information; <t> is a transport name
  28
  29 There are a number of common subroutines, followed by three main programs,
  30 whose inclusion is controlled by -D on the compilation command. */
  31
  32
  33 #include "exim.h"
  34
  35
  36 /* Identifiers for the different database types. */
  37
  38 #define type_retry     1
  39 #define type_wait      2
  40 #define type_misc      3
  41 #define type_callout   4
  42 #define type_ratelimit 5
  43 #define type_tls       6
  44 #define type_seen      7
  45
  46
  47 /* This is used by our cut-down dbfn_open(). */
  48
  49 uschar *spool_directory;
  50
  51 BOOL keyonly = FALSE;
  52 BOOL utc = FALSE;
  53
  54
  55 /******************************************************************************/
  56       /* dummies needed by Solaris build */
  57 void
  58 millisleep(int msec)
  59 {}
  60 uschar *
  61 readconf_printtime(int t)
  62 { return NULL; }
  63 gstring *
  64 string_catn(gstring * g, const uschar * s, int count)
  65 { return NULL; }
  66 gstring *
  67 string_vformat_trc(gstring * g, const uschar * func, unsigned line,
  68   unsigned size_limit, unsigned flags, const char *format, va_list ap)
  69 { return NULL; }
  70 uschar *
  71 string_sprintf_trc(const char * fmt, const uschar * func, unsigned line, ...)
  72 { return NULL; }
  73 BOOL
  74 string_format_trc(uschar * buf, int len, const uschar * func, unsigned line,
  75   const char * fmt, ...)
  76 { return FALSE; }
  77
  78 struct global_flags     f;
  79 unsigned int            log_selector[1];
  80 uschar *                queue_name;
  81 BOOL                    split_spool_directory;
  82
  83
  84 /* These introduced by the taintwarn handling */
  85 #ifdef ALLOW_INSECURE_TAINTED_DATA
  86 BOOL    allow_insecure_tainted_data;
  87 #endif
  88
  89 /******************************************************************************/
  90
  91
  92 /*************************************************
  93 *              SIGALRM handler                   *
  94 *************************************************/
  95
  96 SIGNAL_BOOL sigalrm_seen;
  97
  98 void
  99 sigalrm_handler(int sig)
 100 {
 101 sigalrm_seen = 1;
 102 }
 103
 104
 105
 106 /*************************************************
 107 *        Output usage message and exit           *
 108 *************************************************/
 109
 110 static void
 111 usage(uschar *name, uschar *options)
 112 {
 113 printf("Usage: exim_%s%s  <spool-directory> <database-name>\n", name, options);
 114 printf("  <database-name> = retry | misc | wait-<transport-name> | callout | ratelimit | tls | seen\n");
 115 exit(EXIT_FAILURE);
 116 }
 117
 118
 119
 120 /*************************************************
 121 *           Sort out the command arguments       *
 122 *************************************************/
 123
 124 /* This function checks that there are exactly 2 arguments, and checks the
 125 second of them to be sure it is a known database name. */
 126
 127 static int
 128 check_args(int argc, uschar **argv, uschar *name, uschar *options)
 129 {
 130 uschar * aname = argv[optind + 1];
 131 if (argc - optind == 2)
 132   {
 133   if (Ustrcmp(aname, "retry") == 0)     return type_retry;
 134   if (Ustrcmp(aname, "misc") == 0)      return type_misc;
 135   if (Ustrncmp(aname, "wait-", 5) == 0) return type_wait;
 136   if (Ustrcmp(aname, "callout") == 0)   return type_callout;
 137   if (Ustrcmp(aname, "ratelimit") == 0) return type_ratelimit;
 138   if (Ustrcmp(aname, "tls") == 0)       return type_tls;
 139   if (Ustrcmp(aname, "seen") == 0)      return type_seen;
 140   }
 141 usage(name, options);
 142 return -1;              /* Never obeyed */
 143 }
 144
 145
 146 FUNC_MAYBE_UNUSED
 147 static void
 148 options(int argc, uschar * argv[], uschar * name, const uschar * opts)
 149 {
 150 int opt;
 151
 152 opterr = 0;
 153 while ((opt = getopt(argc, (char * const *)argv, CCS opts)) != -1)
 154   switch (opt)
 155   {
 156   case 'k':     keyonly = TRUE; break;
 157   case 'z':     utc = TRUE; break;
 158   default:      usage(name, US" [-z] [-k]");
 159   }
 160 }
 161
 162
 163
 164
 165 /*************************************************
 166 *         Handle attempts to write the log       *
 167 *************************************************/
 168
 169 /* The message gets written to stderr when log_write() is called from a
 170 utility. The message always gets '\n' added on the end of it. These calls come
 171 from modules such as store.c when things go drastically wrong (e.g. malloc()
 172 failing). In normal use they won't get obeyed.
 173
 174 Arguments:
 175   selector  not relevant when running a utility
 176   flags     not relevant when running a utility
 177   format    a printf() format
 178   ...       arguments for format
 179
 180 Returns:    nothing
 181 */
 182
 183 void
 184 log_write(unsigned int selector, int flags, const char *format, ...)
 185 {
 186 va_list ap;
 187 va_start(ap, format);
 188 vfprintf(stderr, format, ap);
 189 fprintf(stderr, "\n");
 190 va_end(ap);
 191 }
 192
 193
 194
 195 /*************************************************
 196 *        Format a time value for printing        *
 197 *************************************************/
 198
 199 static uschar time_buffer[sizeof("09-xxx-1999 hh:mm:ss  ")];
 200
 201 uschar *
 202 print_time(time_t t)
 203 {
 204 struct tm *tmstr = utc ? gmtime(&t) : localtime(&t);
 205 Ustrftime(time_buffer, sizeof(time_buffer), "%d-%b-%Y %H:%M:%S", tmstr);
 206 return time_buffer;
 207 }
 208
 209
 210
 211 /*************************************************
 212 *        Format a cache value for printing       *
 213 *************************************************/
 214
 215 uschar *
 216 print_cache(int value)
 217 {
 218 return value == ccache_accept ? US"accept" :
 219        value == ccache_reject ? US"reject" :
 220        US"unknown";
 221 }
 222
 223
 224 #ifdef EXIM_FIXDB
 225 /*************************************************
 226 *                Read time value                 *
 227 *************************************************/
 228
 229 static time_t
 230 read_time(uschar *s)
 231 {
 232 int field = 0;
 233 int value;
 234 time_t now = time(NULL);
 235 struct tm *tm = localtime(&now);
 236
 237 tm->tm_sec = 0;
 238 tm->tm_isdst = -1;
 239
 240 for (uschar * t = s + Ustrlen(s) - 1; t >= s; t--)
 241   {
 242   if (*t == ':') continue;
 243   if (!isdigit((uschar)*t)) return -1;
 244
 245   value = *t - '0';
 246   if (--t >= s)
 247     {
 248     if (!isdigit((uschar)*t)) return -1;
 249     value = value + (*t - '0')*10;
 250     }
 251
 252   switch (field++)
 253     {
 254     case 0: tm->tm_min = value; break;
 255     case 1: tm->tm_hour = value; break;
 256     case 2: tm->tm_mday = value; break;
 257     case 3: tm->tm_mon = value - 1; break;
 258     case 4: tm->tm_year = (value < 90)? value + 100 : value; break;
 259     default: return -1;
 260     }
 261   }
 262
 263 return mktime(tm);
 264 }
 265 #endif  /* EXIM_FIXDB */
 266
 267
 268
 269 /*************************************************
 270 *       Open and lock a database file            *
 271 *************************************************/
 272
 273 /* This is a cut-down version from the function in dbfn.h that Exim itself
 274 uses. We assume the database exists, and therefore give up if we cannot open
 275 the lock file.
 276
 277 Arguments:
 278   name     The single-component name of one of Exim's database files.
 279   flags    O_RDONLY or O_RDWR
 280   dbblock  Points to an open_db block to be filled in.
 281   lof      Unused.
 282   panic    Unused
 283
 284 Returns:   NULL if the open failed, or the locking failed.
 285            On success, dbblock is returned. This contains the dbm pointer and
 286            the fd of the locked lock file.
 287 */
 288
 289 open_db *
 290 dbfn_open(uschar *name, int flags, open_db *dbblock, BOOL lof, BOOL panic)
 291 {
 292 int rc;
 293 struct flock lock_data;
 294 BOOL read_only = flags == O_RDONLY;
 295 uschar * dirname, * filename;
 296
 297 /* The first thing to do is to open a separate file on which to lock. This
 298 ensures that Exim has exclusive use of the database before it even tries to
 299 open it. If there is a database, there should be a lock file in existence. */
 300
 301 #ifdef COMPILE_UTILITY
 302 if (  asprintf(CSS &dirname, "%s/db", spool_directory) < 0
 303    || asprintf(CSS &filename, "%s/%s.lockfile", dirname, name) < 0)
 304   return NULL;
 305 #else
 306 dirname = string_sprintf("%s/db", spool_directory);
 307 filename = string_sprintf("%s/%s.lockfile", dirname, name);
 308 #endif
 309
 310 dbblock->lockfd = Uopen(filename, flags, 0);
 311 if (dbblock->lockfd < 0)
 312   {
 313   printf("** Failed to open database lock file %s: %s\n", filename,
 314     strerror(errno));
 315   return NULL;
 316   }
 317
 318 /* Now we must get a lock on the opened lock file; do this with a blocking
 319 lock that times out. */
 320
 321 lock_data.l_type = read_only ? F_RDLCK : F_WRLCK;
 322 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
 323
 324 sigalrm_seen = FALSE;
 325 os_non_restarting_signal(SIGALRM, sigalrm_handler);
 326 ALARM(EXIMDB_LOCK_TIMEOUT);
 327 rc = fcntl(dbblock->lockfd, F_SETLKW, &lock_data);
 328 ALARM_CLR(0);
 329
 330 if (sigalrm_seen) errno = ETIMEDOUT;
 331 if (rc < 0)
 332   {
 333   printf("** Failed to get %s lock for %s: %s",
 334     flags & O_WRONLY ? "write" : "read",
 335     filename,
 336     errno == ETIMEDOUT ? "timed out" : strerror(errno));
 337   (void)close(dbblock->lockfd);
 338   return NULL;
 339   }
 340
 341 /* At this point we have an opened and locked separate lock file, that is,
 342 exclusive access to the database, so we can go ahead and open it. */
 343
 344 #ifdef COMPILE_UTILITY
 345 if (asprintf(CSS &filename, "%s/%s", dirname, name) < 0) return NULL;
 346 #else
 347 filename = string_sprintf("%s/%s", dirname, name);
 348 #endif
 349 dbblock->dbptr = exim_dbopen(filename, dirname, flags, 0);
 350
 351 if (!dbblock->dbptr)
 352   {
 353   printf("** Failed to open DBM file %s for %s:\n   %s%s\n", filename,
 354     read_only? "reading" : "writing", strerror(errno),
 355     #ifdef USE_DB
 356     " (or Berkeley DB error while opening)"
 357     #else
 358     ""
 359     #endif
 360     );
 361   (void)close(dbblock->lockfd);
 362   return NULL;
 363   }
 364
 365 return dbblock;
 366 }
 367
 368
 369
 370
 371 /*************************************************
 372 *         Unlock and close a database file       *
 373 *************************************************/
 374
 375 /* Closing a file automatically unlocks it, so after closing the database, just
 376 close the lock file.
 377
 378 Argument: a pointer to an open database block
 379 Returns:  nothing
 380 */
 381
 382 void
 383 dbfn_close(open_db *dbblock)
 384 {
 385 exim_dbclose(dbblock->dbptr);
 386 (void)close(dbblock->lockfd);
 387 }
 388
 389
 390
 391
 392 /*************************************************
 393 *             Read from database file            *
 394 *************************************************/
 395
 396 /* Passing back the pointer unchanged is useless, because there is no guarantee
 397 of alignment. Since all the records used by Exim need to be properly aligned to
 398 pick out the timestamps, etc., do the copying centrally here.
 399
 400 Arguments:
 401   dbblock   a pointer to an open database block
 402   key       the key of the record to be read
 403   length    where to put the length (or NULL if length not wanted). Includes overhead.
 404
 405 Returns: a pointer to the retrieved record, or
 406          NULL if the record is not found
 407 */
 408
 409 void *
 410 dbfn_read_with_length(open_db * dbblock, const uschar * key, int * length)
 411 {
 412 void * yield;
 413 EXIM_DATUM key_datum, result_datum;
 414 int klen = Ustrlen(key) + 1;
 415 uschar * key_copy = store_get(klen, key);
 416 unsigned dlen;
 417
 418 memcpy(key_copy, key, klen);
 419
 420 exim_datum_init(&key_datum);         /* Some DBM libraries require the datum */
 421 exim_datum_init(&result_datum);      /* to be cleared before use. */
 422 exim_datum_data_set(&key_datum, key_copy);
 423 exim_datum_size_set(&key_datum, klen);
 424
 425 if (!exim_dbget(dbblock->dbptr, &key_datum, &result_datum)) return NULL;
 426
 427 /* Assume for now that anything stored could have been tainted. Properly
 428 we should store the taint status along with the data. */
 429
 430 dlen = exim_datum_size_get(&result_datum);
 431 yield = store_get(dlen, GET_TAINTED);
 432 memcpy(yield, exim_datum_data_get(&result_datum), dlen);
 433 if (length) *length = dlen;
 434
 435 exim_datum_free(&result_datum);    /* Some DBM libs require freeing */
 436 return yield;
 437 }
 438
 439
 440
 441 #if defined(EXIM_TIDYDB) || defined(EXIM_FIXDB)
 442
 443 /*************************************************
 444 *             Write to database file             *
 445 *************************************************/
 446
 447 /*
 448 Arguments:
 449   dbblock   a pointer to an open database block
 450   key       the key of the record to be written
 451   ptr       a pointer to the record to be written
 452   length    the length of the record to be written
 453
 454 Returns:    the yield of the underlying dbm or db "write" function. If this
 455             is dbm, the value is zero for OK.
 456 */
 457
 458 int
 459 dbfn_write(open_db *dbblock, const uschar *key, void *ptr, int length)
 460 {
 461 EXIM_DATUM key_datum, value_datum;
 462 dbdata_generic *gptr = (dbdata_generic *)ptr;
 463 int klen = Ustrlen(key) + 1;
 464 uschar * key_copy = store_get(klen, key);
 465
 466 memcpy(key_copy, key, klen);
 467 gptr->time_stamp = time(NULL);
 468
 469 exim_datum_init(&key_datum);         /* Some DBM libraries require the datum */
 470 exim_datum_init(&value_datum);       /* to be cleared before use. */
 471 exim_datum_data_set(&key_datum, key_copy);
 472 exim_datum_size_set(&key_datum, klen);
 473 exim_datum_data_set(&value_datum, ptr);
 474 exim_datum_size_set(&value_datum, length);
 475 return exim_dbput(dbblock->dbptr, &key_datum, &value_datum);
 476 }
 477
 478
 479
 480 /*************************************************
 481 *           Delete record from database file     *
 482 *************************************************/
 483
 484 /*
 485 Arguments:
 486   dbblock    a pointer to an open database block
 487   key        the key of the record to be deleted
 488
 489 Returns: the yield of the underlying dbm or db "delete" function.
 490 */
 491
 492 int
 493 dbfn_delete(open_db *dbblock, const uschar *key)
 494 {
 495 int klen = Ustrlen(key) + 1;
 496 uschar * key_copy = store_get(klen, key);
 497 EXIM_DATUM key_datum;
 498
 499 memcpy(key_copy, key, klen);
 500 exim_datum_init(&key_datum);         /* Some DBM libraries require clearing */
 501 exim_datum_data_set(&key_datum, key_copy);
 502 exim_datum_size_set(&key_datum, klen);
 503 return exim_dbdel(dbblock->dbptr, &key_datum);
 504 }
 505
 506 #endif  /* EXIM_TIDYDB || EXIM_FIXDB */
 507
 508
 509
 510 #if defined(EXIM_DUMPDB) || defined(EXIM_TIDYDB)
 511 /*************************************************
 512 *         Scan the keys of a database file       *
 513 *************************************************/
 514
 515 /*
 516 Arguments:
 517   dbblock  a pointer to an open database block
 518   start    TRUE if starting a new scan
 519            FALSE if continuing with the current scan
 520   cursor   a pointer to a pointer to a cursor anchor, for those dbm libraries
 521            that use the notion of a cursor
 522
 523 Returns:   the next record from the file, or
 524            NULL if there are no more
 525 */
 526
 527 uschar *
 528 dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
 529 {
 530 EXIM_DATUM key_datum, value_datum;
 531 uschar *yield;
 532
 533 /* Some dbm require an initialization */
 534
 535 if (start) *cursor = exim_dbcreate_cursor(dbblock->dbptr);
 536
 537 exim_datum_init(&key_datum);         /* Some DBM libraries require the datum */
 538 exim_datum_init(&value_datum);       /* to be cleared before use. */
 539
 540 yield = exim_dbscan(dbblock->dbptr, &key_datum, &value_datum, start, *cursor)
 541   ? US exim_datum_data_get(&key_datum) : NULL;
 542
 543 /* Some dbm require a termination */
 544
 545 if (!yield) exim_dbdelete_cursor(*cursor);
 546 return yield;
 547 }
 548 #endif  /* EXIM_DUMPDB || EXIM_TIDYDB */
 549
 550
 551
 552 #ifdef EXIM_DUMPDB
 553 /*************************************************
 554 *           The exim_dumpdb main program         *
 555 *************************************************/
 556
 557 int
 558 main(int argc, char **cargv)
 559 {
 560 int dbdata_type = 0;
 561 int yield = 0;
 562 open_db dbblock;
 563 open_db *dbm;
 564 EXIM_CURSOR *cursor;
 565 uschar **argv = USS cargv;
 566 uschar keybuffer[1024];
 567
 568 store_init();
 569 options(argc, argv, US"dumpdb", US"kz");
 570
 571 /* Check the arguments, and open the database */
 572
 573 dbdata_type = check_args(argc, argv, US"dumpdb", US" [-z] [-k]");
 574 argc -= optind; argv += optind;
 575 spool_directory = argv[0];
 576
 577 if (!(dbm = dbfn_open(argv[1], O_RDONLY, &dbblock, FALSE, TRUE)))
 578   exit(1);
 579
 580 /* Scan the file, formatting the information for each entry. Note
 581 that data is returned in a malloc'ed block, in order that it be
 582 correctly aligned. */
 583
 584 for (uschar * key = dbfn_scan(dbm, TRUE, &cursor);
 585      key;
 586      key = dbfn_scan(dbm, FALSE, &cursor))
 587   {
 588   dbdata_retry *retry;
 589   dbdata_wait *wait;
 590   dbdata_callout_cache *callout;
 591   dbdata_ratelimit *ratelimit;
 592   dbdata_ratelimit_unique *rate_unique;
 593   dbdata_tls_session *session;
 594   dbdata_seen *seen;
 595   int count_bad = 0;
 596   int length;
 597   uschar *t;
 598   uschar name[MESSAGE_ID_LENGTH + 1];
 599   void *value;
 600   rmark reset_point = store_mark();
 601
 602   /* Keep a copy of the key separate, as in some DBM's the pointer is into data
 603   which might change. */
 604
 605   if (Ustrlen(key) > sizeof(keybuffer) - 1)
 606     {
 607     printf("**** Overlong key encountered: %s\n", key);
 608     return 1;
 609     }
 610   Ustrcpy(keybuffer, key);
 611
 612   if (keyonly)
 613     printf("  %s\n", keybuffer);
 614   else if (!(value = dbfn_read_with_length(dbm, keybuffer, &length)))
 615     fprintf(stderr, "**** Entry \"%s\" was in the key scan, but the record "
 616                     "was not found in the file - something is wrong!\n",
 617       CS keybuffer);
 618   else
 619     /* Note: don't use print_time more than once in one statement, since
 620     it uses a single buffer. */
 621
 622     switch(dbdata_type)
 623       {
 624       case type_retry:
 625         retry = (dbdata_retry *)value;
 626         printf("  %s %d %d %s\n%s  ", keybuffer, retry->basic_errno,
 627           retry->more_errno, retry->text,
 628           print_time(retry->first_failed));
 629         printf("%s  ", print_time(retry->last_try));
 630         printf("%s %s\n", print_time(retry->next_try),
 631           (retry->expired)? "*" : "");
 632         break;
 633
 634       case type_wait:
 635         wait = (dbdata_wait *)value;
 636         printf("%s ", keybuffer);
 637         t = wait->text;
 638         name[MESSAGE_ID_LENGTH] = 0;
 639
 640     /* Leave corrupt records alone */
 641         if (wait->count > WAIT_NAME_MAX)
 642           {
 643           fprintf(stderr,
 644             "**** Data for %s corrupted\n  count=%d=0x%x max=%d\n",
 645             CS keybuffer, wait->count, wait->count, WAIT_NAME_MAX);
 646           wait->count = WAIT_NAME_MAX;
 647           yield = count_bad = 1;
 648           }
 649         for (int i = 1; i <= wait->count; i++)
 650           {
 651           Ustrncpy(name, t, MESSAGE_ID_LENGTH);
 652           if (count_bad && name[0] == 0) break;
 653           if (Ustrlen(name) != MESSAGE_ID_LENGTH ||
 654               Ustrspn(name, "0123456789"
 655                             "abcdefghijklmnopqrstuvwxyz"
 656                             "ABCDEFGHIJKLMNOPQRSTUVWXYZ-") != MESSAGE_ID_LENGTH)
 657             {
 658             fprintf(stderr,
 659               "**** Data for %s corrupted: bad character in message id\n",
 660               CS keybuffer);
 661             for (int j = 0; j < MESSAGE_ID_LENGTH; j++)
 662               fprintf(stderr, "%02x ", name[j]);
 663             fprintf(stderr, "\n");
 664             yield = 1;
 665             break;
 666             }
 667           printf("%s ", name);
 668           t += MESSAGE_ID_LENGTH;
 669           }
 670         printf("\n");
 671         break;
 672
 673       case type_misc:
 674         printf("%s %s\n", print_time(((dbdata_generic *)value)->time_stamp),
 675           keybuffer);
 676         break;
 677
 678       case type_callout:
 679         callout = (dbdata_callout_cache *)value;
 680
 681         /* New-style address record */
 682
 683         if (length == sizeof(dbdata_callout_cache_address))
 684           {
 685           printf("%s %s callout=%s\n",
 686             print_time(((dbdata_generic *)value)->time_stamp),
 687             keybuffer,
 688             print_cache(callout->result));
 689           }
 690
 691         /* New-style domain record */
 692
 693         else if (length == sizeof(dbdata_callout_cache))
 694           {
 695           printf("%s %s callout=%s postmaster=%s",
 696             print_time(((dbdata_generic *)value)->time_stamp),
 697             keybuffer,
 698             print_cache(callout->result),
 699             print_cache(callout->postmaster_result));
 700           if (callout->postmaster_result != ccache_unknown)
 701             printf(" (%s)", print_time(callout->postmaster_stamp));
 702           printf(" random=%s", print_cache(callout->random_result));
 703           if (callout->random_result != ccache_unknown)
 704             printf(" (%s)", print_time(callout->random_stamp));
 705           printf("\n");
 706           }
 707
 708         break;
 709
 710       case type_ratelimit:
 711         if (Ustrstr(key, "/unique/") != NULL && length >= sizeof(*rate_unique))
 712           {
 713           ratelimit = (dbdata_ratelimit *)value;
 714           rate_unique = (dbdata_ratelimit_unique *)value;
 715           printf("%s.%06d rate: %10.3f epoch: %s size: %u key: %s\n",
 716             print_time(ratelimit->time_stamp),
 717             ratelimit->time_usec, ratelimit->rate,
 718             print_time(rate_unique->bloom_epoch), rate_unique->bloom_size,
 719             keybuffer);
 720           }
 721         else
 722           {
 723           ratelimit = (dbdata_ratelimit *)value;
 724           printf("%s.%06d rate: %10.3f key: %s\n",
 725             print_time(ratelimit->time_stamp),
 726             ratelimit->time_usec, ratelimit->rate,
 727             keybuffer);
 728           }
 729         break;
 730
 731       case type_tls:
 732         session = (dbdata_tls_session *)value;
 733         printf("  %s %.*s\n", keybuffer, length, session->session);
 734         break;
 735
 736       case type_seen:
 737         seen = (dbdata_seen *)value;
 738         printf("%s\t%s\n", keybuffer, print_time(seen->time_stamp));
 739         break;
 740       }
 741   store_reset(reset_point);
 742   }
 743
 744 dbfn_close(dbm);
 745 return yield;
 746 }
 747
 748 #endif  /* EXIM_DUMPDB */
 749
 750
 751
 752
 753 #ifdef EXIM_FIXDB
 754 /*************************************************
 755 *           The exim_fixdb main program          *
 756 *************************************************/
 757
 758 /* In order not to hold the database lock any longer than is necessary, each
 759 operation on the database uses a separate open/close call. This is expensive,
 760 but then using this utility is not expected to be very common. Its main use is
 761 to provide a way of patching up hints databases in order to run tests.
 762
 763 Syntax of commands:
 764
 765 (1) <record name>
 766     This causes the data from the given record to be displayed, or "not found"
 767     to be output. Note that in the retry database, destination names are
 768     preceded by R: or T: for router or transport retry info.
 769
 770 (2) <record name> d
 771     This causes the given record to be deleted or "not found" to be output.
 772
 773 (3) <record name> <field number> <value>
 774     This sets the given value into the given field, identified by a number
 775     which is output by the display command. Not all types of record can
 776     be changed.
 777
 778 (4) q
 779     This exits from exim_fixdb.
 780
 781 If the record name is omitted from (2) or (3), the previously used record name
 782 is re-used. */
 783
 784
 785 int
 786 main(int argc, char **cargv)
 787 {
 788 int dbdata_type;
 789 uschar **argv = USS cargv;
 790 uschar buffer[256];
 791 uschar name[256];
 792 rmark reset_point;
 793 uschar * aname;
 794
 795 store_init();
 796 options(argc, argv, US"fixdb", US"z");
 797 name[0] = 0;  /* No name set */
 798
 799 /* Sort out the database type, verify what we are working on and then process
 800 user requests */
 801
 802 dbdata_type = check_args(argc, argv, US"fixdb", US" [-z]");
 803 argc -= optind; argv += optind;
 804 spool_directory = argv[0];
 805 aname = argv[1];
 806
 807 printf("Modifying Exim hints database %s/db/%s\n", spool_directory, aname);
 808
 809 for(; (reset_point = store_mark()); store_reset(reset_point))
 810   {
 811   open_db dbblock;
 812   open_db *dbm;
 813   void *record;
 814   dbdata_retry *retry;
 815   dbdata_wait *wait;
 816   dbdata_callout_cache *callout;
 817   dbdata_ratelimit *ratelimit;
 818   dbdata_ratelimit_unique *rate_unique;
 819   dbdata_tls_session *session;
 820   int oldlength;
 821   uschar *t;
 822   uschar field[256], value[256];
 823
 824   printf("> ");
 825   if (Ufgets(buffer, 256, stdin) == NULL) break;
 826
 827   buffer[Ustrlen(buffer)-1] = 0;
 828   field[0] = value[0] = 0;
 829
 830   /* If the buffer contains just one digit, or just consists of "d", use the
 831   previous name for an update. */
 832
 833   if ((isdigit((uschar)buffer[0]) && (buffer[1] == ' ' || buffer[1] == '\0'))
 834        || Ustrcmp(buffer, "d") == 0)
 835     {
 836     if (name[0] == 0)
 837       {
 838       printf("No previous record name is set\n");
 839       continue;
 840       }
 841     (void)sscanf(CS buffer, "%s %s", field, value);
 842     }
 843   else
 844     {
 845     name[0] = 0;
 846     (void)sscanf(CS buffer, "%s %s %s", name, field, value);
 847     }
 848
 849   /* Handle an update request */
 850
 851   if (field[0] != 0)
 852     {
 853     int verify = 1;
 854
 855     if (!(dbm = dbfn_open(aname, O_RDWR, &dbblock, FALSE, TRUE)))
 856       continue;
 857
 858     if (Ustrcmp(field, "d") == 0)
 859       {
 860       if (value[0] != 0) printf("unexpected value after \"d\"\n");
 861         else printf("%s\n", (dbfn_delete(dbm, name) < 0)?
 862           "not found" : "deleted");
 863       dbfn_close(dbm);
 864       continue;
 865       }
 866
 867     else if (isdigit((uschar)field[0]))
 868       {
 869       int fieldno = Uatoi(field);
 870       if (value[0] == 0)
 871         {
 872         printf("value missing\n");
 873         dbfn_close(dbm);
 874         continue;
 875         }
 876       else
 877         {
 878         record = dbfn_read_with_length(dbm, name, &oldlength);
 879         if (record == NULL) printf("not found\n"); else
 880           {
 881           time_t tt;
 882           /*int length = 0;      Stops compiler warning */
 883
 884           switch(dbdata_type)
 885             {
 886             case type_retry:
 887               retry = (dbdata_retry *)record;
 888               /* length = sizeof(dbdata_retry) + Ustrlen(retry->text); */
 889
 890               switch(fieldno)
 891                 {
 892                 case 0: retry->basic_errno = Uatoi(value);
 893                         break;
 894                 case 1: retry->more_errno = Uatoi(value);
 895                         break;
 896                 case 2: if ((tt = read_time(value)) > 0) retry->first_failed = tt;
 897                         else printf("bad time value\n");
 898                         break;
 899                 case 3: if ((tt = read_time(value)) > 0) retry->last_try = tt;
 900                         else printf("bad time value\n");
 901                         break;
 902                 case 4: if ((tt = read_time(value)) > 0) retry->next_try = tt;
 903                         else printf("bad time value\n");
 904                         break;
 905                 case 5: if (Ustrcmp(value, "yes") == 0) retry->expired = TRUE;
 906                         else if (Ustrcmp(value, "no") == 0) retry->expired = FALSE;
 907                         else printf("\"yes\" or \"no\" expected=n");
 908                         break;
 909                 default: printf("unknown field number\n");
 910                          verify = 0;
 911                          break;
 912                 }
 913               break;
 914
 915             case type_wait:
 916               printf("Can't change contents of wait database record\n");
 917               break;
 918
 919             case type_misc:
 920               printf("Can't change contents of misc database record\n");
 921               break;
 922
 923             case type_callout:
 924               callout = (dbdata_callout_cache *)record;
 925               /* length = sizeof(dbdata_callout_cache); */
 926               switch(fieldno)
 927                 {
 928                 case 0: callout->result = Uatoi(value);
 929                         break;
 930                 case 1: callout->postmaster_result = Uatoi(value);
 931                         break;
 932                 case 2: callout->random_result = Uatoi(value);
 933                         break;
 934                 default: printf("unknown field number\n");
 935                          verify = 0;
 936                          break;
 937                 }
 938                 break;
 939
 940             case type_ratelimit:
 941               ratelimit = (dbdata_ratelimit *)record;
 942               switch(fieldno)
 943                 {
 944                 case 0: if ((tt = read_time(value)) > 0) ratelimit->time_stamp = tt;
 945                         else printf("bad time value\n");
 946                         break;
 947                 case 1: ratelimit->time_usec = Uatoi(value);
 948                         break;
 949                 case 2: ratelimit->rate = Ustrtod(value, NULL);
 950                         break;
 951                 case 3: if (Ustrstr(name, "/unique/") != NULL
 952                             && oldlength >= sizeof(dbdata_ratelimit_unique))
 953                           {
 954                           rate_unique = (dbdata_ratelimit_unique *)record;
 955                           if ((tt = read_time(value)) > 0) rate_unique->bloom_epoch = tt;
 956                             else printf("bad time value\n");
 957                           break;
 958                           }
 959                         /* else fall through */
 960                 case 4:
 961                 case 5: if (Ustrstr(name, "/unique/") != NULL
 962                             && oldlength >= sizeof(dbdata_ratelimit_unique))
 963                           {
 964                           /* see acl.c */
 965                           BOOL seen;
 966                           unsigned hash, hinc;
 967                           uschar md5sum[16];
 968                           md5 md5info;
 969                           md5_start(&md5info);
 970                           md5_end(&md5info, value, Ustrlen(value), md5sum);
 971                           hash = md5sum[0] <<  0 | md5sum[1] <<  8
 972                                | md5sum[2] << 16 | md5sum[3] << 24;
 973                           hinc = md5sum[4] <<  0 | md5sum[5] <<  8
 974                                | md5sum[6] << 16 | md5sum[7] << 24;
 975                           rate_unique = (dbdata_ratelimit_unique *)record;
 976                           seen = TRUE;
 977                           for (unsigned n = 0; n < 8; n++, hash += hinc)
 978                             {
 979                             int bit = 1 << (hash % 8);
 980                             int byte = (hash / 8) % rate_unique->bloom_size;
 981                             if ((rate_unique->bloom[byte] & bit) == 0)
 982                               {
 983                               seen = FALSE;
 984                               if (fieldno == 5) rate_unique->bloom[byte] |= bit;
 985                               }
 986                             }
 987                           printf("%s %s\n",
 988                             seen ? "seen" : fieldno == 5 ? "added" : "unseen", value);
 989                           break;
 990                           }
 991                         /* else fall through */
 992                 default: printf("unknown field number\n");
 993                          verify = 0;
 994                          break;
 995                 }
 996               break;
 997
 998             case type_tls:
 999               printf("Can't change contents of tls database record\n");
1000               break;
1001             }
1002
1003           dbfn_write(dbm, name, record, oldlength);
1004           }
1005         }
1006       }
1007
1008     else
1009       {
1010       printf("field number or d expected\n");
1011       verify = 0;
1012       }
1013
1014     dbfn_close(dbm);
1015     if (!verify) continue;
1016     }
1017
1018   /* The "name" q causes an exit */
1019
1020   else if (Ustrcmp(name, "q") == 0) return 0;
1021
1022   /* Handle a read request, or verify after an update. */
1023
1024   if (!(dbm = dbfn_open(aname, O_RDONLY, &dbblock, FALSE, TRUE)))
1025     continue;
1026
1027   if (!(record = dbfn_read_with_length(dbm, name, &oldlength)))
1028     {
1029     printf("record %s not found\n", name);
1030     name[0] = 0;
1031     }
1032   else
1033     {
1034     int count_bad = 0;
1035     printf("%s\n", CS print_time(((dbdata_generic *)record)->time_stamp));
1036     switch(dbdata_type)
1037       {
1038       case type_retry:
1039         retry = (dbdata_retry *)record;
1040         printf("0 error number: %d %s\n", retry->basic_errno, retry->text);
1041         printf("1 extra data:   %d\n", retry->more_errno);
1042         printf("2 first failed: %s\n", print_time(retry->first_failed));
1043         printf("3 last try:     %s\n", print_time(retry->last_try));
1044         printf("4 next try:     %s\n", print_time(retry->next_try));
1045         printf("5 expired:      %s\n", (retry->expired)? "yes" : "no");
1046         break;
1047
1048       case type_wait:
1049         wait = (dbdata_wait *)record;
1050         t = wait->text;
1051         printf("Sequence: %d\n", wait->sequence);
1052         if (wait->count > WAIT_NAME_MAX)
1053           {
1054           printf("**** Data corrupted: count=%d=0x%x max=%d ****\n", wait->count,
1055             wait->count, WAIT_NAME_MAX);
1056           wait->count = WAIT_NAME_MAX;
1057           count_bad = 1;
1058           }
1059         for (int i = 1; i <= wait->count; i++)
1060           {
1061           Ustrncpy(value, t, MESSAGE_ID_LENGTH);
1062           value[MESSAGE_ID_LENGTH] = 0;
1063           if (count_bad && value[0] == 0) break;
1064           if (Ustrlen(value) != MESSAGE_ID_LENGTH ||
1065               Ustrspn(value, "0123456789"
1066                             "abcdefghijklmnopqrstuvwxyz"
1067                             "ABCDEFGHIJKLMNOPQRSTUVWXYZ-") != MESSAGE_ID_LENGTH)
1068             {
1069             printf("\n**** Data corrupted: bad character in message id ****\n");
1070             for (int j = 0; j < MESSAGE_ID_LENGTH; j++)
1071               printf("%02x ", value[j]);
1072             printf("\n");
1073             break;
1074             }
1075           printf("%s ", value);
1076           t += MESSAGE_ID_LENGTH;
1077           }
1078         printf("\n");
1079         break;
1080
1081       case type_misc:
1082         break;
1083
1084       case type_callout:
1085         callout = (dbdata_callout_cache *)record;
1086         printf("0 callout:    %s (%d)\n", print_cache(callout->result),
1087             callout->result);
1088         if (oldlength > sizeof(dbdata_callout_cache_address))
1089           {
1090           printf("1 postmaster: %s (%d)\n", print_cache(callout->postmaster_result),
1091               callout->postmaster_result);
1092           printf("2 random:     %s (%d)\n", print_cache(callout->random_result),
1093               callout->random_result);
1094           }
1095         break;
1096
1097       case type_ratelimit:
1098         ratelimit = (dbdata_ratelimit *)record;
1099         printf("0 time stamp:  %s\n", print_time(ratelimit->time_stamp));
1100         printf("1 fract. time: .%06d\n", ratelimit->time_usec);
1101         printf("2 sender rate: % .3f\n", ratelimit->rate);
1102         if (Ustrstr(name, "/unique/") != NULL
1103          && oldlength >= sizeof(dbdata_ratelimit_unique))
1104          {
1105          rate_unique = (dbdata_ratelimit_unique *)record;
1106          printf("3 filter epoch: %s\n", print_time(rate_unique->bloom_epoch));
1107          printf("4 test filter membership\n");
1108          printf("5 add element to filter\n");
1109          }
1110         break;
1111
1112       case type_tls:
1113         session = (dbdata_tls_session *)value;
1114         printf("0 time stamp:  %s\n", print_time(session->time_stamp));
1115         printf("1 session: .%s\n", session->session);
1116         break;
1117       }
1118     }
1119
1120   /* The database is closed after each request */
1121
1122   dbfn_close(dbm);
1123   }
1124
1125 printf("\n");
1126 return 0;
1127 }
1128
1129 #endif  /* EXIM_FIXDB */
1130
1131
1132
1133 #ifdef EXIM_TIDYDB
1134 /*************************************************
1135 *           The exim_tidydb main program         *
1136 *************************************************/
1137
1138
1139 /* Utility program to tidy the contents of an exim database file. There is one
1140 option:
1141
1142    -t <time>  expiry time for old records - default 30 days
1143
1144 For backwards compatibility, an -f option is recognized and ignored. (It used
1145 to request a "full" tidy. This version always does the whole job.) */
1146
1147
1148 typedef struct key_item {
1149   struct key_item *next;
1150   uschar key[1];
1151 } key_item;
1152
1153
1154 int
1155 main(int argc, char **cargv)
1156 {
1157 struct stat statbuf;
1158 int maxkeep = 30 * 24 * 60 * 60;
1159 int dbdata_type, i, oldest, path_len;
1160 key_item *keychain = NULL;
1161 rmark reset_point;
1162 open_db dbblock;
1163 open_db *dbm;
1164 EXIM_CURSOR *cursor;
1165 uschar **argv = USS cargv;
1166 uschar buffer[256];
1167 uschar *key;
1168
1169 store_init();
1170
1171 /* Scan the options */
1172
1173 for (i = 1; i < argc; i++)
1174   {
1175   if (argv[i][0] != '-') break;
1176   if (Ustrcmp(argv[i], "-f") == 0) continue;
1177   if (Ustrcmp(argv[i], "-t") == 0)
1178     {
1179     uschar *s;
1180     s = argv[++i];
1181     maxkeep = 0;
1182     while (*s != 0)
1183       {
1184       int value, count;
1185       if (!isdigit(*s)) usage(US"tidydb", US" [-t <time>]");
1186       (void)sscanf(CS s, "%d%n", &value, &count);
1187       s += count;
1188       switch (*s)
1189         {
1190         case 'w': value *= 7;
1191         case 'd': value *= 24;
1192         case 'h': value *= 60;
1193         case 'm': value *= 60;
1194         case 's': s++;
1195         break;
1196         default: usage(US"tidydb", US" [-t <time>]");
1197         }
1198       maxkeep += value;
1199       }
1200     }
1201   else usage(US"tidydb", US" [-t <time>]");
1202   }
1203
1204 /* Adjust argument values and process arguments */
1205
1206 argc -= --i;
1207 argv += i;
1208
1209 dbdata_type = check_args(argc, argv, US"tidydb", US" [-t <time>]");
1210
1211 /* Compute the oldest keep time, verify what we are doing, and open the
1212 database */
1213
1214 oldest = time(NULL) - maxkeep;
1215 printf("Tidying Exim hints database %s/db/%s\n", argv[1], argv[2]);
1216
1217 spool_directory = argv[1];
1218 if (!(dbm = dbfn_open(argv[2], O_RDWR, &dbblock, FALSE, TRUE)))
1219   exit(1);
1220
1221 /* Prepare for building file names */
1222
1223 sprintf(CS buffer, "%s/input/", argv[1]);
1224 path_len = Ustrlen(buffer);
1225
1226
1227 /* It appears, by experiment, that it is a bad idea to make changes
1228 to the file while scanning it. Pity the man page doesn't warn you about that.
1229 Therefore, we scan and build a list of all the keys. Then we use that to
1230 read the records and possibly update them. */
1231
1232 for (key = dbfn_scan(dbm, TRUE, &cursor);
1233      key;
1234      key = dbfn_scan(dbm, FALSE, &cursor))
1235   {
1236   key_item * k = store_get(sizeof(key_item) + Ustrlen(key), key);
1237   k->next = keychain;
1238   keychain = k;
1239   Ustrcpy(k->key, key);
1240   }
1241
1242 /* Now scan the collected keys and operate on the records, resetting
1243 the store each time round. */
1244
1245 for (; keychain && (reset_point = store_mark()); store_reset(reset_point))
1246   {
1247   dbdata_generic *value;
1248
1249   key = keychain->key;
1250   keychain = keychain->next;
1251   value = dbfn_read_with_length(dbm, key, NULL);
1252
1253   /* A continuation record may have been deleted or renamed already, so
1254   non-existence is not serious. */
1255
1256   if (!value) continue;
1257
1258   /* Delete if too old */
1259
1260   if (value->time_stamp < oldest)
1261     {
1262     printf("deleted %s (too old)\n", key);
1263     dbfn_delete(dbm, key);
1264     continue;
1265     }
1266
1267   /* Do database-specific tidying for wait databases, and message-
1268   specific tidying for the retry database. */
1269
1270   if (dbdata_type == type_wait)
1271     {
1272     dbdata_wait *wait = (dbdata_wait *)value;
1273     BOOL update = FALSE;
1274
1275     /* Leave corrupt records alone */
1276
1277     if (wait->time_stamp > time(NULL))
1278       {
1279       printf("**** Data for '%s' corrupted\n  time in future: %s\n",
1280         key, print_time(((dbdata_generic *)value)->time_stamp));
1281       continue;
1282       }
1283     if (wait->count > WAIT_NAME_MAX)
1284       {
1285       printf("**** Data for '%s' corrupted\n  count=%d=0x%x max=%d\n",
1286         key, wait->count, wait->count, WAIT_NAME_MAX);
1287       continue;
1288       }
1289     if (wait->sequence > WAIT_CONT_MAX)
1290       {
1291       printf("**** Data for '%s' corrupted\n  sequence=%d=0x%x max=%d\n",
1292         key, wait->sequence, wait->sequence, WAIT_CONT_MAX);
1293       continue;
1294       }
1295
1296     /* Record over 1 year old; just remove it */
1297
1298     if (wait->time_stamp < time(NULL) - 365*24*60*60)
1299       {
1300       dbfn_delete(dbm, key);
1301       printf("deleted %s (too old)\n", key);
1302       continue;
1303       }
1304
1305     /* Loop for renamed continuation records. For each message id,
1306     check to see if the message exists, and if not, remove its entry
1307     from the record. Because of the possibility of split input directories,
1308     we must look in both possible places for a -D file. */
1309
1310     for (;;)
1311       {
1312       int length = wait->count * MESSAGE_ID_LENGTH;
1313
1314       for (int offset = length - MESSAGE_ID_LENGTH;
1315            offset >= 0; offset -= MESSAGE_ID_LENGTH)
1316         {
1317         Ustrncpy(buffer+path_len, wait->text + offset, MESSAGE_ID_LENGTH);
1318         sprintf(CS(buffer+path_len + MESSAGE_ID_LENGTH), "-D");
1319
1320         if (Ustat(buffer, &statbuf) != 0)
1321           {
1322           buffer[path_len] = wait->text[offset+5];
1323           buffer[path_len+1] = '/';
1324           Ustrncpy(buffer+path_len+2, wait->text + offset, MESSAGE_ID_LENGTH);
1325           sprintf(CS(buffer+path_len+2 + MESSAGE_ID_LENGTH), "-D");
1326
1327           if (Ustat(buffer, &statbuf) != 0)
1328             {
1329             int left = length - offset - MESSAGE_ID_LENGTH;
1330             if (left > 0) Ustrncpy(wait->text + offset,
1331               wait->text + offset + MESSAGE_ID_LENGTH, left);
1332             wait->count--;
1333             length -= MESSAGE_ID_LENGTH;
1334             update = TRUE;
1335             }
1336           }
1337         }
1338
1339       /* If record is empty and the main record, either delete it or rename
1340       the next continuation, repeating if that is also empty. */
1341
1342       if (wait->count == 0 && Ustrchr(key, ':') == NULL)
1343         {
1344         while (wait->count == 0 && wait->sequence > 0)
1345           {
1346           uschar newkey[256];
1347           dbdata_generic *newvalue;
1348           sprintf(CS newkey, "%s:%d", key, wait->sequence - 1);
1349           newvalue = dbfn_read_with_length(dbm, newkey, NULL);
1350           if (newvalue != NULL)
1351             {
1352             value = newvalue;
1353             wait = (dbdata_wait *)newvalue;
1354             dbfn_delete(dbm, newkey);
1355             printf("renamed %s\n", newkey);
1356             update = TRUE;
1357             }
1358           else wait->sequence--;
1359           }
1360
1361         /* If we have ended up with an empty main record, delete it
1362         and break the loop. Otherwise the new record will be scanned. */
1363
1364         if (wait->count == 0 && wait->sequence == 0)
1365           {
1366           dbfn_delete(dbm, key);
1367           printf("deleted %s (empty)\n", key);
1368           update = FALSE;
1369           break;
1370           }
1371         }
1372
1373       /* If not an empty main record, break the loop */
1374
1375       else break;
1376       }
1377
1378     /* Re-write the record if required */
1379
1380     if (update)
1381       {
1382       printf("updated %s\n", key);
1383       dbfn_write(dbm, key, wait, sizeof(dbdata_wait) +
1384         wait->count * MESSAGE_ID_LENGTH);
1385       }
1386     }
1387
1388   /* If a retry record's key ends with a message-id, check that that message
1389   still exists; if not, remove this record. */
1390
1391   else if (dbdata_type == type_retry)
1392     {
1393     uschar *id;
1394     int len = Ustrlen(key);
1395
1396     if (len < MESSAGE_ID_LENGTH + 1) continue;
1397     id = key + len - MESSAGE_ID_LENGTH - 1;
1398     if (*id++ != ':') continue;
1399
1400     for (i = 0; i < MESSAGE_ID_LENGTH; i++)
1401       if (i == 6 || i == 13)
1402         { if (id[i] != '-') break; }
1403       else
1404         { if (!isalnum(id[i])) break; }
1405     if (i < MESSAGE_ID_LENGTH) continue;
1406
1407     Ustrncpy(buffer + path_len, id, MESSAGE_ID_LENGTH);
1408     sprintf(CS(buffer + path_len + MESSAGE_ID_LENGTH), "-D");
1409
1410     if (Ustat(buffer, &statbuf) != 0)
1411       {
1412       sprintf(CS(buffer + path_len), "%c/%s-D", id[5], id);
1413       if (Ustat(buffer, &statbuf) != 0)
1414         {
1415         dbfn_delete(dbm, key);
1416         printf("deleted %s (no message)\n", key);
1417         }
1418       }
1419     }
1420   }
1421
1422 dbfn_close(dbm);
1423 printf("Tidying complete\n");
1424 return 0;
1425 }
1426
1427 #endif  /* EXIM_TIDYDB */
1428
1429 /* End of exim_dbutil.c */