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