EXPORTED search_query_t *search_query_new(struct index_state *state,
struct searchargs *searchargs)
{
search_query_t *query;
query = xzmalloc(sizeof(*query));
query->state = state;
query->searchargs = searchargs;
construct_hash_table(&query->subs_by_folder, 128, 0);
construct_hash_table(&query->subs_by_indexed, 128, 0);
ptrarray_init(&query->merged_msgdata);
construct_hash_table(&query->folders_by_name, 128, 0);
ptrarray_init(&query->folders_by_id);
return query;
}
static message_data_t *new_msg(FILE *msg, int size, const char *name)
{
message_data_t *m;
m = xmalloc(sizeof(message_data_t));
m->data = msg;
m->size = size;
m->name = xstrdup(name);
m->content.base = NULL;
m->content.len = 0;
m->content.body = NULL;
construct_hash_table(&m->cache, 1000, 0);
m->cache_full = 0;
return m;
}
/*
* Construct an iCalendar property value from XML content.
*/
static icalvalue *xml_element_to_icalvalue(xmlNodePtr xtype,
icalvalue_kind kind)
{
icalvalue *value = NULL;
xmlNodePtr node;
xmlChar *content = NULL;
switch (kind) {
case ICAL_GEO_VALUE: {
struct icalgeotype geo;
node = xmlFirstElementChild(xtype);
if (!node) {
syslog(LOG_WARNING, "Missing <latitude> XML element");
break;
}
else if (xmlStrcmp(node->name, BAD_CAST "latitude")) {
syslog(LOG_WARNING,
"Expected <latitude> XML element, received %s", node->name);
break;
}
content = xmlNodeGetContent(node);
geo.lat = atof((const char *) content);
node = xmlNextElementSibling(node);
if (!node) {
syslog(LOG_WARNING, "Missing <longitude> XML element");
break;
}
else if (xmlStrcmp(node->name, BAD_CAST "longitude")) {
syslog(LOG_WARNING,
"Expected <longitude> XML element, received %s", node->name);
break;
}
xmlFree(content);
content = xmlNodeGetContent(node);
geo.lon = atof((const char *) content);
value = icalvalue_new_geo(geo);
break;
}
case ICAL_PERIOD_VALUE: {
struct icalperiodtype p;
p.start = p.end = icaltime_null_time();
p.duration = icaldurationtype_from_int(0);
node = xmlFirstElementChild(xtype);
if (!node) {
syslog(LOG_WARNING, "Missing <start> XML element");
break;
}
else if (xmlStrcmp(node->name, BAD_CAST "start")) {
syslog(LOG_WARNING,
"Expected <start> XML element, received %s", node->name);
break;
}
content = xmlNodeGetContent(node);
p.start = icaltime_from_string((const char *) content);
if (icaltime_is_null_time(p.start)) break;
node = xmlNextElementSibling(node);
if (!node) {
syslog(LOG_WARNING, "Missing <end> / <duration> XML element");
break;
}
else if (!xmlStrcmp(node->name, BAD_CAST "end")) {
xmlFree(content);
content = xmlNodeGetContent(node);
p.end = icaltime_from_string((const char *) content);
if (icaltime_is_null_time(p.end)) break;
}
else if (!xmlStrcmp(node->name, BAD_CAST "duration")) {
xmlFree(content);
content = xmlNodeGetContent(node);
p.duration = icaldurationtype_from_string((const char *) content);
if (icaldurationtype_as_int(p.duration) == 0) break;
}
else {
syslog(LOG_WARNING,
"Expected <end> / <duration> XML element, received %s",
node->name);
break;
}
value = icalvalue_new_period(p);
break;
}
case ICAL_RECUR_VALUE: {
struct buf rrule = BUF_INITIALIZER;
struct hash_table byrules;
struct icalrecurrencetype rt;
char *sep = "";
construct_hash_table(&byrules, 10, 1);
/* create an iCal RRULE string from xCal <recur> sub-elements */
for (node = xmlFirstElementChild(xtype); node;
node = xmlNextElementSibling(node)) {
content = xmlNodeGetContent(node);
if (!xmlStrncmp(node->name, BAD_CAST "by", 2)) {
/* BY* rules can have a list of values -
assemble them using a hash table */
struct buf *vals =
hash_lookup((const char *) node->name, &byrules);
if (vals) {
/* append this value to existing list */
buf_printf(vals, ",%s", (char *) content);
}
else {
/* create new list with this valiue */
vals = xzmalloc(sizeof(struct buf));
buf_setcstr(vals, (char *) content);
hash_insert((char *) node->name, vals, &byrules);
}
}
else {
/* single value rpart */
buf_printf(&rrule, "%s%s=%s", sep,
ucase((char *) node->name), (char *) content);
sep = ";";
}
xmlFree(content);
content = NULL;
}
/* append the BY* rules to RRULE buffer */
hash_enumerate(&byrules,
(void (*)(const char*, void*, void*)) &append_byrule,
&rrule);
free_hash_table(&byrules, NULL);
/* parse our iCal RRULE string */
rt = icalrecurrencetype_from_string(buf_cstring(&rrule));
buf_free(&rrule);
if (rt.freq != ICAL_NO_RECURRENCE) value = icalvalue_new_recur(rt);
break;
}
case ICAL_REQUESTSTATUS_VALUE: {
struct icalreqstattype rst = { ICAL_UNKNOWN_STATUS, NULL, NULL };
short maj, min;
node = xmlFirstElementChild(xtype);
if (!node) {
syslog(LOG_WARNING, "Missing <code> XML element");
break;
}
else if (xmlStrcmp(node->name, BAD_CAST "code")) {
syslog(LOG_WARNING,
"Expected <code> XML element, received %s", node->name);
break;
}
content = xmlNodeGetContent(node);
if (sscanf((const char *) content, "%hd.%hd", &maj, &min) == 2) {
rst.code = icalenum_num_to_reqstat(maj, min);
}
if (rst.code == ICAL_UNKNOWN_STATUS) {
syslog(LOG_WARNING, "Unknown request-status code");
break;
}
node = xmlNextElementSibling(node);
if (!node) {
syslog(LOG_WARNING, "Missing <description> XML element");
break;
}
else if (xmlStrcmp(node->name, BAD_CAST "description")) {
syslog(LOG_WARNING,
"Expected <description> XML element, received %s",
node->name);
break;
}
xmlFree(content);
content = xmlNodeGetContent(node);
rst.desc = (const char *) content;
node = xmlNextElementSibling(node);
if (node) {
if (xmlStrcmp(node->name, BAD_CAST "data")) {
syslog(LOG_WARNING,
"Expected <data> XML element, received %s", node->name);
break;
}
xmlFree(content);
content = xmlNodeGetContent(node);
rst.debug = (const char *) content;
}
value = icalvalue_new_requeststatus(rst);
break;
}
case ICAL_UTCOFFSET_VALUE: {
int n, utcoffset, hours, minutes, seconds = 0;
char sign;
content = xmlNodeGetContent(xtype);
n = sscanf((const char *) content, "%c%02d:%02d:%02d",
&sign, &hours, &minutes, &seconds);
if (n < 3) {
syslog(LOG_WARNING, "Unexpected utc-offset format");
break;
}
utcoffset = hours*3600 + minutes*60 + seconds;
if (sign == '-') utcoffset = -utcoffset;
value = icalvalue_new_utcoffset(utcoffset);
break;
}
default:
content = xmlNodeGetContent(xtype);
value = icalvalue_new_from_string(kind, (const char *) content);
break;
}
if (content) xmlFree(content);
return value;
}
int main(int argc, char **argv)
{
int opt, r = 0;
char *alt_config = NULL, *pub = NULL, *ver = NULL, *winfile = NULL;
char prefix[2048];
enum { REBUILD, WINZONES, NONE } op = NONE;
if ((geteuid()) == 0 && (become_cyrus(/*ismaster*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:r:vw:")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'r':
if (op == NONE) {
op = REBUILD;
pub = optarg;
ver = strchr(optarg, ':');
if (ver) *ver++ = '\0';
else usage();
}
else usage();
break;
case 'v':
verbose = 1;
break;
case 'w':
if (op == NONE) {
op = WINZONES;
winfile = optarg;
}
else usage();
break;
default:
usage();
}
}
cyrus_init(alt_config, "ctl_zoneinfo", 0, 0);
signals_set_shutdown(&shut_down);
signals_add_handlers(0);
snprintf(prefix, sizeof(prefix), "%s%s", config_dir, FNAME_ZONEINFODIR);
switch (op) {
case REBUILD: {
struct hash_table tzentries;
struct zoneinfo *info;
struct txn *tid = NULL;
char buf[1024];
FILE *fp;
construct_hash_table(&tzentries, 500, 1);
/* Add INFO record (overall lastmod and TZ DB source version) */
info = xzmalloc(sizeof(struct zoneinfo));
info->type = ZI_INFO;
appendstrlist(&info->data, pub);
appendstrlist(&info->data, ver);
hash_insert(INFO_TZID, info, &tzentries);
/* Add LEAP record (last updated and hash) */
snprintf(buf, sizeof(buf), "%s%s", prefix, FNAME_LEAPSECFILE);
if (verbose) printf("Processing leap seconds file %s\n", buf);
if (!(fp = fopen(buf, "r"))) {
fprintf(stderr, "Could not open leap seconds file %s\n", buf);
}
else {
struct zoneinfo *leap = xzmalloc(sizeof(struct zoneinfo));
leap->type = ZI_INFO;
while(fgets(buf, sizeof(buf), fp)) {
if (buf[0] == '#') {
/* comment line */
if (buf[1] == '$') {
/* last updated */
unsigned long last;
sscanf(buf+2, "\t%lu", &last);
leap->dtstamp = last - NIST_EPOCH_OFFSET;
}
else if (buf[1] == 'h') {
/* hash */
char *p, *hash = buf+3 /* skip "#h\t" */;
/* trim trailing whitespace */
for (p = hash + strlen(hash); isspace(*--p); *p = '\0');
appendstrlist(&leap->data, hash);
}
}
}
fclose(fp);
hash_insert(LEAP_TZID, leap, &tzentries);
info->dtstamp = leap->dtstamp;
}
/* Add ZONE/LINK records */
do_zonedir(prefix, &tzentries, info);
zoneinfo_open(NULL);
/* Store records */
hash_enumerate(&tzentries, &store_zoneinfo, &tid);
zoneinfo_close(tid);
free_hash_table(&tzentries, &free_zoneinfo);
break;
}
case WINZONES: {
xmlParserCtxtPtr ctxt;
xmlDocPtr doc;
xmlNodePtr node;
struct buf tzidbuf = BUF_INITIALIZER;
struct buf aliasbuf = BUF_INITIALIZER;
if (verbose) printf("Processing Windows Zone file %s\n", winfile);
/* Parse the XML file */
ctxt = xmlNewParserCtxt();
if (!ctxt) {
fprintf(stderr, "Failed to create XML parser context\n");
break;
}
doc = xmlCtxtReadFile(ctxt, winfile, NULL, 0);
xmlFreeParserCtxt(ctxt);
if (!doc) {
fprintf(stderr, "Failed to parse XML document\n");
break;
}
node = xmlDocGetRootElement(doc);
if (!node || xmlStrcmp(node->name, BAD_CAST "supplementalData")) {
fprintf(stderr, "Incorrect root node\n");
goto done;
}
for (node = xmlFirstElementChild(node);
node && xmlStrcmp(node->name, BAD_CAST "windowsZones");
node = xmlNextElementSibling(node));
if (!node) {
fprintf(stderr, "Missing windowsZones node\n");
goto done;
}
node = xmlFirstElementChild(node);
if (!node || xmlStrcmp(node->name, BAD_CAST "mapTimezones")) {
fprintf(stderr, "Missing mapTimezones node\n");
goto done;
}
if (chdir(prefix)) {
fprintf(stderr, "chdir(%s) failed\n", prefix);
goto done;
}
for (node = xmlFirstElementChild(node);
node;
node = xmlNextElementSibling(node)) {
if (!xmlStrcmp(node->name, BAD_CAST "mapZone") &&
!xmlStrcmp(xmlGetProp(node, BAD_CAST "territory"),
BAD_CAST "001")) {
const char *tzid, *alias;
buf_setcstr(&tzidbuf,
(const char *) xmlGetProp(node, BAD_CAST "type"));
buf_appendcstr(&tzidbuf, ".ics");
tzid = buf_cstring(&tzidbuf);
buf_setcstr(&aliasbuf,
(const char *) xmlGetProp(node, BAD_CAST "other"));
buf_appendcstr(&aliasbuf, ".ics");
alias = buf_cstring(&aliasbuf);
if (verbose) printf("\tLINK: %s -> %s\n", alias, tzid);
if (symlink(tzid, alias)) {
if (errno == EEXIST) {
struct stat sbuf;
if (stat(alias, &sbuf)) {
fprintf(stderr, "stat(%s) failed: %s\n",
alias, strerror(errno));
errno = EEXIST;
}
else if (sbuf.st_mode & S_IFLNK) {
char link[MAX_MAILBOX_PATH+1];
int n = readlink(alias, link, MAX_MAILBOX_PATH);
if (n == -1) {
fprintf(stderr, "readlink(%s) failed: %s\n",
alias, strerror(errno));
errno = EEXIST;
}
else if (n == (int) strlen(tzid) &&
!strncmp(tzid, link, n)) {
errno = 0;
}
}
}
if (errno) {
fprintf(stderr, "symlink(%s, %s) failed: %s\n",
tzid, alias, strerror(errno));
}
}
}
}
done:
buf_free(&aliasbuf);
buf_free(&tzidbuf);
xmlFreeDoc(doc);
break;
}
case NONE:
r = 2;
usage();
break;
}
cyrus_done();
return r;
}
int main(int argc, char **argv)
{
int opt, i, r;
int dousers = 0;
int rflag = 0;
int mflag = 0;
int fflag = 0;
int xflag = 0;
char buf[MAX_MAILBOX_PATH+1];
strarray_t discovered = STRARRAY_INITIALIZER;
char *alt_config = NULL;
char *start_part = NULL;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
construct_hash_table(&unqid_table, 2047, 1);
while ((opt = getopt(argc, argv, "C:kp:rmfsxgGqRUMoOnV:u")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'p':
start_part = optarg;
break;
case 'r':
rflag = 1;
break;
case 'u':
dousers = 1;
break;
case 'm':
mflag = 1;
break;
case 'n':
reconstruct_flags &= ~RECONSTRUCT_MAKE_CHANGES;
break;
case 'g':
fprintf(stderr, "reconstruct: deprecated option -g ignored\n");
break;
case 'G':
reconstruct_flags |= RECONSTRUCT_ALWAYS_PARSE;
break;
case 'f':
fflag = 1;
break;
case 'x':
xflag = 1;
break;
case 'k':
fprintf(stderr, "reconstruct: deprecated option -k ignored\n");
break;
case 's':
reconstruct_flags &= ~RECONSTRUCT_DO_STAT;
break;
case 'q':
reconstruct_flags |= RECONSTRUCT_QUIET;
break;
case 'R':
reconstruct_flags |= RECONSTRUCT_GUID_REWRITE;
break;
case 'U':
reconstruct_flags |= RECONSTRUCT_GUID_UNLINK;
break;
case 'o':
reconstruct_flags |= RECONSTRUCT_IGNORE_ODDFILES;
break;
case 'O':
reconstruct_flags |= RECONSTRUCT_REMOVE_ODDFILES;
break;
case 'M':
reconstruct_flags |= RECONSTRUCT_PREFER_MBOXLIST;
break;
case 'V':
if (!strcasecmp(optarg, "max"))
setversion = MAILBOX_MINOR_VERSION;
else
setversion = atoi(optarg);
break;
default:
usage();
}
}
cyrus_init(alt_config, "reconstruct", 0, CONFIG_NEED_PARTITION_DATA);
global_sasl_init(1,0,NULL);
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&recon_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EC_CONFIG);
}
sync_log_init();
if (mflag) {
if (rflag || fflag || optind != argc) {
cyrus_done();
usage();
}
do_mboxlist();
}
mboxlist_init(0);
mboxlist_open(NULL);
quotadb_init(0);
quotadb_open(NULL);
#ifdef WITH_DAV
caldav_init();
carddav_init();
webdav_init();
#endif
/* Deal with nonexistent mailboxes */
if (start_part) {
/* We were handed a mailbox that does not exist currently */
if(optind == argc) {
fprintf(stderr,
"When using -p, you must specify a mailbox to attempt to reconstruct.");
exit(EC_USAGE);
}
/* do any of the mailboxes exist in mboxlist already? */
/* Do they look like mailboxes? */
for (i = optind; i < argc; i++) {
if (strchr(argv[i],'%') || strchr(argv[i],'*')) {
fprintf(stderr, "Using wildcards with -p is not supported.\n");
exit(EC_USAGE);
}
/* Translate mailboxname */
char *intname = mboxname_from_external(argv[i], &recon_namespace, NULL);
/* Does it exist */
do {
r = mboxlist_lookup(intname, NULL, NULL);
} while (r == IMAP_AGAIN);
if (r != IMAP_MAILBOX_NONEXISTENT) {
fprintf(stderr,
"Mailbox %s already exists. Cannot specify -p.\n",
argv[i]);
exit(EC_USAGE);
}
free(intname);
}
/* None of them exist. Create them. */
for (i = optind; i < argc; i++) {
/* Translate mailboxname */
char *intname = mboxname_from_external(argv[i], &recon_namespace, NULL);
/* don't notify mailbox creation here */
r = mboxlist_createmailbox(intname, 0, start_part, 1,
"cyrus", NULL, 0, 0, !xflag, 0, NULL);
if (r) {
fprintf(stderr, "could not create %s\n", argv[i]);
}
free(intname);
}
}
/* Normal Operation */
if (optind == argc) {
if (rflag || dousers) {
fprintf(stderr, "please specify a mailbox to recurse from\n");
cyrus_done();
exit(EC_USAGE);
}
assert(!rflag);
strlcpy(buf, "*", sizeof(buf));
mboxlist_findall(&recon_namespace, buf, 1, 0, 0,
do_reconstruct, NULL);
}
for (i = optind; i < argc; i++) {
if (dousers) {
mboxlist_usermboxtree(argv[i], do_reconstruct_p, NULL, MBOXTREE_TOMBSTONES|MBOXTREE_DELETED);
continue;
}
char *domain = NULL;
/* save domain */
if (config_virtdomains) domain = strchr(argv[i], '@');
strlcpy(buf, argv[i], sizeof(buf));
/* reconstruct the first mailbox/pattern */
mboxlist_findall(&recon_namespace, buf, 1, 0,
0, do_reconstruct,
fflag ? &discovered : NULL);
if (rflag) {
/* build a pattern for submailboxes */
char *p = strchr(buf, '@');
if (p) *p = '\0';
strlcat(buf, ".*", sizeof(buf));
/* append the domain */
if (domain) strlcat(buf, domain, sizeof(buf));
/* reconstruct the submailboxes */
mboxlist_findall(&recon_namespace, buf, 1, 0,
0, do_reconstruct,
fflag ? &discovered : NULL);
}
}
/* examine our list to see if we discovered anything */
while (discovered.count) {
char *name = strarray_shift(&discovered);
int r = 0;
/* create p (database only) and reconstruct it */
/* partition is defined by the parent mailbox */
/* don't notify mailbox creation here */
r = mboxlist_createmailbox(name, 0, NULL, 1,
"cyrus", NULL, 0, 0, !xflag, 0, NULL);
if (r) {
fprintf(stderr, "createmailbox %s: %s\n",
name, error_message(r));
} else {
mboxlist_findone(&recon_namespace, name, 1, 0,
0, do_reconstruct,
&discovered);
}
/* may have added more things into our list */
free(name);
}
free_hash_table(&unqid_table, free);
sync_log_done();
mboxlist_close();
mboxlist_done();
quotadb_close();
quotadb_done();
partlist_local_done();
#ifdef WITH_DAV
webdav_done();
carddav_done();
caldav_done();
#endif
cyrus_done();
strarray_fini(&discovered);
return 0;
}
/* verify that the matching MAILBOX exists within the claimed chunk
* for each mailbox or mailbox_message in the index
*/
static int verify_chunk_mailbox_links(struct backup *backup, struct backup_chunk *chunk,
struct gzuncat *gzuc, int verbose, FILE *out)
{
/*
* get list of mailboxes in chunk
* get list of mailbox_messages in chunk
* index mailboxes list by uniqueid
* index mailbox_messages list by uniqueid:uid
* open chunk
* foreach line in chunk
* read dlist
* skip if it's not a mailbox
* if details in dlist match details in mailbox
* remove from mailbox list/index
* foreach record in dlist
* if details in dlist match details in mailbox_message
* remove from mailbox_message list/index
* failed if either list of mailboxes or list of mailbox_messages is not empty
*/
struct backup_mailbox_list *mailbox_list = NULL;
struct backup_mailbox_message_list *mailbox_message_list = NULL;
hash_table mailbox_list_index = HASH_TABLE_INITIALIZER;
hash_table mailbox_message_list_index = HASH_TABLE_INITIALIZER;
struct backup_mailbox *mailbox = NULL;
struct backup_mailbox_message *mailbox_message = NULL;
int r;
if (out && verbose)
fprintf(out, "checking chunk %d mailbox links...\n", chunk->id);
mailbox_list = backup_get_mailboxes(backup, chunk->id, 0);
mailbox_message_list = backup_get_mailbox_messages(backup, chunk->id);
if (mailbox_list->count == 0 && mailbox_message_list->count == 0) {
/* nothing we care about in this chunk */
free(mailbox_list);
free(mailbox_message_list);
if (out && verbose)
fprintf(out, "ok\n");
return 0;
}
/* XXX consider whether the two hashes should use pools */
if (mailbox_list->count) {
/* build an index of the mailbox list */
construct_hash_table(&mailbox_list_index, mailbox_list->count, 0);
mailbox = mailbox_list->head;
while (mailbox) {
hash_insert(mailbox->uniqueid, mailbox, &mailbox_list_index);
mailbox = mailbox->next;
}
}
if (mailbox_message_list->count) {
/* build an index of the mailbox message list */
construct_hash_table(&mailbox_message_list_index,
mailbox_message_list->count, 0);
mailbox_message = mailbox_message_list->head;
while (mailbox_message) {
char keybuf[1024]; // FIXME whatever
snprintf(keybuf, sizeof(keybuf), "%s:%d",
mailbox_message->mailbox_uniqueid, mailbox_message->uid);
hash_insert(keybuf, mailbox_message, &mailbox_message_list_index);
mailbox_message = mailbox_message->next;
}
}
r = gzuc_member_start_from(gzuc, chunk->offset);
if (r) {
syslog(LOG_ERR, "%s: error reading chunk %i at offset %jd: %s",
__func__, chunk->id, chunk->offset, zError(r));
if (out)
fprintf(out, "error reading chunk %i at offset %jd: %s",
chunk->id, chunk->offset, zError(r));
goto done;
}
struct protstream *ps = prot_readcb(_prot_fill_cb, gzuc);
prot_setisclient(ps, 1); /* don't sync literals */
struct buf cmd = BUF_INITIALIZER;
while (1) {
struct dlist *dl = NULL;
struct dlist *record = NULL;
struct dlist *di = NULL;
const char *uniqueid = NULL;
int c = parse_backup_line(ps, NULL, &cmd, &dl);
if (c == EOF) {
const char *error = prot_error(ps);
if (error && 0 != strcmp(error, PROT_EOF_STRING)) {
syslog(LOG_ERR,
"%s: error reading chunk %i data at offset %jd, byte %i: %s",
__func__, chunk->id, chunk->offset, prot_bytes_in(ps), error);
if (out)
fprintf(out, "error reading chunk %i data at offset %jd, byte %i: %s",
chunk->id, chunk->offset, prot_bytes_in(ps), error);
r = EOF;
}
break;
}
if (strcmp(buf_cstring(&cmd), "APPLY") != 0)
goto next_line;
if (strcmp(dl->name, "MAILBOX") != 0)
goto next_line;
if (!dlist_getatom(dl, "UNIQUEID", &uniqueid))
goto next_line;
if (mailbox_list->count) {
mailbox = (struct backup_mailbox *) hash_lookup(uniqueid, &mailbox_list_index);
if (mailbox && mailbox_matches(mailbox, dl)) {
backup_mailbox_list_remove(mailbox_list, mailbox);
hash_del(uniqueid, &mailbox_list_index);
backup_mailbox_free(&mailbox);
}
}
if (mailbox_message_list->count) {
if (!dlist_getlist(dl, "RECORD", &record))
goto next_line;
for (di = record->head; di; di = di->next) {
char keybuf[1024]; // FIXME whatever
uint32_t uid;
if (!dlist_getnum32(di, "UID", &uid))
continue;
snprintf(keybuf, sizeof(keybuf), "%s:%d", uniqueid, uid);
mailbox_message = (struct backup_mailbox_message *) hash_lookup(
keybuf, &mailbox_message_list_index);
if (!mailbox_message)
continue;
if (!mailbox_message_matches(mailbox_message, di))
continue;
backup_mailbox_message_list_remove(mailbox_message_list, mailbox_message);
hash_del(keybuf, &mailbox_message_list_index);
backup_mailbox_message_free(&mailbox_message);
}
}
next_line:
if (dl) {
dlist_unlink_files(dl);
dlist_free(&dl);
}
}
buf_free(&cmd);
prot_free(ps);
gzuc_member_end(gzuc, NULL);
/* anything left in either of the lists is missing from the chunk data. bad! */
mailbox = mailbox_list->head;
while (mailbox) {
syslog(LOG_DEBUG, "%s: chunk %d missing mailbox data for %s (%s)\n",
__func__, chunk->id, mailbox->uniqueid, mailbox->mboxname);
if (out)
fprintf(out, "chunk %d missing mailbox data for %s (%s)\n",
chunk->id, mailbox->uniqueid, mailbox->mboxname);
mailbox = mailbox->next;
}
mailbox_message = mailbox_message_list->head;
while (mailbox_message) {
syslog(LOG_DEBUG, "%s: chunk %d missing mailbox_message data for %s uid %u\n",
__func__, chunk->id, mailbox_message->mailbox_uniqueid,
mailbox_message->uid);
if (out)
fprintf(out, "chunk %d missing mailbox_message data for %s uid %u\n",
chunk->id, mailbox_message->mailbox_uniqueid,
mailbox_message->uid);
mailbox_message = mailbox_message->next;
}
if (!r) r = mailbox_list->count || mailbox_message_list->count ? -1 : 0;
done:
free_hash_table(&mailbox_list_index, NULL);
free_hash_table(&mailbox_message_list_index, NULL);
backup_mailbox_list_empty(mailbox_list);
free(mailbox_list);
backup_mailbox_message_list_empty(mailbox_message_list);
free(mailbox_message_list);
syslog(LOG_DEBUG, "%s: chunk %d %s!\n", __func__, chunk->id,
r ? "failed" : "passed");
if (out && verbose)
fprintf(out, "%s\n", r ? "error" : "ok");
return r;
}
