#include "notmuch-client.h"
#include "gmime-filter-reply.h"
#include "sprinter.h"
+#include "zlib-extra.h"
static const char *
_get_tags_as_string (const void *ctx, notmuch_message_t *message)
for (tags = notmuch_message_get_tags (message);
notmuch_tags_valid (tags);
- notmuch_tags_move_to_next (tags))
- {
+ notmuch_tags_move_to_next (tags)) {
tag = notmuch_tags_get (tags);
result = talloc_asprintf_append (result, "%s%s",
from, relative_date, tags);
}
-static const char *_get_disposition(GMimeObject *meta)
+static const char *
+_get_disposition (GMimeObject *meta)
{
GMimeContentDisposition *disposition;
disposition = g_mime_object_get_content_disposition (meta);
- if (!disposition)
+ if (! disposition)
return NULL;
return g_mime_content_disposition_get_disposition (disposition);
InternetAddressMailbox *mailbox;
const char *email = "MAILER-DAEMON";
- addresses = internet_address_list_parse_string (from);
+ addresses = internet_address_list_parse (NULL, from);
/* Bail if there is no address here. */
if (addresses == NULL || internet_address_list_length (addresses) < 1)
g_object_unref (addresses);
return email;
- }
+}
/* Return 1 if 'line' is an mbox From_ line---that is, a line
* beginning with zero or more '>' characters followed by the
void
format_headers_sprinter (sprinter_t *sp, GMimeMessage *message,
- bool reply)
+ bool reply, const _notmuch_message_crypto_t *msg_crypto)
{
/* Any changes to the JSON or S-Expression format should be
* reflected in the file devel/schemata. */
sp->begin_map (sp);
sp->map_key (sp, "Subject");
- sp->string (sp, g_mime_message_get_subject (message));
+ if (msg_crypto && msg_crypto->payload_subject) {
+ sp->string (sp, msg_crypto->payload_subject);
+ } else
+ sp->string (sp, g_mime_message_get_subject (message));
sp->map_key (sp, "From");
sp->string (sp, g_mime_message_get_from_string (message));
if (! g_mime_content_type_is_type (content_type, "text", "*"))
INTERNAL_ERROR ("Illegal request to format non-text part (%s) as text.",
- g_mime_content_type_to_string (content_type));
+ g_mime_content_type_get_mime_type (content_type));
if (stream_out == NULL)
return;
charset = g_mime_object_get_content_type_parameter (part, "charset");
charset = charset ? g_mime_charset_canon_name (charset) : NULL;
- wrapper = g_mime_part_get_content_object (GMIME_PART (part));
- if (wrapper && charset && !g_ascii_strncasecmp (charset, "iso-8859-", 9)) {
+ wrapper = g_mime_part_get_content (GMIME_PART (part));
+ if (wrapper && charset && ! g_ascii_strncasecmp (charset, "iso-8859-", 9)) {
GMimeStream *null_stream = NULL;
GMimeStream *null_stream_filter = NULL;
null_stream = g_mime_stream_null_new ();
null_stream_filter = g_mime_stream_filter_new (null_stream);
windows_filter = g_mime_filter_windows_new (charset);
- g_mime_stream_filter_add(GMIME_STREAM_FILTER (null_stream_filter),
- windows_filter);
+ g_mime_stream_filter_add (GMIME_STREAM_FILTER (null_stream_filter),
+ windows_filter);
g_mime_data_wrapper_write_to_stream (wrapper, null_stream_filter);
- charset = g_mime_filter_windows_real_charset(
+ charset = g_mime_filter_windows_real_charset (
(GMimeFilterWindows *) windows_filter);
if (null_stream_filter)
}
stream_filter = g_mime_stream_filter_new (stream_out);
- crlf_filter = g_mime_filter_crlf_new (false, false);
- g_mime_stream_filter_add(GMIME_STREAM_FILTER (stream_filter),
- crlf_filter);
+ crlf_filter = g_mime_filter_dos2unix_new (false);
+ g_mime_stream_filter_add (GMIME_STREAM_FILTER (stream_filter),
+ crlf_filter);
g_object_unref (crlf_filter);
if (charset) {
if (wrapper && stream_filter)
g_mime_data_wrapper_write_to_stream (wrapper, stream_filter);
if (stream_filter)
- g_object_unref(stream_filter);
+ g_object_unref (stream_filter);
if (windows_filter)
g_object_unref (windows_filter);
}
-static const char*
+static const char *
signature_status_to_string (GMimeSignatureStatus status)
{
if (g_mime_signature_status_bad (status))
/* Print signature flags */
struct key_map_struct {
- GMimeSignatureError bit;
- const char * string;
+ GMimeSignatureStatus bit;
+ const char *string;
};
static void
do_format_signature_errors (sprinter_t *sp, struct key_map_struct *key_map,
- unsigned int array_map_len, GMimeSignatureError errors) {
+ unsigned int array_map_len, GMimeSignatureStatus errors)
+{
sp->map_key (sp, "errors");
sp->begin_map (sp);
static void
format_signature_errors (sprinter_t *sp, GMimeSignature *signature)
{
- GMimeSignatureError errors = g_mime_signature_get_errors (signature);
+ GMimeSignatureStatus errors = g_mime_signature_get_status (signature);
- if (!(errors & GMIME_SIGNATURE_STATUS_ERROR_MASK))
+ if (! (errors & GMIME_SIGNATURE_STATUS_ERROR_MASK))
return;
struct key_map_struct key_map[] = {
- { GMIME_SIGNATURE_STATUS_KEY_REVOKED, "key-revoked"},
- { GMIME_SIGNATURE_STATUS_KEY_EXPIRED, "key-expired"},
+ { GMIME_SIGNATURE_STATUS_KEY_REVOKED, "key-revoked" },
+ { GMIME_SIGNATURE_STATUS_KEY_EXPIRED, "key-expired" },
{ GMIME_SIGNATURE_STATUS_SIG_EXPIRED, "sig-expired" },
- { GMIME_SIGNATURE_STATUS_KEY_MISSING, "key-missing"},
- { GMIME_SIGNATURE_STATUS_CRL_MISSING, "crl-missing"},
- { GMIME_SIGNATURE_STATUS_CRL_TOO_OLD, "crl-too-old"},
- { GMIME_SIGNATURE_STATUS_BAD_POLICY, "bad-policy"},
- { GMIME_SIGNATURE_STATUS_SYS_ERROR, "sys-error"},
- { GMIME_SIGNATURE_STATUS_TOFU_CONFLICT, "tofu-conflict"},
+ { GMIME_SIGNATURE_STATUS_KEY_MISSING, "key-missing" },
+ { GMIME_SIGNATURE_STATUS_CRL_MISSING, "crl-missing" },
+ { GMIME_SIGNATURE_STATUS_CRL_TOO_OLD, "crl-too-old" },
+ { GMIME_SIGNATURE_STATUS_BAD_POLICY, "bad-policy" },
+ { GMIME_SIGNATURE_STATUS_SYS_ERROR, "sys-error" },
+ { GMIME_SIGNATURE_STATUS_TOFU_CONFLICT, "tofu-conflict" },
};
- do_format_signature_errors (sp, key_map, ARRAY_SIZE(key_map), errors);
+ do_format_signature_errors (sp, key_map, ARRAY_SIZE (key_map), errors);
}
/* Signature status sprinter */
sp->begin_list (sp);
- if (!siglist) {
+ if (! siglist) {
sp->end (sp);
return;
}
}
if (notmuch_format_version <= 3) {
- GMimeSignatureError errors = g_mime_signature_get_errors (signature);
+ GMimeSignatureStatus errors = g_mime_signature_get_status (signature);
if (g_mime_signature_status_error (errors)) {
sp->map_key (sp, "errors");
sp->integer (sp, errors);
}
sp->end (sp);
- }
+ }
sp->end (sp);
}
{
/* 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;
+ GMimeObject *meta = node->envelope_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;
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;
+ const char *filename = leaf ? (
+ g_mime_part_get_filename (GMIME_PART (node->part)) ) : NULL;
if (disposition &&
strcasecmp (disposition, GMIME_DISPOSITION_ATTACHMENT) == 0)
if (cid)
g_mime_stream_printf (stream, ", Content-id: %s", cid);
- content_string = g_mime_content_type_to_string (content_type);
+ content_string = g_mime_content_type_get_mime_type (content_type);
g_mime_stream_printf (stream, ", Content-type: %s\n", content_string);
g_free (content_string);
}
g_mime_stream_printf (stream, "Date: %s\n", date_string);
g_mime_stream_printf (stream, "\fheader}\n");
- if (!params->output_body)
- {
+ if (! params->output_body) {
g_mime_stream_printf (stream, "\f%s}\n", part_type);
return NOTMUCH_STATUS_SUCCESS;
}
if (leaf) {
if (g_mime_content_type_is_type (content_type, "text", "*") &&
(params->include_html ||
- ! g_mime_content_type_is_type (content_type, "text", "html")))
- {
+ ! g_mime_content_type_is_type (content_type, "text", "html"))) {
show_text_part_content (node->part, stream, 0);
} else {
- char *content_string = g_mime_content_type_to_string (content_type);
+ char *content_string = g_mime_content_type_get_mime_type (content_type);
g_mime_stream_printf (stream, "Non-text part: %s\n", content_string);
g_free (content_string);
}
{
const char *content_charset = g_mime_object_get_content_type_parameter (meta, "charset");
const char *cte = g_mime_object_get_header (meta, "content-transfer-encoding");
- GMimeDataWrapper *wrapper = g_mime_part_get_content_object (part);
+ GMimeDataWrapper *wrapper = g_mime_part_get_content (part);
GMimeStream *stream = g_mime_data_wrapper_get_stream (wrapper);
ssize_t content_length = g_mime_stream_length (stream);
* reflected in the file devel/schemata. */
if (node->envelope_file) {
+ const _notmuch_message_crypto_t *msg_crypto = NULL;
sp->begin_map (sp);
format_message_sprinter (sp, node->envelope_file);
- sp->map_key (sp, "headers");
- format_headers_sprinter (sp, GMIME_MESSAGE (node->part), false);
-
if (output_body) {
sp->map_key (sp, "body");
sp->begin_list (sp);
format_part_sprinter (ctx, sp, mime_node_child (node, 0), true, include_html);
sp->end (sp);
}
+
+ msg_crypto = mime_node_get_message_crypto_status (node);
+ if (notmuch_format_version >= 4) {
+ sp->map_key (sp, "crypto");
+ sp->begin_map (sp);
+ if (msg_crypto->sig_list ||
+ msg_crypto->decryption_status != NOTMUCH_MESSAGE_DECRYPTED_NONE) {
+ if (msg_crypto->sig_list) {
+ sp->map_key (sp, "signed");
+ sp->begin_map (sp);
+ sp->map_key (sp, "status");
+ format_part_sigstatus_sprinter (sp, msg_crypto->sig_list);
+ if (msg_crypto->signature_encrypted) {
+ sp->map_key (sp, "encrypted");
+ sp->boolean (sp, msg_crypto->signature_encrypted);
+ }
+ if (msg_crypto->payload_subject) {
+ sp->map_key (sp, "headers");
+ sp->begin_list (sp);
+ sp->string (sp, "Subject");
+ sp->end (sp);
+ }
+ sp->end (sp);
+ }
+ if (msg_crypto->decryption_status != NOTMUCH_MESSAGE_DECRYPTED_NONE) {
+ 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");
+
+ if (msg_crypto->payload_subject) {
+ const char *subject = g_mime_message_get_subject GMIME_MESSAGE (node->part);
+ if (subject == NULL || strcmp (subject, msg_crypto->payload_subject)) {
+ /* protected subject differs from the external header */
+ sp->map_key (sp, "header-mask");
+ sp->begin_map (sp);
+ sp->map_key (sp, "Subject");
+ if (subject == NULL)
+ sp->null (sp);
+ else
+ sp->string (sp, subject);
+ sp->end (sp);
+ }
+ }
+ sp->end (sp);
+ }
+ }
+ sp->end (sp);
+ }
+
+ sp->map_key (sp, "headers");
+ format_headers_sprinter (sp, GMIME_MESSAGE (node->part), false, msg_crypto);
+
sp->end (sp);
return;
}
/* 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;
+ GMimeObject *meta = node->envelope_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);
const char *cid = g_mime_object_get_content_id (meta);
- const char *filename = GMIME_IS_PART (node->part) ?
- g_mime_part_get_filename (GMIME_PART (node->part)) : NULL;
+ const char *filename = GMIME_IS_PART (node->part) ? (
+ g_mime_part_get_filename (GMIME_PART (node->part) ) ) : NULL;
int nclose = 0;
int i;
}
sp->map_key (sp, "content-type");
- content_string = g_mime_content_type_to_string (content_type);
+ content_string = g_mime_content_type_get_mime_type (content_type);
sp->string (sp, content_string);
g_free (content_string);
*/
if (g_mime_content_type_is_type (content_type, "text", "*") &&
(include_html ||
- ! g_mime_content_type_is_type (content_type, "text", "html")))
- {
+ ! g_mime_content_type_is_type (content_type, "text", "html"))) {
GMimeStream *stream_memory = g_mime_stream_mem_new ();
GByteArray *part_content;
show_text_part_content (node->part, stream_memory, 0);
sp->begin_map (sp);
sp->map_key (sp, "headers");
- format_headers_sprinter (sp, GMIME_MESSAGE (node->part), false);
+ format_headers_sprinter (sp, GMIME_MESSAGE (node->part), false, NULL);
sp->map_key (sp, "body");
sp->begin_list (sp);
notmuch_message_t *message = node->envelope_file;
const char *filename;
- FILE *file;
+ gzFile file;
const char *from;
time_t date;
char date_asctime[26];
char *line = NULL;
- size_t line_size;
+ ssize_t line_size;
ssize_t line_len;
- if (!message)
+ if (! message)
INTERNAL_ERROR ("format_part_mbox requires a root part");
filename = notmuch_message_get_filename (message);
- file = fopen (filename, "r");
+ file = gzopen (filename, "r");
if (file == NULL) {
fprintf (stderr, "Failed to open %s: %s\n",
filename, strerror (errno));
printf ("From %s %s", from, date_asctime);
- while ((line_len = getline (&line, &line_size, file)) != -1 ) {
+ while ((line_len = gz_getline (message, &line, &line_size, file)) != UTIL_EOF ) {
if (_is_from_line (line))
putchar ('>');
printf ("%s", line);
printf ("\n");
- fclose (file);
+ gzclose (file);
return NOTMUCH_STATUS_SUCCESS;
}
if (node->envelope_file) {
/* Special case the entire message to avoid MIME parsing. */
const char *filename;
- FILE *file;
- size_t size;
+ GMimeStream *stream = NULL;
+ ssize_t ssize;
char buf[4096];
+ notmuch_status_t ret = NOTMUCH_STATUS_FILE_ERROR;
filename = notmuch_message_get_filename (node->envelope_file);
if (filename == NULL) {
fprintf (stderr, "Error: Cannot get message filename.\n");
- return NOTMUCH_STATUS_FILE_ERROR;
+ goto DONE;
}
- file = fopen (filename, "r");
- if (file == NULL) {
+ stream = g_mime_stream_gzfile_open (filename);
+ if (stream == NULL) {
fprintf (stderr, "Error: Cannot open file %s: %s\n", filename, strerror (errno));
- return NOTMUCH_STATUS_FILE_ERROR;
+ goto DONE;
}
- while (!feof (file)) {
- size = fread (buf, 1, sizeof (buf), file);
- if (ferror (file)) {
+ while (! g_mime_stream_eos (stream)) {
+ ssize = g_mime_stream_read (stream, buf, sizeof (buf));
+ if (ssize < 0) {
fprintf (stderr, "Error: Read failed from %s\n", filename);
- fclose (file);
- return NOTMUCH_STATUS_FILE_ERROR;
+ goto DONE;
}
- if (fwrite (buf, size, 1, stdout) != 1) {
- fprintf (stderr, "Error: Write failed\n");
- fclose (file);
- return NOTMUCH_STATUS_FILE_ERROR;
+ if (ssize > 0 && fwrite (buf, ssize, 1, stdout) != 1) {
+ fprintf (stderr, "Error: Write %ld chars to stdout failed\n", ssize);
+ goto DONE;
}
}
- fclose (file);
- return NOTMUCH_STATUS_SUCCESS;
+ ret = NOTMUCH_STATUS_SUCCESS;
+
+ /* XXX This DONE is just for the special case of a node in a single file */
+ DONE:
+ if (stream)
+ g_object_unref (stream);
+
+ return ret;
}
GMimeStream *stream_filter = g_mime_stream_filter_new (params->out_stream);
/* For leaf parts, we emit only the transfer-decoded
* body. */
GMimeDataWrapper *wrapper;
- wrapper = g_mime_part_get_content_object (GMIME_PART (node->part));
+ wrapper = g_mime_part_get_content (GMIME_PART (node->part));
if (wrapper && stream_filter)
g_mime_data_wrapper_write_to_stream (wrapper, stream_filter);
* encapsulating part's headers). For multipart parts,
* this will include the headers. */
if (stream_filter)
- g_mime_object_write_to_stream (node->part, stream_filter);
+ g_mime_object_write_to_stream (node->part, NULL, stream_filter);
}
if (stream_filter)
part = mime_node_seek_dfs (root, (params->part < 0 ? 0 : params->part));
if (part)
status = format->part (local, sp, part, indent, params);
-#if HAVE_GMIME_SESSION_KEYS
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 &&
}
}
}
-#endif
DONE:
talloc_free (local);
return status;
for (;
notmuch_messages_valid (messages);
- notmuch_messages_move_to_next (messages))
- {
+ notmuch_messages_move_to_next (messages)) {
sp->begin_list (sp);
message = notmuch_messages_get (messages);
next_indent = indent;
- if ((match && (!excluded || !params->omit_excluded)) || params->entire_thread) {
+ if ((match && (! excluded || ! params->omit_excluded)) || params->entire_thread) {
status = show_message (ctx, format, sp, message, indent, params);
- if (status && !res)
+ if (status && ! res)
res = status;
next_indent = indent + 1;
} else {
notmuch_message_get_replies (message),
next_indent,
params);
- if (status && !res)
+ if (status && ! res)
res = status;
notmuch_message_destroy (message);
notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH, 1);
return show_message (ctx, format, sp, message, 0, params)
- != NOTMUCH_STATUS_SUCCESS;
+ != NOTMUCH_STATUS_SUCCESS;
}
/* 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;
notmuch_messages_t *messages;
notmuch_status_t status, res = NOTMUCH_STATUS_SUCCESS;
- status= notmuch_query_search_threads (query, &threads);
+ status = notmuch_query_search_threads (query, &threads);
if (print_status_query ("notmuch show", query, status))
return 1;
sp->begin_list (sp);
- for ( ;
+ for (;
notmuch_threads_valid (threads);
- notmuch_threads_move_to_next (threads))
- {
+ notmuch_threads_move_to_next (threads)) {
thread = notmuch_threads_get (threads);
messages = notmuch_thread_get_toplevel_messages (thread);
notmuch_thread_get_thread_id (thread));
status = show_messages (ctx, format, sp, messages, 0, params);
- if (status && !res)
+ if (status && ! res)
res = status;
notmuch_thread_destroy (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 = notmuch_message_get_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,
bool exclude = true;
bool entire_thread_set = false;
bool single_message;
+ bool unthreaded = FALSE;
notmuch_opt_desc_t options[] = {
{ .opt_keyword = &format, .name = "format", .keywords =
- (notmuch_keyword_t []){ { "json", NOTMUCH_FORMAT_JSON },
- { "text", NOTMUCH_FORMAT_TEXT },
- { "sexp", NOTMUCH_FORMAT_SEXP },
- { "mbox", NOTMUCH_FORMAT_MBOX },
- { "raw", NOTMUCH_FORMAT_RAW },
- { 0, 0 } } },
+ (notmuch_keyword_t []){ { "json", NOTMUCH_FORMAT_JSON },
+ { "text", NOTMUCH_FORMAT_TEXT },
+ { "sexp", NOTMUCH_FORMAT_SEXP },
+ { "mbox", NOTMUCH_FORMAT_MBOX },
+ { "raw", NOTMUCH_FORMAT_RAW },
+ { 0, 0 } } },
{ .opt_int = ¬much_format_version, .name = "format-version" },
{ .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",
+ { .opt_keyword = (int *) (¶ms.crypto.decrypt), .name = "decrypt",
.keyword_no_arg_value = "true", .keywords =
- (notmuch_keyword_t []){ { "false", NOTMUCH_DECRYPT_FALSE },
- { "auto", NOTMUCH_DECRYPT_AUTO },
- { "true", NOTMUCH_DECRYPT_NOSTASH },
- { "stash", NOTMUCH_DECRYPT_TRUE },
- { 0, 0 } } },
+ (notmuch_keyword_t []){ { "false", NOTMUCH_DECRYPT_FALSE },
+ { "auto", NOTMUCH_DECRYPT_AUTO },
+ { "true", NOTMUCH_DECRYPT_NOSTASH },
+ { "stash", NOTMUCH_DECRYPT_TRUE },
+ { 0, 0 } } },
{ .opt_bool = ¶ms.crypto.verify, .name = "verify" },
{ .opt_bool = ¶ms.output_body, .name = "body" },
{ .opt_bool = ¶ms.include_html, .name = "include-html" },
(format == NOTMUCH_FORMAT_JSON || format == NOTMUCH_FORMAT_SEXP))
params.entire_thread = true;
- if (!params.output_body) {
+ if (! params.output_body) {
if (params.part > 0) {
fprintf (stderr, "Warning: --body=false is incompatible with --part > 0. Disabling.\n");
params.output_body = true;
}
if (params.include_html &&
- (format != NOTMUCH_FORMAT_TEXT &&
+ (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");
}
- query_string = query_string_from_args (config, argc-opt_index, argv+opt_index);
+ query_string = query_string_from_args (config, argc - opt_index, argv + opt_index);
if (query_string == NULL) {
fprintf (stderr, "Out of memory\n");
return EXIT_FAILURE;
return EXIT_FAILURE;
}
-#if (GMIME_MAJOR_VERSION < 3)
- params.crypto.gpgpath = notmuch_config_get_crypto_gpg_path (config);
-#endif
-
notmuch_database_mode_t mode = NOTMUCH_DATABASE_MODE_READ_ONLY;
if (params.crypto.decrypt == NOTMUCH_DECRYPT_TRUE)
mode = NOTMUCH_DATABASE_MODE_READ_WRITE;
/* Create structure printer. */
formatter = formatters[format];
- sprinter = formatter->new_sprinter(config, stdout);
+ sprinter = formatter->new_sprinter (config, stdout);
params.out_stream = g_mime_stream_stdout_new ();
notmuch_status_t status;
search_exclude_tags = notmuch_config_get_search_exclude_tags
- (config, &search_exclude_tags_length);
+ (config, &search_exclude_tags_length);
for (i = 0; i < search_exclude_tags_length; i++) {
status = notmuch_query_add_tag_exclude (query, search_exclude_tags[i]);
params.omit_excluded = false;
}
- ret = do_show (config, query, formatter, sprinter, ¶ms);
+ if (unthreaded)
+ ret = do_show_unthreaded (config, query, formatter, sprinter, ¶ms);
+ else
+ ret = do_show_threaded (config, query, formatter, sprinter, ¶ms);
}
- DONE:
+ DONE:
g_mime_stream_flush (params.out_stream);
g_object_unref (params.out_stream);
projects / notmuch / blobdiff