return g_mime_content_disposition_get_disposition (disposition);
}
+static bool
+_get_message_flag (notmuch_message_t *message, notmuch_message_flag_t flag)
+{
+ notmuch_bool_t is_set;
+ notmuch_status_t status;
+
+ status = notmuch_message_get_flag_st (message, flag, &is_set);
+
+ if (print_status_message ("notmuch show", message, status))
+ INTERNAL_ERROR ("unexpected error getting message flag\n");
+
+ return is_set;
+}
+
/* Emit a sequence of key/value pairs for the metadata of message.
* The caller should begin a map before calling this. */
static void
sp->string (sp, notmuch_message_get_message_id (message));
sp->map_key (sp, "match");
- sp->boolean (sp, notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH));
+ sp->boolean (sp, _get_message_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH));
sp->map_key (sp, "excluded");
- sp->boolean (sp, notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED));
+ sp->boolean (sp, _get_message_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED));
sp->map_key (sp, "filename");
if (notmuch_format_version >= 3) {
return 0;
}
+/* Output extra headers if configured with the `show.extra_headers'
+ * configuration option
+ */
+static void
+format_extra_headers_sprinter (sprinter_t *sp, GMimeMessage *message)
+{
+ GMimeHeaderList *header_list = g_mime_object_get_header_list (GMIME_OBJECT (message));
+
+ for (notmuch_config_values_t *extra_headers = notmuch_config_get_values (
+ sp->notmuch, NOTMUCH_CONFIG_EXTRA_HEADERS);
+ notmuch_config_values_valid (extra_headers);
+ notmuch_config_values_move_to_next (extra_headers)) {
+ GMimeHeader *header;
+ const char *header_name = notmuch_config_values_get (extra_headers);
+
+ header = g_mime_header_list_get_header (header_list, header_name);
+ if (header == NULL)
+ continue;
+
+ sp->map_key (sp, g_mime_header_get_name (header));
+ sp->string (sp, g_mime_header_get_value (header));
+ }
+}
+
void
format_headers_sprinter (sprinter_t *sp, GMimeMessage *message,
bool reply, const _notmuch_message_crypto_t *msg_crypto)
sp->string (sp, g_mime_message_get_date_string (sp, message));
}
+ /* Output extra headers the user has configured, if any */
+ if (! reply)
+ format_extra_headers_sprinter (sp, message);
sp->end (sp);
talloc_free (local);
}
}
int i;
+
for (i = 0; i < g_mime_signature_list_length (siglist); i++) {
GMimeSignature *signature = g_mime_signature_list_get_signature (siglist, i);
sp->map_key (sp, "userid");
sp->string (sp, uid);
}
+ const char *email = g_mime_certificate_get_valid_email (certificate);
+ if (email) {
+ sp->map_key (sp, "email");
+ sp->string (sp, email);
+ }
}
} else if (certificate) {
const char *key_id = g_mime_certificate_get_fpr16 (certificate);
/* The disposition and content-type metadata are associated with
* the envelope for message parts */
GMimeObject *meta = node->envelope_part ? (
- GMIME_OBJECT (node->envelope_part) ) : node->part ;
+ GMIME_OBJECT (node->envelope_part) ) : node->part;
GMimeContentType *content_type = g_mime_object_get_content_type (meta);
const bool leaf = GMIME_IS_PART (node->part);
GMimeStream *stream = params->out_stream;
part_type,
notmuch_message_get_message_id (message),
indent,
- notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH) ? 1 : 0,
- notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED) ? 1 : 0,
+ _get_message_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH) ? 1 : 0,
+ _get_message_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED) ? 1 : 0,
notmuch_message_get_filename (message));
} else {
char *content_string;
const char *disposition = _get_disposition (meta);
const char *cid = g_mime_object_get_content_id (meta);
const char *filename = leaf ? (
- g_mime_part_get_filename (GMIME_PART (node->part)) ) : NULL ;
+ g_mime_part_get_filename (GMIME_PART (node->part)) ) : NULL;
if (disposition &&
strcasecmp (disposition, GMIME_DISPOSITION_ATTACHMENT) == 0)
sp->map_key (sp, "decrypted");
sp->begin_map (sp);
sp->map_key (sp, "status");
- sp->string (sp, msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL ? "full" : "partial");
+ sp->string (sp, msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL ?
+ "full" : "partial");
if (msg_crypto->payload_subject) {
const char *subject = g_mime_message_get_subject GMIME_MESSAGE (node->part);
/* The disposition and content-type metadata are associated with
* the envelope for message parts */
GMimeObject *meta = node->envelope_part ? (
- GMIME_OBJECT (node->envelope_part) ): node->part;
+ GMIME_OBJECT (node->envelope_part) ) : node->part;
GMimeContentType *content_type = g_mime_object_get_content_type (meta);
char *content_string;
const char *disposition = _get_disposition (meta);
sp->string_len (sp, (char *) part_content->data, part_content->len);
g_object_unref (stream_memory);
} else {
- format_omitted_part_meta_sprinter (sp, meta, GMIME_PART (node->part));
+ /* if we have a child part despite being a standard
+ * (non-multipart) MIME part, that means there is
+ * something to unwrap, which we will present in
+ * content: */
+ if (node->nchildren) {
+ sp->map_key (sp, "content");
+ sp->begin_list (sp);
+ nclose = 1;
+ } else
+ format_omitted_part_meta_sprinter (sp, meta, GMIME_PART (node->part));
}
} else if (GMIME_IS_MULTIPART (node->part)) {
sp->map_key (sp, "content");
}
if (ssize > 0 && fwrite (buf, ssize, 1, stdout) != 1) {
- fprintf (stderr, "Error: Write %ld chars to stdout failed\n", ssize);
+ fprintf (stderr, "Error: Write %zd chars to stdout failed\n", ssize);
goto DONE;
}
}
notmuch_status_t session_key_count_error = NOTMUCH_STATUS_SUCCESS;
if (params->crypto.decrypt == NOTMUCH_DECRYPT_TRUE)
- session_key_count_error = notmuch_message_count_properties (message, "session-key", &session_keys);
+ session_key_count_error = notmuch_message_count_properties (message, "session-key",
+ &session_keys);
status = mime_node_open (local, message, &(params->crypto), &root);
if (status)
part = mime_node_seek_dfs (root, (params->part < 0 ? 0 : params->part));
if (part)
status = format->part (local, sp, part, indent, params);
- if (params->crypto.decrypt == NOTMUCH_DECRYPT_TRUE && session_key_count_error == NOTMUCH_STATUS_SUCCESS) {
+ if (params->crypto.decrypt == NOTMUCH_DECRYPT_TRUE && session_key_count_error ==
+ NOTMUCH_STATUS_SUCCESS) {
unsigned int new_session_keys = 0;
- if (notmuch_message_count_properties (message, "session-key", &new_session_keys) == NOTMUCH_STATUS_SUCCESS &&
+ if (notmuch_message_count_properties (message, "session-key", &new_session_keys) ==
+ NOTMUCH_STATUS_SUCCESS &&
new_session_keys > session_keys) {
/* try a quiet re-indexing */
- notmuch_indexopts_t *indexopts = notmuch_database_get_default_indexopts (notmuch_message_get_database (message));
+ notmuch_indexopts_t *indexopts = notmuch_database_get_default_indexopts (
+ notmuch_message_get_database (message));
if (indexopts) {
notmuch_indexopts_set_decrypt_policy (indexopts, NOTMUCH_DECRYPT_AUTO);
print_status_message ("Error re-indexing message with --decrypt=stash",
}
}
}
- DONE :
+ DONE:
talloc_free (local);
return status;
}
message = notmuch_messages_get (messages);
- match = notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH);
- excluded = notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED);
+ match = _get_message_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH);
+ excluded = _get_message_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED);
next_indent = indent;
return 1;
if (count != 1) {
- fprintf (stderr, "Error: search term did not match precisely one message (matched %u messages).\n", count);
+ fprintf (stderr,
+ "Error: search term did not match precisely one message (matched %u messages).\n",
+ count);
return 1;
}
/* Formatted output of threads */
static int
-do_show (void *ctx,
- notmuch_query_t *query,
- const notmuch_show_format_t *format,
- sprinter_t *sp,
- notmuch_show_params_t *params)
+do_show_threaded (void *ctx,
+ notmuch_query_t *query,
+ const notmuch_show_format_t *format,
+ sprinter_t *sp,
+ notmuch_show_params_t *params)
{
notmuch_threads_t *threads;
notmuch_thread_t *thread;
return res != NOTMUCH_STATUS_SUCCESS;
}
+static int
+do_show_unthreaded (void *ctx,
+ notmuch_query_t *query,
+ const notmuch_show_format_t *format,
+ sprinter_t *sp,
+ notmuch_show_params_t *params)
+{
+ notmuch_messages_t *messages;
+ notmuch_message_t *message;
+ notmuch_status_t status, res = NOTMUCH_STATUS_SUCCESS;
+ notmuch_bool_t excluded;
+
+ status = notmuch_query_search_messages (query, &messages);
+ if (print_status_query ("notmuch show", query, status))
+ return 1;
+
+ sp->begin_list (sp);
+
+ for (;
+ notmuch_messages_valid (messages);
+ notmuch_messages_move_to_next (messages)) {
+ sp->begin_list (sp);
+ sp->begin_list (sp);
+
+ message = notmuch_messages_get (messages);
+
+ notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH, TRUE);
+ excluded = _get_message_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED);
+
+ if (! excluded || ! params->omit_excluded) {
+ status = show_message (ctx, format, sp, message, 0, params);
+ if (status && ! res)
+ res = status;
+ } else {
+ sp->null (sp);
+ }
+ notmuch_message_destroy (message);
+ sp->end (sp);
+ sp->end (sp);
+ }
+ sp->end (sp);
+ return res;
+}
+
enum {
NOTMUCH_FORMAT_NOT_SPECIFIED,
NOTMUCH_FORMAT_JSON,
};
int
-notmuch_show_command (notmuch_config_t *config, int argc, char *argv[])
+notmuch_show_command (notmuch_database_t *notmuch, int argc, char *argv[])
{
- notmuch_database_t *notmuch;
notmuch_query_t *query;
char *query_string;
int opt_index, ret;
bool exclude = true;
bool entire_thread_set = false;
bool single_message;
+ bool unthreaded = FALSE;
+ notmuch_status_t status;
+ int sort = NOTMUCH_SORT_NEWEST_FIRST;
notmuch_opt_desc_t options[] = {
+ { .opt_keyword = &sort, .name = "sort", .keywords =
+ (notmuch_keyword_t []){ { "oldest-first", NOTMUCH_SORT_OLDEST_FIRST },
+ { "newest-first", NOTMUCH_SORT_NEWEST_FIRST },
+ { 0, 0 } } },
{ .opt_keyword = &format, .name = "format", .keywords =
(notmuch_keyword_t []){ { "json", NOTMUCH_FORMAT_JSON },
{ "text", NOTMUCH_FORMAT_TEXT },
{ .opt_bool = &exclude, .name = "exclude" },
{ .opt_bool = ¶ms.entire_thread, .name = "entire-thread",
.present = &entire_thread_set },
+ { .opt_bool = &unthreaded, .name = "unthreaded" },
{ .opt_int = ¶ms.part, .name = "part" },
{ .opt_keyword = (int *) (¶ms.crypto.decrypt), .name = "decrypt",
.keyword_no_arg_value = "true", .keywords =
if (opt_index < 0)
return EXIT_FAILURE;
- notmuch_process_shared_options (argv[0]);
+ notmuch_process_shared_options (notmuch, argv[0]);
/* explicit decryption implies verification */
if (params.crypto.decrypt == NOTMUCH_DECRYPT_NOSTASH ||
(format != NOTMUCH_FORMAT_TEXT &&
format != NOTMUCH_FORMAT_JSON &&
format != NOTMUCH_FORMAT_SEXP)) {
- fprintf (stderr, "Warning: --include-html only implemented for format=text, format=json and format=sexp\n");
+ fprintf (stderr,
+ "Warning: --include-html only implemented for format=text, format=json and format=sexp\n");
+ }
+
+ if (params.crypto.decrypt == NOTMUCH_DECRYPT_TRUE) {
+ status = notmuch_database_reopen (notmuch, NOTMUCH_DATABASE_MODE_READ_WRITE);
+ if (status) {
+ fprintf (stderr, "Error reopening database for READ_WRITE: %s\n",
+ notmuch_status_to_string (status));
+ return EXIT_FAILURE;
+ }
}
- query_string = query_string_from_args (config, argc - opt_index, argv + opt_index);
+ query_string = query_string_from_args (notmuch, argc - opt_index, argv + opt_index);
if (query_string == NULL) {
fprintf (stderr, "Out of memory\n");
return EXIT_FAILURE;
return EXIT_FAILURE;
}
- notmuch_database_mode_t mode = NOTMUCH_DATABASE_MODE_READ_ONLY;
- if (params.crypto.decrypt == NOTMUCH_DECRYPT_TRUE)
- mode = NOTMUCH_DATABASE_MODE_READ_WRITE;
- if (notmuch_database_open (notmuch_config_get_database_path (config),
- mode, ¬much))
+ status = notmuch_query_create_with_syntax (notmuch, query_string,
+ shared_option_query_syntax (),
+ &query);
+ if (print_status_database ("notmuch show", notmuch, status))
return EXIT_FAILURE;
- notmuch_exit_if_unmatched_db_uuid (notmuch);
-
- query = notmuch_query_create (notmuch, query_string);
- if (query == NULL) {
- fprintf (stderr, "Out of memory\n");
- return EXIT_FAILURE;
- }
+ notmuch_query_set_sort (query, sort);
/* Create structure printer. */
formatter = formatters[format];
- sprinter = formatter->new_sprinter (config, stdout);
+ sprinter = formatter->new_sprinter (notmuch, stdout);
params.out_stream = g_mime_stream_stdout_new ();
/* If a single message is requested we do not use search_excludes. */
if (single_message) {
- ret = do_show_single (config, query, formatter, sprinter, ¶ms);
+ ret = do_show_single (notmuch, query, formatter, sprinter, ¶ms);
} else {
/* We always apply set the exclude flag. The
* exclude=true|false option controls whether or not we return
* threads that only match in an excluded message */
- const char **search_exclude_tags;
- size_t search_exclude_tags_length;
- unsigned int i;
+ notmuch_config_values_t *exclude_tags;
notmuch_status_t status;
- search_exclude_tags = notmuch_config_get_search_exclude_tags
- (config, &search_exclude_tags_length);
+ for (exclude_tags = notmuch_config_get_values (notmuch, NOTMUCH_CONFIG_EXCLUDE_TAGS);
+ notmuch_config_values_valid (exclude_tags);
+ notmuch_config_values_move_to_next (exclude_tags)) {
- for (i = 0; i < search_exclude_tags_length; i++) {
- status = notmuch_query_add_tag_exclude (query, search_exclude_tags[i]);
+ status = notmuch_query_add_tag_exclude (query,
+ notmuch_config_values_get (exclude_tags));
if (status && status != NOTMUCH_STATUS_IGNORED) {
print_status_query ("notmuch show", query, status);
ret = -1;
params.omit_excluded = false;
}
- ret = do_show (config, query, formatter, sprinter, ¶ms);
+ if (unthreaded)
+ ret = do_show_unthreaded (notmuch, query, formatter, sprinter, ¶ms);
+ else
+ ret = do_show_threaded (notmuch, query, formatter, sprinter, ¶ms);
}
- DONE :
+ DONE:
g_mime_stream_flush (params.out_stream);
g_object_unref (params.out_stream);