int
main(int argc, char **cargv)
{
int dbdata_type = 0;
int yield = 0;
open_db dbblock;
open_db *dbm;
EXIM_CURSOR *cursor;
uschar **argv = USS cargv;
uschar *key;
uschar keybuffer[1024];
/* Check the arguments, and open the database */
dbdata_type = check_args(argc, argv, US"dumpdb", US"");
dbm = dbfn_open(argv[1], argv[2], O_RDONLY, &dbblock);
if (dbm == NULL) exit(1);
/* Scan the file, formatting the information for each entry. Note
that data is returned in a malloc'ed block, in order that it be
correctly aligned. */
key = dbfn_scan(dbm, TRUE, &cursor);
while (key != NULL)
{
dbdata_retry *retry;
dbdata_wait *wait;
dbdata_callout_cache *callout;
dbdata_ratelimit *ratelimit;
int count_bad = 0;
int i, length;
uschar *t;
uschar name[MESSAGE_ID_LENGTH + 1];
void *value;
/* Keep a copy of the key separate, as in some DBM's the pointer is into data
which might change. */
if (Ustrlen(key) > sizeof(keybuffer) - 1)
{
printf("**** Overlong key encountered: %s\n", key);
return 1;
}
Ustrcpy(keybuffer, key);
value = dbfn_read_with_length(dbm, keybuffer, &length);
if (value == NULL)
fprintf(stderr, "**** Entry \"%s\" was in the key scan, but the record "
"was not found in the file - something is wrong!\n",
CS keybuffer);
else
{
/* Note: don't use print_time more than once in one statement, since
it uses a single buffer. */
switch(dbdata_type)
{
case type_retry:
retry = (dbdata_retry *)value;
printf(" %s %d %d %s\n%s ", keybuffer, retry->basic_errno,
retry->more_errno, retry->text,
print_time(retry->first_failed));
printf("%s ", print_time(retry->last_try));
printf("%s %s\n", print_time(retry->next_try),
(retry->expired)? "*" : "");
break;
case type_wait:
wait = (dbdata_wait *)value;
printf("%s ", keybuffer);
t = wait->text;
name[MESSAGE_ID_LENGTH] = 0;
if (wait->count > WAIT_NAME_MAX)
{
fprintf(stderr,
"**** Data for %s corrupted\n count=%d=0x%x max=%d\n",
CS keybuffer, wait->count, wait->count, WAIT_NAME_MAX);
wait->count = WAIT_NAME_MAX;
yield = count_bad = 1;
}
for (i = 1; i <= wait->count; i++)
{
Ustrncpy(name, t, MESSAGE_ID_LENGTH);
if (count_bad && name[0] == 0) break;
if (Ustrlen(name) != MESSAGE_ID_LENGTH ||
Ustrspn(name, "0123456789"
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ-") != MESSAGE_ID_LENGTH)
{
int j;
fprintf(stderr,
"**** Data for %s corrupted: bad character in message id\n",
CS keybuffer);
for (j = 0; j < MESSAGE_ID_LENGTH; j++)
fprintf(stderr, "%02x ", name[j]);
fprintf(stderr, "\n");
yield = 1;
break;
}
printf("%s ", name);
t += MESSAGE_ID_LENGTH;
}
printf("\n");
break;
case type_misc:
printf("%s %s\n", print_time(((dbdata_generic *)value)->time_stamp),
keybuffer);
break;
case type_callout:
callout = (dbdata_callout_cache *)value;
/* New-style address record */
if (length == sizeof(dbdata_callout_cache_address))
{
printf("%s %s callout=%s\n",
print_time(((dbdata_generic *)value)->time_stamp),
keybuffer,
print_cache(callout->result));
}
/* New-style domain record */
else if (length == sizeof(dbdata_callout_cache))
{
printf("%s %s callout=%s postmaster=%s",
print_time(((dbdata_generic *)value)->time_stamp),
keybuffer,
print_cache(callout->result),
print_cache(callout->postmaster_result));
if (callout->postmaster_result != ccache_unknown)
printf(" (%s)", print_time(callout->postmaster_stamp));
printf(" random=%s", print_cache(callout->random_result));
if (callout->random_result != ccache_unknown)
printf(" (%s)", print_time(callout->random_stamp));
printf("\n");
}
/* Old-style domain record, without separate timestamps. This code can
eventually be thrown away, say in 5 years' time (it's now Feb 2003). */
else
{
printf("%s %s callout=%s postmaster=%s random=%s\n",
print_time(((dbdata_generic *)value)->time_stamp),
keybuffer,
print_cache(callout->result),
print_cache(callout->postmaster_result),
print_cache(callout->random_result));
}
break;
case type_ratelimit:
ratelimit = (dbdata_ratelimit *)value;
printf("%s.%06d rate: %10.3f key: %s\n",
print_time(ratelimit->time_stamp), ratelimit->time_usec,
ratelimit->rate, keybuffer);
break;
}
store_reset(value);
}
key = dbfn_scan(dbm, FALSE, &cursor);
}
dbfn_close(dbm);
return yield;
}
int
main(int argc, char **cargv)
{
open_db dbblock[8];
int max_db = sizeof(dbblock)/sizeof(open_db);
int current = -1;
int showtime = 0;
int i;
dbdata_wait *dbwait = NULL;
uschar **argv = USS cargv;
uschar buffer[256];
uschar structbuffer[1024];
if (argc != 2)
{
printf("Usage: test_dbfn directory\n");
printf("The subdirectory called \"db\" in the given directory is used for\n");
printf("the files used in this test program.\n");
return 1;
}
/* Initialize */
spool_directory = argv[1];
debug_selector = D_all - D_memory;
debug_file = stderr;
big_buffer = malloc(big_buffer_size);
for (i = 0; i < max_db; i++) dbblock[i].dbptr = NULL;
printf("\nExim's db functions tester: interface type is %s\n", EXIM_DBTYPE);
printf("DBM library: ");
#ifdef DB_VERSION_STRING
printf("Berkeley DB: %s\n", DB_VERSION_STRING);
#elif defined(BTREEVERSION) && defined(HASHVERSION)
#ifdef USE_DB
printf("probably Berkeley DB version 1.8x (native mode)\n");
#else
printf("probably Berkeley DB version 1.8x (compatibility mode)\n");
#endif
#elif defined(_DBM_RDONLY) || defined(dbm_dirfno)
printf("probably ndbm\n");
#elif defined(USE_TDB)
printf("using tdb\n");
#else
#ifdef USE_GDBM
printf("probably GDBM (native mode)\n");
#else
printf("probably GDBM (compatibility mode)\n");
#endif
#endif
/* Test the functions */
printf("\nTest the functions\n> ");
while (Ufgets(buffer, 256, stdin) != NULL)
{
int len = Ustrlen(buffer);
int count = 1;
clock_t start = 1;
clock_t stop = 0;
uschar *cmd = buffer;
while (len > 0 && isspace((uschar)buffer[len-1])) len--;
buffer[len] = 0;
if (isdigit((uschar)*cmd))
{
count = Uatoi(cmd);
while (isdigit((uschar)*cmd)) cmd++;
while (isspace((uschar)*cmd)) cmd++;
}
if (Ustrncmp(cmd, "open", 4) == 0)
{
int i;
open_db *odb;
uschar *s = cmd + 4;
while (isspace((uschar)*s)) s++;
for (i = 0; i < max_db; i++)
if (dbblock[i].dbptr == NULL) break;
if (i >= max_db)
{
printf("Too many open databases\n> ");
continue;
}
start = clock();
odb = dbfn_open(s, O_RDWR, dbblock + i, TRUE);
stop = clock();
if (odb != NULL)
{
current = i;
printf("opened %d\n", current);
}
/* Other error cases will have written messages */
else if (errno == ENOENT)
{
printf("open failed: %s%s\n", strerror(errno),
#ifdef USE_DB
" (or other Berkeley DB error)"
#else
""
#endif
);
}
}
else if (Ustrncmp(cmd, "write", 5) == 0)
{
int rc = 0;
uschar *key = cmd + 5;
uschar *data;
if (current < 0)
{
printf("No current database\n");
continue;
}
while (isspace((uschar)*key)) key++;
data = key;
while (*data != 0 && !isspace((uschar)*data)) data++;
*data++ = 0;
while (isspace((uschar)*data)) data++;
dbwait = (dbdata_wait *)(&structbuffer);
Ustrcpy(dbwait->text, data);
start = clock();
while (count-- > 0)
rc = dbfn_write(dbblock + current, key, dbwait,
Ustrlen(data) + sizeof(dbdata_wait));
stop = clock();
if (rc != 0) printf("Failed: %s\n", strerror(errno));
}
else if (Ustrncmp(cmd, "read", 4) == 0)
{
uschar *key = cmd + 4;
if (current < 0)
{
printf("No current database\n");
continue;
}
while (isspace((uschar)*key)) key++;
start = clock();
while (count-- > 0)
dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock+ current, key, NULL);
stop = clock();
printf("%s\n", (dbwait == NULL)? "<not found>" : CS dbwait->text);
}
else if (Ustrncmp(cmd, "delete", 6) == 0)
{
uschar *key = cmd + 6;
if (current < 0)
{
printf("No current database\n");
continue;
}
while (isspace((uschar)*key)) key++;
dbfn_delete(dbblock + current, key);
}
else if (Ustrncmp(cmd, "scan", 4) == 0)
{
EXIM_CURSOR *cursor;
BOOL startflag = TRUE;
uschar *key;
uschar keybuffer[256];
if (current < 0)
{
printf("No current database\n");
continue;
}
start = clock();
while ((key = dbfn_scan(dbblock + current, startflag, &cursor)) != NULL)
{
startflag = FALSE;
Ustrcpy(keybuffer, key);
dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock + current,
keybuffer, NULL);
printf("%s: %s\n", keybuffer, dbwait->text);
}
stop = clock();
printf("End of scan\n");
}
else if (Ustrncmp(cmd, "close", 5) == 0)
{
uschar *s = cmd + 5;
while (isspace((uschar)*s)) s++;
i = Uatoi(s);
if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n"); else
{
start = clock();
dbfn_close(dbblock + i);
stop = clock();
dbblock[i].dbptr = NULL;
if (i == current) current = -1;
}
}
else if (Ustrncmp(cmd, "file", 4) == 0)
{
uschar *s = cmd + 4;
while (isspace((uschar)*s)) s++;
i = Uatoi(s);
if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n");
else current = i;
}
else if (Ustrncmp(cmd, "time", 4) == 0)
{
showtime = ~showtime;
printf("Timing %s\n", showtime? "on" : "off");
}
else if (Ustrcmp(cmd, "q") == 0 || Ustrncmp(cmd, "quit", 4) == 0) break;
else if (Ustrncmp(cmd, "help", 4) == 0)
{
printf("close [<number>] close file [<number>]\n");
printf("delete <key> remove record from current file\n");
printf("file <number> make file <number> current\n");
printf("open <name> open db file\n");
printf("q[uit] exit program\n");
printf("read <key> read record from current file\n");
printf("scan scan current file\n");
printf("time time display on/off\n");
printf("write <key> <rest-of-line> write record to current file\n");
}
else printf("Eh?\n");
if (showtime && stop >= start)
printf("start=%d stop=%d difference=%d\n", (int)start, (int)stop,
(int)(stop - start));
printf("> ");
}
for (i = 0; i < max_db; i++)
{
if (dbblock[i].dbptr != NULL)
{
printf("\nClosing %d", i);
dbfn_close(dbblock + i);
}
}
printf("\n");
return 0;
}
int main(int argc, char **cargv)
{
struct stat statbuf;
int maxkeep = 30 * 24 * 60 * 60;
int dbdata_type, i, oldest, path_len;
key_item *keychain = NULL;
void *reset_point;
open_db dbblock;
open_db *dbm;
EXIM_CURSOR *cursor;
uschar **argv = USS cargv;
uschar buffer[256];
uschar *key;
/* Scan the options */
for (i = 1; i < argc; i++)
{
if (argv[i][0] != '-') break;
if (Ustrcmp(argv[i], "-f") == 0) continue;
if (Ustrcmp(argv[i], "-t") == 0)
{
uschar *s;
s = argv[++i];
maxkeep = 0;
while (*s != 0)
{
int value, count;
if (!isdigit(*s)) usage(US"tidydb", US" [-t <time>]");
(void)sscanf(CS s, "%d%n", &value, &count);
s += count;
switch (*s)
{
case 'w': value *= 7;
case 'd': value *= 24;
case 'h': value *= 60;
case 'm': value *= 60;
case 's': s++;
break;
default: usage(US"tidydb", US" [-t <time>]");
}
maxkeep += value;
}
}
else usage(US"tidydb", US" [-t <time>]");
}
/* Adjust argument values and process arguments */
argc -= --i;
argv += i;
dbdata_type = check_args(argc, argv, US"tidydb", US" [-t <time>]");
/* Compute the oldest keep time, verify what we are doing, and open the
database */
oldest = time(NULL) - maxkeep;
printf("Tidying Exim hints database %s/db/%s\n", argv[1], argv[2]);
dbm = dbfn_open(argv[1], argv[2], O_RDWR, &dbblock);
if (dbm == NULL) exit(1);
/* Prepare for building file names */
sprintf(CS buffer, "%s/input/", argv[1]);
path_len = Ustrlen(buffer);
/* It appears, by experiment, that it is a bad idea to make changes
to the file while scanning it. Pity the man page doesn't warn you about that.
Therefore, we scan and build a list of all the keys. Then we use that to
read the records and possibly update them. */
key = dbfn_scan(dbm, TRUE, &cursor);
while (key != NULL)
{
key_item *k = store_get(sizeof(key_item) + Ustrlen(key));
k->next = keychain;
keychain = k;
Ustrcpy(k->key, key);
key = dbfn_scan(dbm, FALSE, &cursor);
}
/* Now scan the collected keys and operate on the records, resetting
the store each time round. */
reset_point = store_get(0);
while (keychain != NULL)
{
dbdata_generic *value;
store_reset(reset_point);
key = keychain->key;
keychain = keychain->next;
value = dbfn_read_with_length(dbm, key, NULL);
/* A continuation record may have been deleted or renamed already, so
non-existence is not serious. */
if (value == NULL) continue;
/* Delete if too old */
if (value->time_stamp < oldest)
{
printf("deleted %s (too old)\n", key);
dbfn_delete(dbm, key);
continue;
}
/* Do database-specific tidying for wait databases, and message-
specific tidying for the retry database. */
if (dbdata_type == type_wait)
{
dbdata_wait *wait = (dbdata_wait *)value;
BOOL update = FALSE;
/* Leave corrupt records alone */
if (wait->count > WAIT_NAME_MAX)
{
printf("**** Data for %s corrupted\n count=%d=0x%x max=%d\n",
key, wait->count, wait->count, WAIT_NAME_MAX);
continue;
}
/* Loop for renamed continuation records. For each message id,
check to see if the message exists, and if not, remove its entry
from the record. Because of the possibility of split input directories,
we must look in both possible places for a -D file. */
for (;;)
{
int offset;
int length = wait->count * MESSAGE_ID_LENGTH;
for (offset = length - MESSAGE_ID_LENGTH;
offset >= 0; offset -= MESSAGE_ID_LENGTH)
{
Ustrncpy(buffer+path_len, wait->text + offset, MESSAGE_ID_LENGTH);
sprintf(CS(buffer+path_len + MESSAGE_ID_LENGTH), "-D");
if (Ustat(buffer, &statbuf) != 0)
{
buffer[path_len] = wait->text[offset+5];
buffer[path_len+1] = '/';
Ustrncpy(buffer+path_len+2, wait->text + offset, MESSAGE_ID_LENGTH);
sprintf(CS(buffer+path_len+2 + MESSAGE_ID_LENGTH), "-D");
if (Ustat(buffer, &statbuf) != 0)
{
int left = length - offset - MESSAGE_ID_LENGTH;
if (left > 0) Ustrncpy(wait->text + offset,
wait->text + offset + MESSAGE_ID_LENGTH, left);
wait->count--;
length -= MESSAGE_ID_LENGTH;
update = TRUE;
}
}
}
/* If record is empty and the main record, either delete it or rename
the next continuation, repeating if that is also empty. */
if (wait->count == 0 && Ustrchr(key, ':') == NULL)
{
while (wait->count == 0 && wait->sequence > 0)
{
uschar newkey[256];
dbdata_generic *newvalue;
sprintf(CS newkey, "%s:%d", key, wait->sequence - 1);
newvalue = dbfn_read_with_length(dbm, newkey, NULL);
if (newvalue != NULL)
{
value = newvalue;
wait = (dbdata_wait *)newvalue;
dbfn_delete(dbm, newkey);
printf("renamed %s\n", newkey);
update = TRUE;
}
else wait->sequence--;
}
/* If we have ended up with an empty main record, delete it
and break the loop. Otherwise the new record will be scanned. */
if (wait->count == 0 && wait->sequence == 0)
{
dbfn_delete(dbm, key);
printf("deleted %s (empty)\n", key);
update = FALSE;
break;
}
}
/* If not an empty main record, break the loop */
else break;
}
/* Re-write the record if required */
if (update)
{
printf("updated %s\n", key);
dbfn_write(dbm, key, wait, sizeof(dbdata_wait) +
wait->count * MESSAGE_ID_LENGTH);
}
}
/* If a retry record's key ends with a message-id, check that that message
still exists; if not, remove this record. */
else if (dbdata_type == type_retry)
{
uschar *id;
int len = Ustrlen(key);
if (len < MESSAGE_ID_LENGTH + 1) continue;
id = key + len - MESSAGE_ID_LENGTH - 1;
if (*id++ != ':') continue;
for (i = 0; i < MESSAGE_ID_LENGTH; i++)
{
if (i == 6 || i == 13)
{ if (id[i] != '-') break; }
else
{ if (!isalnum(id[i])) break; }
}
if (i < MESSAGE_ID_LENGTH) continue;
Ustrncpy(buffer + path_len, id, MESSAGE_ID_LENGTH);
sprintf(CS(buffer + path_len + MESSAGE_ID_LENGTH), "-D");
if (Ustat(buffer, &statbuf) != 0)
{
sprintf(CS(buffer + path_len), "%c/%s-D", id[5], id);
if (Ustat(buffer, &statbuf) != 0)
{
dbfn_delete(dbm, key);
printf("deleted %s (no message)\n", key);
}
}
}
}
dbfn_close(dbm);
printf("Tidying complete\n");
return 0;
}
