src/src/exim_dbutil.c

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