src/src/exim_dbutil.c

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