static int _parse_entry_multivalue(struct vparse_state *state)
{
state->entry->multivalue = 1;
state->entry->v.values = strarray_new();
NOTESTART();
while (*state->p) {
switch (*state->p) {
/* only one type of quoting */
case '\\':
/* seen in the wild - \n split by line wrapping */
if (state->p[1] == '\r') INC(1);
if (state->p[1] == '\n') {
if (state->p[2] != ' ' && state->p[2] != '\t')
return PE_BACKQUOTE_EOF;
INC(2);
}
if (!state->p[1])
return PE_BACKQUOTE_EOF;
if (state->p[1] == 'n' || state->p[1] == 'N')
PUTC('\n');
else
PUTC(state->p[1]);
INC(2);
break;
case ';':
strarray_appendm(state->entry->v.values, buf_dup_cstring(&state->buf));
INC(1);
break;
case '\r':
INC(1);
break; /* just skip */
case '\n':
if (state->p[1] == ' ' || state->p[1] == '\t') {/* wrapped line */
INC(2);
break;
}
/* otherwise it's the end of the value */
INC(1);
goto out;
default:
PUTC(*state->p);
INC(1);
break;
}
}
out:
/* reaching the end of the file isn't a failure here,
* it's just another type of end-of-value */
strarray_appendm(state->entry->v.values, buf_dup_cstring(&state->buf));
return 0;
}
static strarray_t *mygroups(const struct auth_state *auth_state)
{
strarray_t *sa;
int i;
if (!auth_state->ngroups)
return NULL;
sa = strarray_new();
strarray_truncate(sa, auth_state->ngroups);
for (i = 0; i < auth_state->ngroups; i++) {
strarray_append(sa, auth_state->groups[i].id);
}
return sa;
}
static strarray_t *read_sync_log_items(sync_log_reader_t *slr)
{
const char *args[3];
strarray_t *folders = strarray_new();
while (sync_log_reader_getitem(slr, args) == 0) {
if (!strcmp(args[0], "APPEND")) {
if (!mboxname_isdeletedmailbox(args[1], NULL))
strarray_add(folders, args[1]);
}
else if (!strcmp(args[0], "USER"))
mboxlist_usermboxtree(args[1], addmbox, folders, /*flags*/0);
}
return folders;
}
int main(int argc, char *argv[])
{
int option;
int i;
char *alt_config = NULL;
struct incremental_record irec;
progname = basename(argv[0]);
while ((option = getopt(argc, argv, "vC:")) != EOF) {
switch (option) {
case 'v':
verbose++;
break;
case 'C': /* alt config file */
alt_config = optarg;
break;
default:
usage();
break;
}
}
if (optind == argc) {
usage();
}
cyrus_init(alt_config, "dump", 0, CONFIG_NEED_PARTITION_DATA);
search_attr_init();
irec.incruid = 0;
strarray_t *array = strarray_new();
for (i = optind; i < argc; i++) {
strarray_append(array, argv[i]);
}
if (array->count)
mboxlist_findallmulti(NULL, array, 1, 0, 0, dump_me, &irec);
strarray_free(array);
cyrus_done();
return 0;
}
static void fill_cache(message_data_t *m)
{
rewind(m->data);
/* let's fill that header cache */
for (;;) {
char *name, *body;
strarray_t *contents;
if (parseheader(m->data, &name, &body) < 0) {
break;
}
/* put it in the hash table */
contents = (strarray_t *)hash_lookup(name, &m->cache);
if (!contents)
contents = hash_insert(name, strarray_new(), &m->cache);
strarray_appendm(contents, body);
free(name);
}
m->cache_full = 1;
}
EXPORTED variable_list_t *varlist_new(void) {
variable_list_t *vl;
vl = xzmalloc(sizeof(variable_list_t));
vl->var = strarray_new();
return vl;
}
EXPORTED void vparse_set_multiparam(struct vparse_state *state, const char *name)
{
if (!state->multiparam) state->multiparam = strarray_new();
strarray_append(state->multiparam, name);
}
int main(int argc, char **argv)
{
save_argv0(argv[0]);
struct cyrbu_cmd_options options = {0};
enum cyrbu_mode mode = CYRBU_MODE_UNSPECIFIED;
enum cyrbu_cmd cmd = CYRBU_CMD_UNSPECIFIED;
const char *alt_config = NULL;
const char *backup_name = NULL;
const char *command = NULL;
const char *subcommand = NULL;
struct backup *backup = NULL;
mbname_t *mbname = NULL;
int i, opt, r = 0;
while ((opt = getopt(argc, argv, "C:fmuv")) != EOF) {
switch (opt) {
case 'C':
alt_config = optarg;
break;
case 'f':
if (mode != CYRBU_MODE_UNSPECIFIED) usage();
mode = CYRBU_MODE_FILENAME;
break;
case 'm':
if (mode != CYRBU_MODE_UNSPECIFIED) usage();
mode = CYRBU_MODE_MBOXNAME;
break;
case 'u':
if (mode != CYRBU_MODE_UNSPECIFIED) usage();
mode = CYRBU_MODE_USERNAME;
break;
case 'v':
options.verbose++;
break;
default:
usage();
break;
}
}
/* default mode is username */
if (mode == CYRBU_MODE_UNSPECIFIED)
mode = CYRBU_MODE_USERNAME;
/* get the backup name */
if (optind == argc) usage();
backup_name = argv[optind++];
/* get the command */
if (optind == argc) usage();
command = argv[optind++];
/* get the subcommand */
if (optind == argc) usage();
subcommand = argv[optind++];
/* parse the command and subcommand */
cmd = parse_cmd_string(command, subcommand);
/* check remaining arguments based on command */
switch (cmd) {
case CYRBU_CMD_LIST_ALL:
case CYRBU_CMD_LIST_CHUNKS:
case CYRBU_CMD_LIST_MAILBOXES:
case CYRBU_CMD_LIST_MESSAGES:
/* these want no more arguments */
if (optind != argc) usage();
break;
case CYRBU_CMD_SHOW_CHUNKS:
case CYRBU_CMD_SHOW_MAILBOXES:
case CYRBU_CMD_SHOW_MESSAGES:
/* these need at least one more argument */
if (optind == argc) usage();
break;
case CYRBU_CMD_DUMP_CHUNK:
case CYRBU_CMD_DUMP_MAILBOX:
case CYRBU_CMD_DUMP_MESSAGE:
/* these need exactly one more argument */
if (argc - optind != 1) usage();
break;
default:
usage();
break;
}
/* build a nice args list */
options.argv = strarray_new();
for (i = optind; i < argc; i++) {
strarray_add(options.argv, argv[i]);
}
// FIXME finish parsing options
cyrus_init(alt_config, "cyr_backup", 0, 0);
/* open backup */
switch (mode) {
case CYRBU_MODE_FILENAME:
r = backup_open_paths(&backup, backup_name, NULL,
BACKUP_OPEN_NONBLOCK, BACKUP_OPEN_NOCREATE);
break;
case CYRBU_MODE_MBOXNAME:
mbname = mbname_from_intname(backup_name);
if (!mbname) usage();
r = backup_open(&backup, mbname,
BACKUP_OPEN_NONBLOCK, BACKUP_OPEN_NOCREATE);
break;
case CYRBU_MODE_USERNAME:
mbname = mbname_from_userid(backup_name);
if (!mbname) usage();
r = backup_open(&backup, mbname,
BACKUP_OPEN_NONBLOCK, BACKUP_OPEN_NOCREATE);
break;
default:
usage();
break;
}
/* run command */
if (!r && cmd_func[cmd])
r = cmd_func[cmd](backup, &options);
if (r)
fprintf(stderr, "%s: %s\n", backup_name, error_message(r));
/* close backup */
if (backup)
backup_close(&backup);
/* clean up and exit */
backup_cleanup_staging_path();
cyrus_done();
strarray_free(options.argv);
exit(r ? EC_TEMPFAIL : EC_OK);
}
int main (int argc, char *argv[]) {
int option; /* getopt() returns an int */
char *alt_config = NULL;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((option = getopt(argc, argv, "C:rn")) != EOF) {
switch (option) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'r':
disinfect = 1;
break;
case 'n':
notify = 1;
break;
case 'h':
default: usage(argv[0]);
}
}
cyrus_init(alt_config, "cyr_virusscan", 0, CONFIG_NEED_PARTITION_DATA);
if (!engine.name) {
fatal("no virus scanner configured", EC_SOFTWARE);
} else {
if (verbose) printf("Using %s virus scanner\n", engine.name);
}
engine.state = engine.init();
mboxlist_init(0);
mboxlist_open(NULL);
/* open the quota db, we'll need it for expunge */
quotadb_init(0);
quotadb_open(NULL);
sync_log_init();
/* setup for mailbox event notifications */
mboxevent_init();
if (optind == argc) { /* do the whole partition */
mboxlist_findall(NULL, "*", 1, 0, 0, scan_me, NULL);
} else {
strarray_t *array = strarray_new();
for (; optind < argc; optind++) {
strarray_append(array, argv[optind]);
}
mboxlist_findallmulti(NULL, array, 1, 0, 0, scan_me, NULL);
strarray_free(array);
}
if (notify) append_notifications();
sync_log_done();
quotadb_close();
quotadb_done();
mboxlist_close();
mboxlist_done();
engine.destroy(engine.state);
cyrus_done();
return 0;
}