static int
parse_sup_line (void *ctx, char *line,
char **query_str, tag_op_list_t *tag_ops)
{
regmatch_t match[3];
char *file_tags;
int rerr;
tag_op_list_reset (tag_ops);
chomp_newline (line);
/* Silently ignore blank lines */
if (line[0] == '\0') {
return 1;
}
rerr = xregexec (®ex, line, 3, match, 0);
if (rerr == REG_NOMATCH) {
fprintf (stderr, "Warning: Ignoring invalid sup format line: %s\n",
line);
return 1;
}
*query_str = talloc_strndup_debug (ctx, line + match[1].rm_so,
match[1].rm_eo - match[1].rm_so);
file_tags = talloc_strndup_debug (ctx, line + match[2].rm_so,
match[2].rm_eo - match[2].rm_so);
char *tok = file_tags;
size_t tok_len = 0;
tag_op_list_reset (tag_ops);
while ((tok = strtok_len (tok + tok_len, " ", &tok_len)) != NULL) {
if (*(tok + tok_len) != '\0') {
*(tok + tok_len) = '\0';
tok_len++;
}
if (tag_op_list_append (tag_ops, tok, FALSE))
return -1;
}
return 0;
}
static int
count_file (notmuch_database_t *notmuch, FILE *input, const char **exclude_tags,
size_t exclude_tags_length, int output, int print_lastmod)
{
char *line = NULL;
ssize_t line_len;
size_t line_size;
int ret = 0;
while (! ret && (line_len = getline (&line, &line_size, input)) != -1) {
chomp_newline (line);
ret = print_count (notmuch, line, exclude_tags, exclude_tags_length,
output, print_lastmod);
}
if (line)
free (line);
return ret;
}
int
notmuch_restore_command (unused (void *ctx), int argc, char *argv[])
{
notmuch_config_t *config;
notmuch_database_t *notmuch;
notmuch_bool_t synchronize_flags;
notmuch_bool_t accumulate = FALSE;
char *input_file_name = NULL;
FILE *input = stdin;
char *line = NULL;
size_t line_size;
ssize_t line_len;
regex_t regex;
int rerr;
int opt_index;
config = notmuch_config_open (ctx, NULL, NULL);
if (config == NULL)
return 1;
if (notmuch_database_open (notmuch_config_get_database_path (config),
NOTMUCH_DATABASE_MODE_READ_WRITE, ¬much))
return 1;
synchronize_flags = notmuch_config_get_maildir_synchronize_flags (config);
notmuch_opt_desc_t options[] = {
{ NOTMUCH_OPT_POSITION, &input_file_name, 0, 0, 0 },
{ NOTMUCH_OPT_BOOLEAN, &accumulate, "accumulate", 'a', 0 },
{ 0, 0, 0, 0, 0 }
};
opt_index = parse_arguments (argc, argv, options, 1);
if (opt_index < 0) {
/* diagnostics already printed */
return 1;
}
if (input_file_name) {
input = fopen (input_file_name, "r");
if (input == NULL) {
fprintf (stderr, "Error opening %s for reading: %s\n",
input_file_name, strerror (errno));
return 1;
}
optind++;
}
if (opt_index < argc) {
fprintf (stderr,
"Cannot read dump from more than one file: %s\n",
argv[optind]);
return 1;
}
/* Dump output is one line per message. We match a sequence of
* non-space characters for the message-id, then one or more
* spaces, then a list of space-separated tags as a sequence of
* characters within literal '(' and ')'. */
if ( xregcomp (®ex,
"^([^ ]+) \\(([^)]*)\\)$",
REG_EXTENDED) )
INTERNAL_ERROR("compile time constant regex failed.");
while ((line_len = getline (&line, &line_size, input)) != -1) {
regmatch_t match[3];
char *message_id, *file_tags;
chomp_newline (line);
rerr = xregexec (®ex, line, 3, match, 0);
if (rerr == REG_NOMATCH)
{
fprintf (stderr, "Warning: Ignoring invalid input line: %s\n",
line);
continue;
}
message_id = xstrndup (line + match[1].rm_so,
match[1].rm_eo - match[1].rm_so);
file_tags = xstrndup (line + match[2].rm_so,
match[2].rm_eo - match[2].rm_so);
tag_message (notmuch, message_id, file_tags, !accumulate,
synchronize_flags);
free (message_id);
free (file_tags);
}
regfree (®ex);
if (line)
free (line);
notmuch_database_destroy (notmuch);
if (input != stdin)
fclose (input);
return 0;
}
tag_parse_status_t
parse_tag_line (void *ctx, char *line,
tag_op_flag_t flags,
char **query_string,
tag_op_list_t *tag_ops)
{
char *tok = line;
size_t tok_len = 0;
char *line_for_error;
tag_parse_status_t ret = TAG_PARSE_SUCCESS;
chomp_newline (line);
line_for_error = talloc_strdup (ctx, line);
if (line_for_error == NULL) {
fprintf (stderr, "Error: out of memory\n");
return TAG_PARSE_OUT_OF_MEMORY;
}
/* remove leading space */
while (*tok == ' ' || *tok == '\t')
tok++;
/* Skip empty and comment lines. */
if (*tok == '\0' || *tok == '#') {
ret = TAG_PARSE_SKIPPED;
goto DONE;
}
tag_op_list_reset (tag_ops);
/* Parse tags. */
while ((tok = strtok_len (tok + tok_len, " ", &tok_len)) != NULL) {
notmuch_bool_t remove;
char *tag;
/* Optional explicit end of tags marker. */
if (tok_len == 2 && strncmp (tok, "--", tok_len) == 0) {
tok = strtok_len (tok + tok_len, " ", &tok_len);
if (tok == NULL) {
ret = line_error (TAG_PARSE_INVALID, line_for_error,
"no query string after --");
goto DONE;
}
break;
}
/* Implicit end of tags. */
if (*tok != '-' && *tok != '+')
break;
/* If tag is terminated by NUL, there's no query string. */
if (*(tok + tok_len) == '\0') {
ret = line_error (TAG_PARSE_INVALID, line_for_error,
"no query string");
goto DONE;
}
/* Terminate, and start next token after terminator. */
*(tok + tok_len++) = '\0';
remove = (*tok == '-');
tag = tok + 1;
/* Maybe refuse illegal tags. */
if (! (flags & TAG_FLAG_BE_GENEROUS)) {
const char *msg = illegal_tag (tag, remove);
if (msg) {
ret = line_error (TAG_PARSE_INVALID, line_for_error, msg);
goto DONE;
}
}
/* Decode tag. */
if (hex_decode_inplace (tag) != HEX_SUCCESS) {
ret = line_error (TAG_PARSE_INVALID, line_for_error,
"hex decoding of tag %s failed", tag);
goto DONE;
}
if (tag_op_list_append (tag_ops, tag, remove)) {
ret = line_error (TAG_PARSE_OUT_OF_MEMORY, line_for_error,
"aborting");
goto DONE;
}
}
if (tok == NULL) {
/* use a different error message for testing */
ret = line_error (TAG_PARSE_INVALID, line_for_error,
"missing query string");
goto DONE;
}
/* tok now points to the query string */
*query_string = tok;
DONE:
talloc_free (line_for_error);
return ret;
}
