static int cmd_show_mailboxes(struct backup *backup,
const struct cyrbu_cmd_options *options)
{
struct backup_mailbox *mailbox = NULL;
struct backup_mailbox_message *record = NULL;
int i;
for (i = 0; i < strarray_size(options->argv); i++) {
char ts_deleted[32] = "";
const char *arg = strarray_nth(options->argv, i);
/* argument could be a uniqueid */
mailbox = backup_get_mailbox_by_uniqueid(backup, arg, 1);
/* or it could be an mboxname */
if (!mailbox) {
mbname_t *mbname = mbname_from_intname(arg);
if (!mbname) continue;
mailbox = backup_get_mailbox_by_name(backup, mbname, 1);
mbname_free(&mbname);
}
/* or it could be junk */
if (!mailbox) continue;
fprintf(stdout, "mboxname: %s\n", mailbox->mboxname);
fprintf(stdout, "uniqueid: %s\n", mailbox->uniqueid);
if (mailbox->deleted) {
strftime(ts_deleted, sizeof(ts_deleted), "%F %T",
localtime(&mailbox->deleted));
fprintf(stdout, "deleted: %s\n", ts_deleted);
}
fprintf(stdout, "messages:\n");
fprintf(stdout, " uid expunged time guid\n");
for (record = mailbox->records->head; record; record = record->next) {
char ts_expunged[32] = " ";
if (record->expunged)
strftime(ts_expunged, sizeof(ts_expunged), "%F %T",
localtime(&record->expunged));
fprintf(stdout, "%10d %s %s\n",
record->uid,
ts_expunged,
message_guid_encode(&record->guid));
}
fprintf(stdout, "\n");
backup_mailbox_free(&mailbox);
}
return 0;
}
static int do_synclogfile(const char *synclogfile)
{
strarray_t *folders = NULL;
sync_log_reader_t *slr;
int nskipped = 0;
int i;
int r;
slr = sync_log_reader_create_with_filename(synclogfile);
r = sync_log_reader_begin(slr);
if (r) goto out;
folders = read_sync_log_items(slr);
sync_log_reader_end(slr);
/* sort folders for locality of reference in file processing mode */
strarray_sort(folders, cmpstringp_raw);
signals_poll();
/* have some due items in the queue, try to index them */
rx = search_begin_update(verbose);
for (i = 0; i < folders->count; i++) {
const char *mboxname = strarray_nth(folders, i);
if (verbose > 1)
syslog(LOG_INFO, "do_synclogfile: indexing %s", mboxname);
r = index_one(mboxname, /*blocking*/1);
if (r == IMAP_MAILBOX_NONEXISTENT)
r = 0;
if (r == IMAP_MAILBOX_LOCKED || r == IMAP_AGAIN) {
nskipped++;
if (nskipped > 10000) {
syslog(LOG_ERR, "IOERROR: skipped too many times at %s", mboxname);
break;
}
r = 0;
/* try again at the end */
strarray_append(folders, mboxname);
}
if (r) {
syslog(LOG_ERR, "IOERROR: failed to index %s: %s",
mboxname, error_message(r));
break;
}
if (sleepmicroseconds)
usleep(sleepmicroseconds);
}
search_end_update(rx);
rx = NULL;
out:
strarray_free(folders);
sync_log_reader_free(slr);
return r;
}
static void do_rolling(const char *channel)
{
strarray_t *folders = NULL;
sync_log_reader_t *slr;
int i;
int r;
slr = sync_log_reader_create_with_channel(channel);
for (;;) {
signals_poll();
if (shutdown_file(NULL, 0))
shut_down(EC_TEMPFAIL);
r = sync_log_reader_begin(slr);
if (r) { /* including IMAP_AGAIN */
usleep(100000); /* 1/10th second */
continue;
}
folders = read_sync_log_items(slr);
if (folders->count) {
/* have some due items in the queue, try to index them */
rx = search_begin_update(verbose);
for (i = 0; i < folders->count; i++) {
const char *mboxname = strarray_nth(folders, i);
if (verbose > 1)
syslog(LOG_INFO, "do_rolling: indexing %s", mboxname);
r = index_one(mboxname, /*blocking*/0);
if (r == IMAP_AGAIN || r == IMAP_MAILBOX_LOCKED) {
/* XXX: alternative, just append to strarray_t *folders ... */
sync_log_channel(channel, "APPEND %s", mboxname);
}
if (sleepmicroseconds)
usleep(sleepmicroseconds);
}
search_end_update(rx);
rx = NULL;
}
strarray_free(folders);
folders = NULL;
}
/* XXX - we don't really get here... */
strarray_free(folders);
sync_log_reader_free(slr);
}
static void print_stringlist(const char *label, strarray_t *list)
{
int x, list_len = strarray_size(list);
printf("%s{%d} [", label, list_len);
for (x = 0; x < list_len; x++) {
const char *str = strarray_nth(list, x);
if (!(x % 5)) printf("\n\t\t");
print_string(" ", str);
}
printf("\n\t]");
free(strarray_takevf(list));
}
static int cmd_dump_chunk(struct backup *backup,
const struct cyrbu_cmd_options *options)
{
struct backup_chunk *chunk = NULL;
int chunk_id;
int r;
chunk_id = atoi(strarray_nth(options->argv, 0));
if (chunk_id <= 0) return -1;
chunk = backup_get_chunk(backup, chunk_id);
if (!chunk) return IMAP_NOTFOUND;
r = backup_read_chunk_data(backup, chunk, dump_buf, stdout);
backup_chunk_free(&chunk);
return r;
}
static int cmd_show_messages(struct backup *backup,
const struct cyrbu_cmd_options *options)
{
struct backup_message *message = NULL;
struct backup_mailbox_list *mailboxes = NULL;
struct backup_mailbox *mailbox;
struct message_guid want_guid;
int i;
for (i = 0; i < strarray_size(options->argv); i++) {
if (!message_guid_decode(&want_guid, strarray_nth(options->argv, i)))
continue;
message = backup_get_message(backup, &want_guid);
if (!message)
continue;
fprintf(stdout, "guid:\t%s\n", message_guid_encode(message->guid));
mailboxes = backup_get_mailboxes_by_message(backup, message, 0);
if (mailboxes) {
fprintf(stdout, "mailboxes:\n");
for (mailbox = mailboxes->head; mailbox; mailbox = mailbox->next) {
fprintf(stdout, "\t%s\t%s\n",
mailbox->uniqueid,
mailbox->mboxname);
}
backup_mailbox_list_empty(mailboxes);
free(mailboxes);
}
fprintf(stdout, "headers:\n");
backup_read_message_data(backup, message,
show_message_headers, stdout);
fprintf(stdout, "\n");
backup_message_free(&message);
}
return 0;
}
static int cmd_dump_message(struct backup *backup,
const struct cyrbu_cmd_options *options)
{
struct backup_message *message = NULL;
struct message_guid want_guid;
int r;
if (!message_guid_decode(&want_guid, strarray_nth(options->argv, 0)))
return IMAP_NOTFOUND;
message = backup_get_message(backup, &want_guid);
if (!message)
return IMAP_NOTFOUND;
r = backup_read_message_data(backup, message, dump_buf, stdout);
backup_message_free(&message);
return r;
}
static void _entry_to_tgt(const struct vparse_entry *entry, struct vparse_target *tgt)
{
struct vparse_param *param;
// rfc6350 3.3 - it is RECOMMENDED that property and parameter names be upper-case on output.
if (entry->group) {
_key_to_tgt(entry->group, tgt);
buf_putc(tgt->buf, '.');
}
_key_to_tgt(entry->name, tgt);
for (param = entry->params; param; param = param->next) {
buf_putc(tgt->buf, ';');
_key_to_tgt(param->name, tgt);
buf_putc(tgt->buf, '=');
if (_needsquote(param->value)) {
/* XXX - smart quoting? */
buf_putc(tgt->buf, '"');
_paramval_to_tgt(param->value, tgt);
buf_putc(tgt->buf, '"');
}
else {
_paramval_to_tgt(param->value, tgt);
}
}
buf_putc(tgt->buf, ':');
if (entry->multivalue) {
int i;
for (i = 0; i < entry->v.values->count; i++) {
if (i) buf_putc(tgt->buf, ';');
_value_to_tgt(strarray_nth(entry->v.values, i), tgt, 1);
}
}
else {
_value_to_tgt(entry->v.value, tgt, 0);
}
_endline(tgt);
}
int main(int argc, char *argv[])
{
const char *OLDDB = NULL, *NEWDB = NULL;
const char *old_db, *new_db;
int i;
int opt;
char *alt_config = NULL;
while ((opt = getopt(argc, argv, "C:")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
}
}
if ((argc - optind) != 4) {
strarray_t *backends = cyrusdb_backends();
char sep;
fprintf(stderr, "Usage: %s [-C altconfig] <old db> <old db backend> <new db> <new db backend>\n", argv[0]);
fprintf(stderr, "Usable Backends: ");
for(i=0, sep = ':'; i < backends->count; i++) {
fprintf(stderr, "%c %s", sep, strarray_nth(backends, i));
sep = ',';
}
strarray_free(backends);
fprintf(stderr, "\n");
exit(-1);
}
old_db = argv[optind];
new_db = argv[optind+2];
if (old_db[0] != '/' || new_db[0] != '/') {
printf("\nSorry, you cannot use this tool with relative path names.\n"
"This is because some database backends (mainly berkeley) do not\n"
"always do what you would expect with them.\n"
"\nPlease use absolute pathnames instead.\n\n");
exit(EC_OSERR);
}
OLDDB = argv[optind+1];
NEWDB = argv[optind+3];
if (NEWDB == OLDDB) {
fatal("no conversion required", EC_TEMPFAIL);
}
cyrus_init(alt_config, "cvt_cyrusdb", 0);
printf("Converting from %s (%s) to %s (%s)\n", old_db, OLDDB,
new_db, NEWDB);
cyrusdb_convert(old_db, new_db, OLDDB, NEWDB);
cyrus_done();
return 0;
}
