#include "notmuch-client.h"
#include "hex-escape.h"
#include "string-util.h"
-#include <zlib.h>
+#include "zlib-extra.h"
static int
database_dump_config (notmuch_database_t *notmuch, gzFile output)
notmuch_config_list_key (list));
goto DONE;
}
- gzprintf (output, "#@ %s", buffer);
+ GZPRINTF (output, "#@ %s", buffer);
if (hex_encode (notmuch, notmuch_config_list_value (list),
&buffer, &buffer_size) != HEX_SUCCESS) {
goto DONE;
}
- gzprintf (output, " %s\n", buffer);
+ GZPUTS (output, " ");
+ GZPUTS (output, buffer);
+ GZPUTS (output, "\n");
}
ret = EXIT_SUCCESS;
- DONE:
+ DONE:
if (list)
notmuch_config_list_destroy (list);
static void
print_dump_header (gzFile output, int output_format, int include)
{
- gzprintf (output, "#notmuch-dump %s:%d %s%s%s\n",
+ const char *sep = "";
+
+ GZPRINTF (output, "#notmuch-dump %s:%d ",
(output_format == DUMP_FORMAT_SUP) ? "sup" : "batch-tag",
- NOTMUCH_DUMP_VERSION,
- (include & DUMP_INCLUDE_CONFIG) ? "config" : "",
- (include & DUMP_INCLUDE_TAGS) && (include & DUMP_INCLUDE_CONFIG) ? "," : "",
- (include & DUMP_INCLUDE_TAGS) ? "tags" : "");
+ NOTMUCH_DUMP_VERSION);
+
+ if (include & DUMP_INCLUDE_CONFIG) {
+ GZPUTS (output, "config");
+ sep = ",";
+ }
+ if (include & DUMP_INCLUDE_PROPERTIES) {
+ GZPRINTF (output, "%sproperties", sep);
+ sep = ",";
+ }
+ if (include & DUMP_INCLUDE_TAGS) {
+ GZPRINTF (output, "%stags", sep);
+ }
+ GZPUTS (output, "\n");
+}
+
+static int
+dump_properties_message (void *ctx,
+ notmuch_message_t *message,
+ gzFile output,
+ char **buffer_p, size_t *size_p)
+{
+ const char *message_id;
+ notmuch_message_properties_t *list;
+ bool first = true;
+
+ message_id = notmuch_message_get_message_id (message);
+
+ if (strchr (message_id, '\n')) {
+ fprintf (stderr, "Warning: skipping message id containing line break: \"%s\"\n", message_id);
+ return 0;
+ }
+
+ for (list = notmuch_message_get_properties (message, "", false);
+ notmuch_message_properties_valid (list); notmuch_message_properties_move_to_next (list)) {
+ const char *key, *val;
+
+ if (first) {
+ if (hex_encode (ctx, message_id, buffer_p, size_p) != HEX_SUCCESS) {
+ fprintf (stderr, "Error: failed to hex-encode message-id %s\n", message_id);
+ return 1;
+ }
+ GZPRINTF (output, "#= %s", *buffer_p);
+ first = false;
+ }
+
+ key = notmuch_message_properties_key (list);
+ val = notmuch_message_properties_value (list);
+
+ if (hex_encode (ctx, key, buffer_p, size_p) != HEX_SUCCESS) {
+ fprintf (stderr, "Error: failed to hex-encode key %s\n", key);
+ return 1;
+ }
+ GZPRINTF (output, " %s", *buffer_p);
+
+ if (hex_encode (ctx, val, buffer_p, size_p) != HEX_SUCCESS) {
+ fprintf (stderr, "Error: failed to hex-encode value %s\n", val);
+ return 1;
+ }
+ GZPRINTF (output, "=%s", *buffer_p);
+ }
+ notmuch_message_properties_destroy (list);
+
+ if (! first)
+ GZPRINTF (output, "\n", *buffer_p);
+
+ return 0;
}
static int
}
if (output_format == DUMP_FORMAT_SUP) {
- gzprintf (output, "%s (", message_id);
+ GZPRINTF (output, "%s (", message_id);
}
for (notmuch_tags_t *tags = notmuch_message_get_tags (message);
const char *tag_str = notmuch_tags_get (tags);
if (! first)
- gzputs (output, " ");
+ GZPUTS (output, " ");
first = 0;
if (output_format == DUMP_FORMAT_SUP) {
- gzputs (output, tag_str);
+ GZPUTS (output, tag_str);
} else {
if (hex_encode (ctx, tag_str,
buffer_p, size_p) != HEX_SUCCESS) {
tag_str);
return EXIT_FAILURE;
}
- gzprintf (output, "+%s", *buffer_p);
+ GZPRINTF (output, "+%s", *buffer_p);
}
}
if (output_format == DUMP_FORMAT_SUP) {
- gzputs (output, ")\n");
+ GZPUTS (output, ")\n");
} else {
if (make_boolean_term (ctx, "id", message_id,
buffer_p, size_p)) {
message_id, strerror (errno));
return EXIT_FAILURE;
}
- gzprintf (output, " -- %s\n", *buffer_p);
+ GZPRINTF (output, " -- %s\n", *buffer_p);
}
return EXIT_SUCCESS;
}
if (include & DUMP_INCLUDE_CONFIG) {
if (print_status_database ("notmuch dump", notmuch,
- database_dump_config(notmuch,output)))
+ database_dump_config (notmuch, output)))
return EXIT_FAILURE;
}
- if (! (include & DUMP_INCLUDE_TAGS))
+ if (! (include & (DUMP_INCLUDE_TAGS | DUMP_INCLUDE_PROPERTIES)))
return EXIT_SUCCESS;
if (! query_str)
*/
notmuch_query_set_sort (query, NOTMUCH_SORT_UNSORTED);
- status = notmuch_query_search_messages_st (query, &messages);
+ status = notmuch_query_search_messages (query, &messages);
if (print_status_query ("notmuch dump", query, status))
return EXIT_FAILURE;
message = notmuch_messages_get (messages);
- if (dump_tags_message (notmuch, message, output_format, output,
+ if ((include & DUMP_INCLUDE_TAGS) &&
+ dump_tags_message (notmuch, message, output_format, output,
&buffer, &buffer_size))
return EXIT_FAILURE;
+ if ((include & DUMP_INCLUDE_PROPERTIES) &&
+ dump_properties_message (notmuch, message, output,
+ &buffer, &buffer_size))
+ return EXIT_FAILURE;
+
notmuch_message_destroy (message);
}
const char *query_str,
dump_format_t output_format,
dump_include_t include,
- notmuch_bool_t gzip_output)
+ bool gzip_output)
{
gzFile output = NULL;
const char *mode = gzip_output ? "w9" : "wT";
name_for_error, strerror (errno));
if (close (outfd))
fprintf (stderr, "Error closing %s during shutdown: %s\n",
- name_for_error, strerror (errno));
+ name_for_error, strerror (errno));
goto DONE;
}
ret = gzflush (output, Z_FINISH);
if (ret) {
- fprintf (stderr, "Error flushing output: %s\n", gzerror (output, NULL));
+ fprintf (stderr, "Error flushing output: %s\n", gzerror_str (output));
goto DONE;
}
}
}
- if (gzclose_w (output) != Z_OK) {
+ ret = gzclose_w (output);
+ if (ret) {
fprintf (stderr, "Error closing %s: %s\n", name_for_error,
- gzerror (output, NULL));
+ gzerror_str (output));
ret = EXIT_FAILURE;
output = NULL;
goto DONE;
- }
+ } else
+ output = NULL;
if (output_file_name) {
ret = rename (tempname, output_file_name);
}
}
- DONE:
+ DONE:
if (ret != EXIT_SUCCESS && output)
(void) gzclose_w (output);
notmuch_exit_if_unmatched_db_uuid (notmuch);
- char *output_file_name = NULL;
+ const char *output_file_name = NULL;
int opt_index;
int output_format = DUMP_FORMAT_BATCH_TAG;
int include = 0;
- notmuch_bool_t gzip_output = 0;
+ bool gzip_output = 0;
notmuch_opt_desc_t options[] = {
- { NOTMUCH_OPT_KEYWORD, &output_format, "format", 'f',
- (notmuch_keyword_t []){ { "sup", DUMP_FORMAT_SUP },
- { "batch-tag", DUMP_FORMAT_BATCH_TAG },
- { 0, 0 } } },
- { NOTMUCH_OPT_KEYWORD_FLAGS, &include, "include", 'I',
- (notmuch_keyword_t []){ { "config", DUMP_INCLUDE_CONFIG },
- { "tags", DUMP_INCLUDE_TAGS} } },
- { NOTMUCH_OPT_STRING, &output_file_name, "output", 'o', 0 },
- { NOTMUCH_OPT_BOOLEAN, &gzip_output, "gzip", 'z', 0 },
- { NOTMUCH_OPT_INHERIT, (void *) ¬much_shared_options, NULL, 0, 0 },
- { 0, 0, 0, 0, 0 }
+ { .opt_keyword = &output_format, .name = "format", .keywords =
+ (notmuch_keyword_t []){ { "sup", DUMP_FORMAT_SUP },
+ { "batch-tag", DUMP_FORMAT_BATCH_TAG },
+ { 0, 0 } } },
+ { .opt_flags = &include, .name = "include", .keywords =
+ (notmuch_keyword_t []){ { "config", DUMP_INCLUDE_CONFIG },
+ { "properties", DUMP_INCLUDE_PROPERTIES },
+ { "tags", DUMP_INCLUDE_TAGS } } },
+ { .opt_string = &output_file_name, .name = "output" },
+ { .opt_bool = &gzip_output, .name = "gzip" },
+ { .opt_inherit = notmuch_shared_options },
+ { }
};
opt_index = parse_arguments (argc, argv, options, 1);
notmuch_process_shared_options (argv[0]);
if (include == 0)
- include = DUMP_INCLUDE_CONFIG | DUMP_INCLUDE_TAGS;
+ include = DUMP_INCLUDE_CONFIG | DUMP_INCLUDE_TAGS | DUMP_INCLUDE_PROPERTIES;
if (opt_index < argc) {
query_str = query_string_from_args (notmuch, argc - opt_index, argv + opt_index);
projects / notmuch / blobdiff