debian/notmuch
1
0
Fork 0
mirror of https://git.notmuchmail.org/git/notmuch synced 2024-11-24 03:48:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
notmuch/notmuch-show.c

1139 lines
32 KiB
C
Raw Normal View History

notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
/* notmuch - Not much of an email program, (just index and search)
*
* Copyright © 2009 Carl Worth
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see http://www.gnu.org/licenses/ .
*
* Author: Carl Worth <cworth@cworth.org>
*/
#include "notmuch-client.h"
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
static void
format_headers_message_part_text (GMimeMessage *message);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
format_part_text (const void *ctx, mime_node_t *node,
int indent, const notmuch_show_params_t *params);
notmuch show: Properly nest MIME parts within mulipart parts Previously, notmuch show flattened all output, losing information about the nesting of the MIME hierarchy. Now, the output is properly nested, (both in the --format=text and --format=json output), so that clients can analyze the original MIME structure. Internally, this required splitting the final closing delimiter out of the various show_part functions and putting it into a new show_part_end function instead. Also, the show_part function now accepts a new "first" argument that is set not only for the first MIME part of a message, but also for each first MIME part within a series of multipart parts. This "first" argument controls the omission of a preceding comma when printing a part (for json). Many thanks to David Edmondson <dme@dme.org> for originally identifying the lack of nesting in the json output and submitting an early implementation of this feature. Thanks as well to Jameson Graef Rollins <jrollins@finestructure.net> for carefully shepherding David's patches through a remarkably long review process, patiently explaining them, and providing a cleaned up series that led to this final implementation. Jameson also provided the new emacs code here.
2011-05-18 00:34:57 +02:00
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
static const notmuch_show_format_t format_text = {
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
.message_set_start = "",
.part = format_part_text,
.message_set_sep = "",
.message_set_end = ""
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
};
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
format_part_json_entry (const void *ctx, mime_node_t *node,
int indent, const notmuch_show_params_t *params);
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
static const notmuch_show_format_t format_json = {
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
.message_set_start = "[",
.part = format_part_json_entry,
.message_set_sep = ", ",
.message_set_end = "]"
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
};
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
static notmuch_status_t
format_part_mbox (const void *ctx, mime_node_t *node,
int indent, const notmuch_show_params_t *params);
notmuch show: Add a --format=mbox option We don't love the mbox format, but it's still sometimes the most practical way to share a collection of messages as a single file. Here we implement the "mboxrd" variant of the mbox file format. This variant applies reversible escaping by prefixing a '>' character to all lines in the email messages matching the regular expression: "^>*From " This allows the escaping to be reliably removed. A reader should remove a '>' from any line matching the regular expression: "^>>*From " More details on the mboxrd formats (and others as well) can be found here: http://homepage.ntlworld.com/jonathan.deboynepollard/FGA/mail-mbox-formats.html
2010-06-09 04:45:54 +02:00
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
static const notmuch_show_format_t format_mbox = {
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
.message_set_start = "",
.part = format_part_mbox,
.message_set_sep = "",
.message_set_end = ""
notmuch show: Add a --format=mbox option We don't love the mbox format, but it's still sometimes the most practical way to share a collection of messages as a single file. Here we implement the "mboxrd" variant of the mbox file format. This variant applies reversible escaping by prefixing a '>' character to all lines in the email messages matching the regular expression: "^>*From " This allows the escaping to be reliably removed. A reader should remove a '>' from any line matching the regular expression: "^>>*From " More details on the mboxrd formats (and others as well) can be found here: http://homepage.ntlworld.com/jonathan.deboynepollard/FGA/mail-mbox-formats.html
2010-06-09 04:45:54 +02:00
};
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
static void
Break up format->part function into part_start and part_content functions. Future improvements (eg. crypto support) will require adding new part header. By breaking up the output of part headers from the output of part content, we can easily out new part headers with new formatting functions.
2011-05-26 03:01:13 +02:00
format_part_content_raw (GMimeObject *part);
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
static const notmuch_show_format_t format_raw = {
show: Introduce mime_node formatter callback This callback is the gateway to the new mime_node_t-based formatters. This maintains backwards compatibility so the formatters can be transitioned one at a time. Once all formatters are converted, the formatter structure can be reduced to only message_set_{start,sep,end} and part, most of show_message can be deleted, and all of show-message.c can be deleted.
2012-01-24 00:33:10 +01:00
"", NULL,
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
"", NULL,
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
"", NULL, format_headers_message_part_text, "\n",
Break up format->part function into part_start and part_content functions. Future improvements (eg. crypto support) will require adding new part header. By breaking up the output of part headers from the output of part content, we can easily out new part headers with new formatting functions.
2011-05-26 03:01:13 +02:00
"",
Add decryption of PGP/MIME-encrypted parts with --decrypt. This adds support for decrypting PGP/MIME-encrypted parts to notmuch-show and notmuch-reply. The --decrypt option implies --verify. Once decryption (and possibly signature verification) is done, a new part_encstatus formatter is emitted, the part_sigstatus formatter is emitted, and the entire multipart/encrypted part is replaced by the contents of the encrypted part. At the moment only a json part_encstatus formatting function is available, even though decryption is done for all formats. Emacs support to follow.
2011-05-26 03:01:18 +02:00
NULL,
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
NULL,
Break up format->part function into part_start and part_content functions. Future improvements (eg. crypto support) will require adding new part header. By breaking up the output of part headers from the output of part content, we can easily out new part headers with new formatting functions.
2011-05-26 03:01:13 +02:00
NULL,
format_part_content_raw,
NULL,
"",
"",
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
"", "",
""
};
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
static const char *
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
_get_tags_as_string (const void *ctx, notmuch_message_t *message)
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
{
notmuch_tags_t *tags;
int first = 1;
const char *tag;
char *result;
result = talloc_strdup (ctx, "");
if (result == NULL)
return NULL;
for (tags = notmuch_message_get_tags (message);
lib: Rename iterator functions to prepare for reverse iteration. We rename 'has_more' to 'valid' so that it can function whether iterating in a forward or reverse direction. We also rename 'advance' to 'move_to_next' to setup parallel naming with the proposed functions 'move_to_first', 'move_to_last', and 'move_to_previous'.
2010-03-09 18:22:29 +01:00
notmuch_tags_valid (tags);
notmuch_tags_move_to_next (tags))
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
{
tag = notmuch_tags_get (tags);
result = talloc_asprintf_append (result, "%s%s",
first ? "" : " ", tag);
first = 0;
}
return result;
}
/* Get a nice, single-line summary of message. */
static const char *
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
_get_one_line_summary (const void *ctx, notmuch_message_t *message)
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
{
const char *from;
time_t date;
const char *relative_date;
const char *tags;
from = notmuch_message_get_header (message, "from");
date = notmuch_message_get_date (message);
relative_date = notmuch_time_relative_date (ctx, date);
tags = _get_tags_as_string (ctx, message);
return talloc_asprintf (ctx, "%s (%s) (%s)",
from, relative_date, tags);
}
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
static void
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
format_message_json (const void *ctx, notmuch_message_t *message)
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
{
notmuch-show: add tags to json output The previous json patches forgot to add the notmuch tags to the json output. This is inconsistent to the text output so here they are. We just output a 'tags' field that sends notmuch tags as a json array. Signed-off-by: Sebastian Spaeth <Sebastian@SSpaeth.de>
2010-03-11 13:11:43 +01:00
notmuch_tags_t *tags;
int first = 1;
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
void *ctx_quote = talloc_new (ctx);
notmuch-show: Add unix and relative dates to the JSON output Include a 'date_unix' and 'date_relative' field in the JSON output for each message. 'date_relative' can be used by a UI implementation, whereas 'date_unix' is useful when scripting.
2010-03-23 10:40:48 +01:00
time_t date;
const char *relative_date;
date = notmuch_message_get_date (message);
relative_date = notmuch_time_relative_date (ctx, date);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
printf ("\"id\": %s, \"match\": %s, \"excluded\": %s, \"filename\": %s, \"timestamp\": %ld, \"date_relative\": \"%s\", \"tags\": [",
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
json_quote_str (ctx_quote, notmuch_message_get_message_id (message)),
notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH) ? "true" : "false",
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED) ? "true" : "false",
notmuch-show: Add unix and relative dates to the JSON output Include a 'date_unix' and 'date_relative' field in the JSON output for each message. 'date_relative' can be used by a UI implementation, whereas 'date_unix' is useful when scripting.
2010-03-23 10:40:48 +01:00
json_quote_str (ctx_quote, notmuch_message_get_filename (message)),
date, relative_date);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
notmuch-show: add tags to json output The previous json patches forgot to add the notmuch tags to the json output. This is inconsistent to the text output so here they are. We just output a 'tags' field that sends notmuch tags as a json array. Signed-off-by: Sebastian Spaeth <Sebastian@SSpaeth.de>
2010-03-11 13:11:43 +01:00
for (tags = notmuch_message_get_tags (message);
notmuch_tags_valid (tags);
notmuch_tags_move_to_next (tags))
{
printf("%s%s", first ? "" : ",",
json_quote_str (ctx_quote, notmuch_tags_get (tags)));
first = 0;
}
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
printf("], ");
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
talloc_free (ctx_quote);
}
notmuch show: Add a --format=mbox option We don't love the mbox format, but it's still sometimes the most practical way to share a collection of messages as a single file. Here we implement the "mboxrd" variant of the mbox file format. This variant applies reversible escaping by prefixing a '>' character to all lines in the email messages matching the regular expression: "^>*From " This allows the escaping to be reliably removed. A reader should remove a '>' from any line matching the regular expression: "^>>*From " More details on the mboxrd formats (and others as well) can be found here: http://homepage.ntlworld.com/jonathan.deboynepollard/FGA/mail-mbox-formats.html
2010-06-09 04:45:54 +02:00
/* Extract just the email address from the contents of a From:
* header. */
static const char *
_extract_email_address (const void *ctx, const char *from)
{
InternetAddressList *addresses;
InternetAddress *address;
InternetAddressMailbox *mailbox;
const char *email = "MAILER-DAEMON";
addresses = internet_address_list_parse_string (from);
/* Bail if there is no address here. */
if (addresses == NULL || internet_address_list_length (addresses) < 1)
goto DONE;
/* Otherwise, just use the first address. */
address = internet_address_list_get_address (addresses, 0);
/* The From header should never contain an address group rather
* than a mailbox. So bail if it does. */
if (! INTERNET_ADDRESS_IS_MAILBOX (address))
goto DONE;
mailbox = INTERNET_ADDRESS_MAILBOX (address);
email = internet_address_mailbox_get_addr (mailbox);
email = talloc_strdup (ctx, email);
DONE:
Release memory allocated by internet_address_list_parse_string() g_object_unref() releases the memory of the InternetAddressList object returned by internet_address_list_parse_string() -- when last (only) reference is released, internet_address_list_finalize() will do cleanup.
2011-12-10 11:18:54 +01:00
if (addresses)
g_object_unref (addresses);
notmuch show: Add a --format=mbox option We don't love the mbox format, but it's still sometimes the most practical way to share a collection of messages as a single file. Here we implement the "mboxrd" variant of the mbox file format. This variant applies reversible escaping by prefixing a '>' character to all lines in the email messages matching the regular expression: "^>*From " This allows the escaping to be reliably removed. A reader should remove a '>' from any line matching the regular expression: "^>>*From " More details on the mboxrd formats (and others as well) can be found here: http://homepage.ntlworld.com/jonathan.deboynepollard/FGA/mail-mbox-formats.html
2010-06-09 04:45:54 +02:00
return email;
}
/* Return 1 if 'line' is an mbox From_ line---that is, a line
* beginning with zero or more '>' characters followed by the
* characters 'F', 'r', 'o', 'm', and space.
*
* Any characters at all may appear after that in the line.
*/
static int
_is_from_line (const char *line)
{
const char *s = line;
if (line == NULL)
return 0;
while (*s == '>')
s++;
if (STRNCMP_LITERAL (s, "From ") == 0)
return 1;
else
return 0;
}
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
static void
format_headers_message_part_text (GMimeMessage *message)
{
InternetAddressList *recipients;
const char *recipients_string;
show: Use consistent header ordering in the text format Previously, top-level message headers were printed as Subject, From, To, Date, while embedded message headers were printed From, To, Subject, Date. This makes both cases use the former order and updates the tests accordingly. Strangely, the raw format also uses this function, so this also fixes the two raw format tests affected by this change.
2012-01-23 03:31:12 +01:00
printf ("Subject: %s\n", g_mime_message_get_subject (message));
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
printf ("From: %s\n", g_mime_message_get_sender (message));
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_TO);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf ("To: %s\n",
recipients_string);
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_CC);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf ("Cc: %s\n",
recipients_string);
printf ("Date: %s\n", g_mime_message_get_date_as_string (message));
}
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
static void
show: Simplify talloc use in format_headers_json Previously there was an unnecessary talloc context.
2012-02-20 01:26:27 +01:00
format_headers_json (const void *ctx, GMimeMessage *message)
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
{
show: Simplify talloc use in format_headers_json Previously there was an unnecessary talloc context.
2012-02-20 01:26:27 +01:00
void *local = talloc_new (ctx);
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
InternetAddressList *recipients;
const char *recipients_string;
show: Make JSON helper functions print complete objects This makes the main recursive function easier to follow because helper functions don't add fields to the running object.
2012-02-20 01:26:28 +01:00
printf ("{%s: %s",
show: Simplify talloc use in format_headers_json Previously there was an unnecessary talloc context.
2012-02-20 01:26:27 +01:00
json_quote_str (local, "Subject"),
json_quote_str (local, g_mime_message_get_subject (message)));
show: Use consistent header ordering in the JSON format Previously, top-level message headers were printed as Subject, From, To, Date, while embedded message headers were printed From, To, Subject, Date. This makes both cases use the former order and updates the tests accordingly.
2012-02-20 01:26:25 +01:00
printf (", %s: %s",
show: Simplify talloc use in format_headers_json Previously there was an unnecessary talloc context.
2012-02-20 01:26:27 +01:00
json_quote_str (local, "From"),
json_quote_str (local, g_mime_message_get_sender (message)));
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_TO);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf (", %s: %s",
show: Simplify talloc use in format_headers_json Previously there was an unnecessary talloc context.
2012-02-20 01:26:27 +01:00
json_quote_str (local, "To"),
json_quote_str (local, recipients_string));
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_CC);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf (", %s: %s",
show: Simplify talloc use in format_headers_json Previously there was an unnecessary talloc context.
2012-02-20 01:26:27 +01:00
json_quote_str (local, "Cc"),
json_quote_str (local, recipients_string));
show: Make JSON helper functions print complete objects This makes the main recursive function easier to follow because helper functions don't add fields to the running object.
2012-02-20 01:26:28 +01:00
printf (", %s: %s}",
show: Simplify talloc use in format_headers_json Previously there was an unnecessary talloc context.
2012-02-20 01:26:27 +01:00
json_quote_str (local, "Date"),
json_quote_str (local, g_mime_message_get_date_as_string (message)));
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
show: Simplify talloc use in format_headers_json Previously there was an unnecessary talloc context.
2012-02-20 01:26:27 +01:00
talloc_free (local);
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
}
notmuch show: Don't do text conversions for non-text parts This fixes the recently-added test case (in test/multipart) demonstrating corruption of binary parts that happen to contain CRLF pairs. We restore the original code from show_one_part_content to format_part_content_raw. Then, for good measure, we rename show_part_content to the more descriptive show_text_part_content and add an internal error if it is ever called with a non-text part.
2011-06-01 01:13:21 +02:00
/* Write a MIME text part out to the given stream.
*
* Both line-ending conversion (CRLF->LF) and charset conversion ( ->
* UTF-8) will be performed, so it is inappropriate to call this
* function with a non-text part. Doing so will trigger an internal
* error.
*/
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
static void
notmuch show: Don't do text conversions for non-text parts This fixes the recently-added test case (in test/multipart) demonstrating corruption of binary parts that happen to contain CRLF pairs. We restore the original code from show_one_part_content to format_part_content_raw. Then, for good measure, we rename show_part_content to the more descriptive show_text_part_content and add an internal error if it is ever called with a non-text part.
2011-06-01 01:13:21 +02:00
show_text_part_content (GMimeObject *part, GMimeStream *stream_out)
notmuch show: Don't hide text parts, even with disposition attachment. If it's text, (such as a patch), then I want to see it.
2009-11-21 01:09:36 +01:00
{
notmuch show: Don't do text conversions for non-text parts This fixes the recently-added test case (in test/multipart) demonstrating corruption of binary parts that happen to contain CRLF pairs. We restore the original code from show_one_part_content to format_part_content_raw. Then, for good measure, we rename show_part_content to the more descriptive show_text_part_content and add an internal error if it is ever called with a non-text part.
2011-06-01 01:13:21 +02:00
GMimeContentType *content_type = g_mime_object_get_content_type (GMIME_OBJECT (part));
notmuch show: Don't hide text parts, even with disposition attachment. If it's text, (such as a patch), then I want to see it.
2009-11-21 01:09:36 +01:00
GMimeStream *stream_filter = NULL;
GMimeDataWrapper *wrapper;
notmuch-show: Show message part using UTF-8. Pass the message through the charset filter so that we can view messages wrote in different charset encoding. Signed-off-by: Kan-Ru Chen <kanru@kanru.info>
2009-11-22 09:30:47 +01:00
const char *charset;
notmuch show: Don't do text conversions for non-text parts This fixes the recently-added test case (in test/multipart) demonstrating corruption of binary parts that happen to contain CRLF pairs. We restore the original code from show_one_part_content to format_part_content_raw. Then, for good measure, we rename show_part_content to the more descriptive show_text_part_content and add an internal error if it is ever called with a non-text part.
2011-06-01 01:13:21 +02:00
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));
Reduce some excessive indentation. I prefer checking a condition and returning early rather than making large blocks of code within a function conditional.
2011-06-01 01:18:45 +02:00
if (stream_out == NULL)
return;
notmuch show: Don't hide text parts, even with disposition attachment. If it's text, (such as a patch), then I want to see it.
2009-11-21 01:09:36 +01:00
Reduce some excessive indentation. I prefer checking a condition and returning early rather than making large blocks of code within a function conditional.
2011-06-01 01:18:45 +02:00
stream_filter = g_mime_stream_filter_new (stream_out);
g_mime_stream_filter_add(GMIME_STREAM_FILTER (stream_filter),
g_mime_filter_crlf_new (FALSE, FALSE));
charset = g_mime_object_get_content_type_parameter (part, "charset");
if (charset) {
GMimeFilter *charset_filter;
charset_filter = g_mime_filter_charset_new (charset, "UTF-8");
/* This result can be NULL for things like "unknown-8bit".
* Don't set a NULL filter as that makes GMime print
* annoying assertion-failure messages on stderr. */
notmuch: unref charset_filter to fix one memory leak In my test case added g_object_unref(charset_filter) reduces memory consumption over 90% when 'notmuch show --format=text "*"' is executed (~11000 messages, RES ~330M -> ~25M).
2011-12-13 19:18:48 +01:00
if (charset_filter) {
Reduce some excessive indentation. I prefer checking a condition and returning early rather than making large blocks of code within a function conditional.
2011-06-01 01:18:45 +02:00
g_mime_stream_filter_add (GMIME_STREAM_FILTER (stream_filter),
charset_filter);
notmuch: unref charset_filter to fix one memory leak In my test case added g_object_unref(charset_filter) reduces memory consumption over 90% when 'notmuch show --format=text "*"' is executed (~11000 messages, RES ~330M -> ~25M).
2011-12-13 19:18:48 +01:00
g_object_unref (charset_filter);
}
notmuch show: Don't hide text parts, even with disposition attachment. If it's text, (such as a patch), then I want to see it.
2009-11-21 01:09:36 +01:00
}
wrapper = g_mime_part_get_content_object (GMIME_PART (part));
if (wrapper && stream_filter)
g_mime_data_wrapper_write_to_stream (wrapper, stream_filter);
if (stream_filter)
g_object_unref(stream_filter);
}
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
#ifdef GMIME_ATLEAST_26
static const char*
signature_status_to_string (GMimeSignatureStatus x)
{
switch (x) {
case GMIME_SIGNATURE_STATUS_GOOD:
return "good";
case GMIME_SIGNATURE_STATUS_BAD:
return "bad";
case GMIME_SIGNATURE_STATUS_ERROR:
return "error";
}
return "unknown";
}
#else
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
static const char*
Rename signerstatustostring to signer_status_to_string Otherwise, it's fartoohardformetoreadthis code.
2011-06-01 01:20:56 +02:00
signer_status_to_string (GMimeSignerStatus x)
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
{
switch (x) {
case GMIME_SIGNER_STATUS_NONE:
return "none";
case GMIME_SIGNER_STATUS_GOOD:
return "good";
case GMIME_SIGNER_STATUS_BAD:
return "bad";
case GMIME_SIGNER_STATUS_ERROR:
return "error";
}
return "unknown";
}
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
#endif
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
#ifdef GMIME_ATLEAST_26
static void
show: Make format_part_sigstatus_json's API consistent between GMIME 2.4 and 2.6 The implementation is still different for GMIME 2.4 and 2.6, but at least now the caller doesn't have to be aware of this.
2012-02-20 01:26:29 +01:00
format_part_sigstatus_json (mime_node_t *node)
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
{
show: Make format_part_sigstatus_json's API consistent between GMIME 2.4 and 2.6 The implementation is still different for GMIME 2.4 and 2.6, but at least now the caller doesn't have to be aware of this.
2012-02-20 01:26:29 +01:00
GMimeSignatureList *siglist = node->sig_list;
show: Make JSON helper functions print complete objects This makes the main recursive function easier to follow because helper functions don't add fields to the running object.
2012-02-20 01:26:28 +01:00
printf ("[");
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
if (!siglist) {
printf ("]");
return;
}
void *ctx_quote = talloc_new (NULL);
int i;
for (i = 0; i < g_mime_signature_list_length (siglist); i++) {
GMimeSignature *signature = g_mime_signature_list_get_signature (siglist, i);
if (i > 0)
printf (", ");
printf ("{");
/* status */
GMimeSignatureStatus status = g_mime_signature_get_status (signature);
printf ("\"status\": %s",
json_quote_str (ctx_quote,
signature_status_to_string (status)));
GMimeCertificate *certificate = g_mime_signature_get_certificate (signature);
if (status == GMIME_SIGNATURE_STATUS_GOOD) {
if (certificate)
printf (", \"fingerprint\": %s", json_quote_str (ctx_quote, g_mime_certificate_get_fingerprint (certificate)));
/* these dates are seconds since the epoch; should we
* provide a more human-readable format string? */
time_t created = g_mime_signature_get_created (signature);
if (created != -1)
printf (", \"created\": %d", (int) created);
time_t expires = g_mime_signature_get_expires (signature);
if (expires > 0)
printf (", \"expires\": %d", (int) expires);
/* output user id only if validity is FULL or ULTIMATE. */
/* note that gmime is using the term "trust" here, which
* is WRONG. It's actually user id "validity". */
if (certificate) {
const char *name = g_mime_certificate_get_name (certificate);
GMimeCertificateTrust trust = g_mime_certificate_get_trust (certificate);
if (name && (trust == GMIME_CERTIFICATE_TRUST_FULLY || trust == GMIME_CERTIFICATE_TRUST_ULTIMATE))
printf (", \"userid\": %s", json_quote_str (ctx_quote, name));
}
} else if (certificate) {
const char *key_id = g_mime_certificate_get_key_id (certificate);
if (key_id)
printf (", \"keyid\": %s", json_quote_str (ctx_quote, key_id));
}
GMimeSignatureError errors = g_mime_signature_get_errors (signature);
if (errors != GMIME_SIGNATURE_ERROR_NONE) {
printf (", \"errors\": %d", errors);
}
printf ("}");
}
printf ("]");
talloc_free (ctx_quote);
}
#else
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
static void
show: Make format_part_sigstatus_json's API consistent between GMIME 2.4 and 2.6 The implementation is still different for GMIME 2.4 and 2.6, but at least now the caller doesn't have to be aware of this.
2012-02-20 01:26:29 +01:00
format_part_sigstatus_json (mime_node_t *node)
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
{
show: Make format_part_sigstatus_json's API consistent between GMIME 2.4 and 2.6 The implementation is still different for GMIME 2.4 and 2.6, but at least now the caller doesn't have to be aware of this.
2012-02-20 01:26:29 +01:00
const GMimeSignatureValidity* validity = node->sig_validity;
show: Make JSON helper functions print complete objects This makes the main recursive function easier to follow because helper functions don't add fields to the running object.
2012-02-20 01:26:28 +01:00
printf ("[");
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
if (!validity) {
printf ("]");
return;
}
const GMimeSigner *signer = g_mime_signature_validity_get_signers (validity);
int first = 1;
void *ctx_quote = talloc_new (NULL);
while (signer) {
if (first)
first = 0;
else
printf (", ");
printf ("{");
/* status */
Rename signerstatustostring to signer_status_to_string Otherwise, it's fartoohardformetoreadthis code.
2011-06-01 01:20:56 +02:00
printf ("\"status\": %s",
json_quote_str (ctx_quote,
signer_status_to_string (signer->status)));
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
if (signer->status == GMIME_SIGNER_STATUS_GOOD)
{
if (signer->fingerprint)
printf (", \"fingerprint\": %s", json_quote_str (ctx_quote, signer->fingerprint));
/* these dates are seconds since the epoch; should we
* provide a more human-readable format string? */
if (signer->created)
printf (", \"created\": %d", (int) signer->created);
if (signer->expires)
printf (", \"expires\": %d", (int) signer->expires);
/* output user id only if validity is FULL or ULTIMATE. */
/* note that gmime is using the term "trust" here, which
* is WRONG. It's actually user id "validity". */
if ((signer->name) && (signer->trust)) {
if ((signer->trust == GMIME_SIGNER_TRUST_FULLY) || (signer->trust == GMIME_SIGNER_TRUST_ULTIMATE))
printf (", \"userid\": %s", json_quote_str (ctx_quote, signer->name));
}
} else {
if (signer->keyid)
printf (", \"keyid\": %s", json_quote_str (ctx_quote, signer->keyid));
}
if (signer->errors != GMIME_SIGNER_ERROR_NONE) {
show: don't use hex literals in JSON output JSON does not support hex literals (0x..) so numbers must be formatted as %d instead of %x. Currently, the possible values for the gmime error code are 1 (expired signature), 2 (no public key), 4 (expired key) and 8 (revoked key). The other possible value is 16 (unsupported algorithm) but obviously it is much more rare. If this happens, the current code will add '"errors": 10'. This is valid JSON (it looks like a decimal number) but it is incorrect (should be 16, not 10). Since this is just an issue in the JSON encoder, no changes are needed on the Emacs side (or in other UIs using the JSON output).
2012-01-22 01:20:57 +01:00
printf (", \"errors\": %d", signer->errors);
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
}
printf ("}");
signer = signer->next;
}
printf ("]");
talloc_free (ctx_quote);
}
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
#endif
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
static void
Break up format->part function into part_start and part_content functions. Future improvements (eg. crypto support) will require adding new part header. By breaking up the output of part headers from the output of part content, we can easily out new part headers with new formatting functions.
2011-05-26 03:01:13 +02:00
format_part_content_raw (GMimeObject *part)
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
{
Do not attempt to output part raw if part is not GMimePart. This was a minor oversite in checking of part type when outputing content raw. This was causing gmime was to throw an exception to stderr. Unfortunately the gmime exception was not being caught by notmuch, or the test suite. I'm not sure if notmuch should have done anything in this case, but certainly the test suite should be capable of detecting that something unexpected was output to stderr.
2011-06-03 19:01:06 +02:00
if (! GMIME_IS_PART (part))
return;
notmuch show: Don't do text conversions for non-text parts This fixes the recently-added test case (in test/multipart) demonstrating corruption of binary parts that happen to contain CRLF pairs. We restore the original code from show_one_part_content to format_part_content_raw. Then, for good measure, we rename show_part_content to the more descriptive show_text_part_content and add an internal error if it is ever called with a non-text part.
2011-06-01 01:13:21 +02:00
GMimeStream *stream_stdout;
GMimeStream *stream_filter = NULL;
GMimeDataWrapper *wrapper;
stream_stdout = g_mime_stream_file_new (stdout);
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
notmuch show: Don't do text conversions for non-text parts This fixes the recently-added test case (in test/multipart) demonstrating corruption of binary parts that happen to contain CRLF pairs. We restore the original code from show_one_part_content to format_part_content_raw. Then, for good measure, we rename show_part_content to the more descriptive show_text_part_content and add an internal error if it is ever called with a non-text part.
2011-06-01 01:13:21 +02:00
stream_filter = g_mime_stream_filter_new (stream_stdout);
wrapper = g_mime_part_get_content_object (GMIME_PART (part));
if (wrapper && stream_filter)
g_mime_data_wrapper_write_to_stream (wrapper, stream_filter);
if (stream_filter)
g_object_unref (stream_filter);
if (stream_stdout)
g_object_unref(stream_stdout);
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
}
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
format_part_text (const void *ctx, mime_node_t *node,
int indent, const notmuch_show_params_t *params)
{
/* 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;
GMimeContentType *content_type = g_mime_object_get_content_type (meta);
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
const notmuch_bool_t leaf = GMIME_IS_PART (node->part);
const char *part_type;
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
int i;
if (node->envelope_file) {
notmuch_message_t *message = node->envelope_file;
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
part_type = "message";
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
printf ("\f%s{ id:%s depth:%d match:%d excluded:%d filename:%s\n",
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
part_type,
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
notmuch_message_get_message_id (message),
indent,
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH) ? 1 : 0,
notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED) ? 1 : 0,
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
notmuch_message_get_filename (message));
} else {
GMimeContentDisposition *disposition = g_mime_object_get_content_disposition (meta);
const char *cid = g_mime_object_get_content_id (meta);
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
const char *filename = leaf ?
g_mime_part_get_filename (GMIME_PART (node->part)) : NULL;
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
if (disposition &&
strcmp (disposition->disposition, GMIME_DISPOSITION_ATTACHMENT) == 0)
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
part_type = "attachment";
else
part_type = "part";
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
printf ("\f%s{ ID: %d", part_type, node->part_num);
if (filename)
printf (", Filename: %s", filename);
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
if (cid)
printf (", Content-id: %s", cid);
printf (", Content-type: %s\n", g_mime_content_type_to_string (content_type));
}
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
if (GMIME_IS_MESSAGE (node->part)) {
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
GMimeMessage *message = GMIME_MESSAGE (node->part);
InternetAddressList *recipients;
const char *recipients_string;
printf ("\fheader{\n");
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
if (node->envelope_file)
printf ("%s\n", _get_one_line_summary (ctx, node->envelope_file));
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
printf ("Subject: %s\n", g_mime_message_get_subject (message));
printf ("From: %s\n", g_mime_message_get_sender (message));
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_TO);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf ("To: %s\n", recipients_string);
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_CC);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf ("Cc: %s\n", recipients_string);
printf ("Date: %s\n", g_mime_message_get_date_as_string (message));
printf ("\fheader}\n");
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
printf ("\fbody{\n");
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
}
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
if (leaf) {
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
if (g_mime_content_type_is_type (content_type, "text", "*") &&
!g_mime_content_type_is_type (content_type, "text", "html"))
{
GMimeStream *stream_stdout = g_mime_stream_file_new (stdout);
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
show_text_part_content (node->part, stream_stdout);
g_object_unref(stream_stdout);
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
} else {
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
printf ("Non-text part: %s\n",
g_mime_content_type_to_string (content_type));
}
}
for (i = 0; i < node->nchildren; i++)
format_part_text (ctx, mime_node_child (node, i), indent, params);
if (GMIME_IS_MESSAGE (node->part))
printf ("\fbody}\n");
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
printf ("\f%s}\n", part_type);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return NOTMUCH_STATUS_SUCCESS;
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
}
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
static void
format_part_json (const void *ctx, mime_node_t *node, notmuch_bool_t first)
{
/* Any changes to the JSON format should be reflected in the file
* devel/schemata. */
if (node->envelope_file) {
printf ("{");
format_message_json (ctx, node->envelope_file);
show: Make JSON helper functions print complete objects This makes the main recursive function easier to follow because helper functions don't add fields to the running object.
2012-02-20 01:26:28 +01:00
printf ("\"headers\": ");
show: Simplify talloc use in format_headers_json Previously there was an unnecessary talloc context.
2012-02-20 01:26:27 +01:00
format_headers_json (ctx, GMIME_MESSAGE (node->part));
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
printf (", \"body\": [");
format_part_json (ctx, mime_node_child (node, 0), first);
printf ("]}");
return;
}
void *local = talloc_new (ctx);
/* 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;
GMimeContentType *content_type = g_mime_object_get_content_type (meta);
const char *cid = g_mime_object_get_content_id (meta);
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
const char *filename = GMIME_IS_PART (node->part) ?
g_mime_part_get_filename (GMIME_PART (node->part)) : NULL;
const char *terminator = "";
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
int i;
if (!first)
printf (", ");
printf ("{\"id\": %d", node->part_num);
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
if (node->decrypt_attempted)
printf (", \"encstatus\": [{\"status\": \"%s\"}]",
node->decrypt_success ? "good" : "bad");
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
if (node->verify_attempted) {
show: Make JSON helper functions print complete objects This makes the main recursive function easier to follow because helper functions don't add fields to the running object.
2012-02-20 01:26:28 +01:00
printf (", \"sigstatus\": ");
show: Make format_part_sigstatus_json's API consistent between GMIME 2.4 and 2.6 The implementation is still different for GMIME 2.4 and 2.6, but at least now the caller doesn't have to be aware of this.
2012-02-20 01:26:29 +01:00
format_part_sigstatus_json (node);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
}
printf (", \"content-type\": %s",
json_quote_str (local, g_mime_content_type_to_string (content_type)));
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
if (cid)
printf (", \"content-id\": %s", json_quote_str (local, cid));
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
if (filename)
printf (", \"filename\": %s", json_quote_str (local, filename));
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
if (GMIME_IS_PART (node->part)) {
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
/* For non-HTML text parts, we include the content in the
* JSON. Since JSON must be Unicode, we handle charset
* decoding here and do not report a charset to the caller.
* For text/html parts, we do not include the content. If a
* caller is interested in text/html parts, it should retrieve
* them separately and they will not be decoded. Since this
* makes charset decoding the responsibility on the caller, we
* report the charset for text/html parts.
*/
if (g_mime_content_type_is_type (content_type, "text", "html")) {
const char *content_charset = g_mime_object_get_content_type_parameter (meta, "charset");
if (content_charset != NULL)
printf (", \"content-charset\": %s", json_quote_str (local, content_charset));
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
} else if (g_mime_content_type_is_type (content_type, "text", "*")) {
GMimeStream *stream_memory = g_mime_stream_mem_new ();
GByteArray *part_content;
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
show_text_part_content (node->part, stream_memory);
part_content = g_mime_stream_mem_get_byte_array (GMIME_STREAM_MEM (stream_memory));
printf (", \"content\": %s", json_quote_chararray (local, (char *) part_content->data, part_content->len));
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
g_object_unref (stream_memory);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
}
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
} else if (GMIME_IS_MULTIPART (node->part)) {
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
printf (", \"content\": [");
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
terminator = "]";
} else if (GMIME_IS_MESSAGE (node->part)) {
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
printf (", \"content\": [{");
show: Make JSON helper functions print complete objects This makes the main recursive function easier to follow because helper functions don't add fields to the running object.
2012-02-20 01:26:28 +01:00
printf ("\"headers\": ");
show: Simplify talloc use in format_headers_json Previously there was an unnecessary talloc context.
2012-02-20 01:26:27 +01:00
format_headers_json (local, GMIME_MESSAGE (node->part));
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
printf (", \"body\": [");
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
terminator = "]}]";
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
}
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
talloc_free (local);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
for (i = 0; i < node->nchildren; i++)
format_part_json (ctx, mime_node_child (node, i), i == 0);
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
printf ("%s}", terminator);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
}
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
format_part_json_entry (const void *ctx, mime_node_t *node, unused (int indent),
unused (const notmuch_show_params_t *params))
{
format_part_json (ctx, node, TRUE);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return NOTMUCH_STATUS_SUCCESS;
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
}
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
/* Print a message in "mboxrd" format as documented, for example,
* here:
*
* http://qmail.org/qmail-manual-html/man5/mbox.html
*/
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
static notmuch_status_t
format_part_mbox (const void *ctx, mime_node_t *node, unused (int indent),
unused (const notmuch_show_params_t *params))
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
{
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
notmuch_message_t *message = node->envelope_file;
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
const char *filename;
FILE *file;
const char *from;
time_t date;
struct tm date_gmtime;
char date_asctime[26];
char *line = NULL;
size_t line_size;
ssize_t line_len;
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
if (!message)
INTERNAL_ERROR ("format_part_mbox requires a root part");
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
filename = notmuch_message_get_filename (message);
file = fopen (filename, "r");
if (file == NULL) {
fprintf (stderr, "Failed to open %s: %s\n",
filename, strerror (errno));
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
return NOTMUCH_STATUS_FILE_ERROR;
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
}
from = notmuch_message_get_header (message, "from");
from = _extract_email_address (ctx, from);
date = notmuch_message_get_date (message);
gmtime_r (&date, &date_gmtime);
asctime_r (&date_gmtime, date_asctime);
printf ("From %s %s", from, date_asctime);
while ((line_len = getline (&line, &line_size, file)) != -1 ) {
if (_is_from_line (line))
putchar ('>');
printf ("%s", line);
}
printf ("\n");
fclose (file);
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
return NOTMUCH_STATUS_SUCCESS;
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
}
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
show_message (void *ctx,
const notmuch_show_format_t *format,
notmuch_message_t *message,
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
int indent,
notmuch_show_params_t *params)
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
{
show: Introduce mime_node formatter callback This callback is the gateway to the new mime_node_t-based formatters. This maintains backwards compatibility so the formatters can be transitioned one at a time. Once all formatters are converted, the formatter structure can be reduced to only message_set_{start,sep,end} and part, most of show_message can be deleted, and all of show-message.c can be deleted.
2012-01-24 00:33:10 +01:00
if (format->part) {
void *local = talloc_new (ctx);
mime_node_t *root, *part;
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
notmuch_status_t status;
status = mime_node_open (local, message, params->cryptoctx,
params->decrypt, &root);
if (status)
goto DONE;
part = mime_node_seek_dfs (root, (params->part < 0 ? 0 : params->part));
if (part)
status = format->part (local, part, indent, params);
DONE:
show: Introduce mime_node formatter callback This callback is the gateway to the new mime_node_t-based formatters. This maintains backwards compatibility so the formatters can be transitioned one at a time. Once all formatters are converted, the formatter structure can be reduced to only message_set_{start,sep,end} and part, most of show_message can be deleted, and all of show-message.c can be deleted.
2012-01-24 00:33:10 +01:00
talloc_free (local);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return status;
show: Introduce mime_node formatter callback This callback is the gateway to the new mime_node_t-based formatters. This maintains backwards compatibility so the formatters can be transitioned one at a time. Once all formatters are converted, the formatter structure can be reduced to only message_set_{start,sep,end} and part, most of show_message can be deleted, and all of show-message.c can be deleted.
2012-01-24 00:33:10 +01:00
}
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
if (params->part <= 0) {
fputs (format->message_start, stdout);
if (format->message)
format->message(ctx, message, indent);
fputs (format->header_start, stdout);
if (format->header)
format->header(ctx, message);
fputs (format->header_end, stdout);
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
fputs (format->body_start, stdout);
}
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
Break up format->part function into part_start and part_content functions. Future improvements (eg. crypto support) will require adding new part header. By breaking up the output of part headers from the output of part content, we can easily out new part headers with new formatting functions.
2011-05-26 03:01:13 +02:00
if (format->part_content)
show: Pass notmuch_message_t instead of path to show_message_body. In addition to simplifying the code, we'll need the notmuch_message_t* in show_message_body shortly.
2011-12-24 19:52:43 +01:00
show_message_body (message, format, params);
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
if (params->part <= 0) {
fputs (format->body_end, stdout);
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
fputs (format->message_end, stdout);
}
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return NOTMUCH_STATUS_SUCCESS;
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
}
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
show_messages (void *ctx,
const notmuch_show_format_t *format,
notmuch_messages_t *messages,
int indent,
create notmuch_show_params_t structure for holding parameters passed to show functions. This simplifies the passing of arguments to the show functions. This will be very useful as we accumulate more parameters that will need to be passed. Currently only the entire_thread parameter is passed this way.
2011-05-21 00:01:52 +02:00
notmuch_show_params_t *params)
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
{
notmuch_message_t *message;
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
notmuch_bool_t match;
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
int first_set = 1;
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
int next_indent;
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
notmuch_status_t status, res = NOTMUCH_STATUS_SUCCESS;
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
fputs (format->message_set_start, stdout);
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
for (;
lib: Rename iterator functions to prepare for reverse iteration. We rename 'has_more' to 'valid' so that it can function whether iterating in a forward or reverse direction. We also rename 'advance' to 'move_to_next' to setup parallel naming with the proposed functions 'move_to_first', 'move_to_last', and 'move_to_previous'.
2010-03-09 18:22:29 +01:00
notmuch_messages_valid (messages);
notmuch_messages_move_to_next (messages))
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
{
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
if (!first_set)
fputs (format->message_set_sep, stdout);
first_set = 0;
fputs (format->message_set_start, stdout);
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
message = notmuch_messages_get (messages);
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
match = notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH);
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
next_indent = indent;
create notmuch_show_params_t structure for holding parameters passed to show functions. This simplifies the passing of arguments to the show functions. This will be very useful as we accumulate more parameters that will need to be passed. Currently only the entire_thread parameter is passed this way.
2011-05-21 00:01:52 +02:00
if (match || params->entire_thread) {
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
status = show_message (ctx, format, message, indent, params);
if (status && !res)
res = status;
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
next_indent = indent + 1;
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
if (!status)
fputs (format->message_set_sep, stdout);
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
}
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
status = show_messages (ctx,
format,
notmuch_message_get_replies (message),
next_indent,
params);
if (status && !res)
res = status;
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
notmuch_message_destroy (message);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
fputs (format->message_set_end, stdout);
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
}
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
fputs (format->message_set_end, stdout);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return res;
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
}
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
/* Formatted output of single message */
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
static int
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
do_show_single (void *ctx,
notmuch_query_t *query,
const notmuch_show_format_t *format,
notmuch_show_params_t *params)
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
{
notmuch_messages_t *messages;
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
notmuch_message_t *message;
notmuch show: limit display to only matching messages This patch changes the default behaviour of notmuch show to display only messages that match the search expression. However, --entire-thread option is provided to display all messages in threads that matched the search expression. It is deemed that will be more useful for human users on the command line. Scripts can be modified to include the --entire-thread option so that they can display all messages once more. Example: $ notmuch search subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b thread:23d99d0f364f93e90e15df8b42eddb5b July 31 [4/12] Johan Herland; [RFCv2 00/12] Foreign VCS helper program for CVS repositories (inbox unread) Note that in this thread 4 out of 12 messages matched. The default show behaviour is to show only those messages that match: $ notmuch show subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 4 With the --entire-thread option the output will contain all dozen messages: $ notmuch show --entire-thread subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 12 Signed-off-by: Bart Trojanowski <bart@jukie.net>
2009-11-28 03:49:39 +01:00
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
if (notmuch_query_count_messages (query) != 1) {
fprintf (stderr, "Error: search term did not match precisely one message.\n");
return 1;
notmuch show: limit display to only matching messages This patch changes the default behaviour of notmuch show to display only messages that match the search expression. However, --entire-thread option is provided to display all messages in threads that matched the search expression. It is deemed that will be more useful for human users on the command line. Scripts can be modified to include the --entire-thread option so that they can display all messages once more. Example: $ notmuch search subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b thread:23d99d0f364f93e90e15df8b42eddb5b July 31 [4/12] Johan Herland; [RFCv2 00/12] Foreign VCS helper program for CVS repositories (inbox unread) Note that in this thread 4 out of 12 messages matched. The default show behaviour is to show only those messages that match: $ notmuch show subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 4 With the --entire-thread option the output will contain all dozen messages: $ notmuch show --entire-thread subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 12 Signed-off-by: Bart Trojanowski <bart@jukie.net>
2009-11-28 03:49:39 +01:00
}
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
messages = notmuch_query_search_messages (query);
message = notmuch_messages_get (messages);
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
if (message == NULL) {
fprintf (stderr, "Error: Cannot find matching message.\n");
Unbreak several notmuch commands after the addition of configuration. All of the following commands: notmuch dump notmuch reply notmuch restore notmuch search notmuch show notmuch tag were calling notmuch_database_open with an argument of NULL. This was a legitimate call until the recent addition of configuration, after which it is expected that all commands will lookup the correct path in the configuration file. So fix all these commands to do that. Also, while touching all of these commands, we fix them to use the talloc context that is passed in rather than creating a local talloc context. We also switch from using goto for return values, to doing direct returns as soon as an error is detected, (which can be leak free thanks to talloc).
2009-11-12 05:29:30 +01:00
return 1;
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
}
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH, 1);
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
/* Special case for --format=raw of full single message, just cat out file */
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
if (params->raw && 0 == params->part) {
Make reply/show/tag all require at least one search term In particular, notmuch tag -inbox "" tended to take a long time to run, happened if you hit 'a' on a blank line in the search view and probably didn't have the desired effect. Signed-off-by: Keith Packard <keithp@keithp.com>
2009-11-18 22:43:38 +01:00
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
const char *filename;
FILE *file;
size_t size;
char buf[4096];
Make reply/show/tag all require at least one search term In particular, notmuch tag -inbox "" tended to take a long time to run, happened if you hit 'a' on a blank line in the search view and probably didn't have the desired effect. Signed-off-by: Keith Packard <keithp@keithp.com>
2009-11-18 22:43:38 +01:00
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
filename = notmuch_message_get_filename (message);
if (filename == NULL) {
fprintf (stderr, "Error: Cannot message filename.\n");
return 1;
}
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
file = fopen (filename, "r");
if (file == NULL) {
fprintf (stderr, "Error: Cannot open file %s: %s\n", filename, strerror (errno));
return 1;
}
while (!feof (file)) {
size = fread (buf, 1, sizeof (buf), file);
show: Handle read and write errors For showing a message in raw format, rather than silently succeeding when a read or a write fails (or, probably, looping if a read fails), try to print an error message and exit with a non-zero status. This silences one of the buildbot warnings about unused results. While my libc lacks the declarations that trigger these warnings, this can be tested by adding the following to notmuch.h: __attribute__((warn_unused_result)) size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
2012-01-19 23:29:18 +01:00
if (ferror (file)) {
fprintf (stderr, "Error: Read failed from %s\n", filename);
fclose (file);
return 1;
}
if (fwrite (buf, size, 1, stdout) != 1) {
fprintf (stderr, "Error: Write failed\n");
fclose (file);
return 1;
}
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
}
fclose (file);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return 0;
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
} else {
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return show_message (ctx, format, message, 0, params) != NOTMUCH_STATUS_SUCCESS;
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
}
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
}
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
/* Formatted output of threads */
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
static int
do_show (void *ctx,
notmuch_query_t *query,
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
const notmuch_show_format_t *format,
create notmuch_show_params_t structure for holding parameters passed to show functions. This simplifies the passing of arguments to the show functions. This will be very useful as we accumulate more parameters that will need to be passed. Currently only the entire_thread parameter is passed this way.
2011-05-21 00:01:52 +02:00
notmuch_show_params_t *params)
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
{
notmuch_threads_t *threads;
notmuch_thread_t *thread;
notmuch_messages_t *messages;
int first_toplevel = 1;
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
notmuch_status_t status, res = NOTMUCH_STATUS_SUCCESS;
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
fputs (format->message_set_start, stdout);
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
for (threads = notmuch_query_search_threads (query);
lib: Rename iterator functions to prepare for reverse iteration. We rename 'has_more' to 'valid' so that it can function whether iterating in a forward or reverse direction. We also rename 'advance' to 'move_to_next' to setup parallel naming with the proposed functions 'move_to_first', 'move_to_last', and 'move_to_previous'.
2010-03-09 18:22:29 +01:00
notmuch_threads_valid (threads);
notmuch_threads_move_to_next (threads))
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
{
thread = notmuch_threads_get (threads);
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
messages = notmuch_thread_get_toplevel_messages (thread);
notmuch show: Detect an internal error if a thread has no messages. This really should be impossible---if there are no messages, then what was the thread object created from? During recent debugging, it was useful to have this error detected and reported.
2009-11-18 02:53:54 +01:00
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
if (messages == NULL)
INTERNAL_ERROR ("Thread %s has no toplevel messages.\n",
notmuch_thread_get_thread_id (thread));
notmuch show: limit display to only matching messages This patch changes the default behaviour of notmuch show to display only messages that match the search expression. However, --entire-thread option is provided to display all messages in threads that matched the search expression. It is deemed that will be more useful for human users on the command line. Scripts can be modified to include the --entire-thread option so that they can display all messages once more. Example: $ notmuch search subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b thread:23d99d0f364f93e90e15df8b42eddb5b July 31 [4/12] Johan Herland; [RFCv2 00/12] Foreign VCS helper program for CVS repositories (inbox unread) Note that in this thread 4 out of 12 messages matched. The default show behaviour is to show only those messages that match: $ notmuch show subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 4 With the --entire-thread option the output will contain all dozen messages: $ notmuch show --entire-thread subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 12 Signed-off-by: Bart Trojanowski <bart@jukie.net>
2009-11-28 03:49:39 +01:00
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
if (!first_toplevel)
fputs (format->message_set_sep, stdout);
first_toplevel = 0;
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
status = show_messages (ctx, format, messages, 0, params);
if (status && !res)
res = status;
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
notmuch_thread_destroy (thread);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
}
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
fputs (format->message_set_end, stdout);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return res != NOTMUCH_STATUS_SUCCESS;
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
}
notmuch: Add a 'part' subcommand A new 'part' subcommand allows the user to extract a single part from a MIME message. Usage: notmuch part --part=<n> <search terms> The search terms must match only a single message (e.g. id:foo@bar.com). The part number specified refers to the part identifiers output by `notmuch show'. The content of the part is written the stdout with no formatting or identification marks. It is not JSON formatted.
2010-03-24 08:21:20 +01:00
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
enum {
NOTMUCH_FORMAT_NOT_SPECIFIED,
NOTMUCH_FORMAT_JSON,
NOTMUCH_FORMAT_TEXT,
NOTMUCH_FORMAT_MBOX,
NOTMUCH_FORMAT_RAW
};
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
int
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
notmuch_show_command (void *ctx, unused (int argc), unused (char *argv[]))
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
{
notmuch_config_t *config;
notmuch_database_t *notmuch;
notmuch_query_t *query;
char *query_string;
cli: reach previously unreachable cleanup code in "notmuch show" The last lines of notmuch_show_command() function were unreachable. Fix it by using a variable for return value. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:23 +01:00
int opt_index, ret;
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
const notmuch_show_format_t *format = &format_text;
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
notmuch_show_params_t params = { .part = -1 };
int format_sel = NOTMUCH_FORMAT_NOT_SPECIFIED;
notmuch_bool_t verify = FALSE;
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
notmuch_bool_t no_exclude = FALSE;
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
notmuch_opt_desc_t options[] = {
{ NOTMUCH_OPT_KEYWORD, &format_sel, "format", 'f',
(notmuch_keyword_t []){ { "json", NOTMUCH_FORMAT_JSON },
{ "text", NOTMUCH_FORMAT_TEXT },
{ "mbox", NOTMUCH_FORMAT_MBOX },
{ "raw", NOTMUCH_FORMAT_RAW },
{ 0, 0 } } },
{ NOTMUCH_OPT_INT, &params.part, "part", 'p', 0 },
{ NOTMUCH_OPT_BOOLEAN, &params.entire_thread, "entire-thread", 't', 0 },
{ NOTMUCH_OPT_BOOLEAN, &params.decrypt, "decrypt", 'd', 0 },
{ NOTMUCH_OPT_BOOLEAN, &verify, "verify", 'v', 0 },
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
{ NOTMUCH_OPT_BOOLEAN, &no_exclude, "no-exclude", 'n', 0 },
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
{ 0, 0, 0, 0, 0 }
};
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
opt_index = parse_arguments (argc, argv, options, 1);
if (opt_index < 0) {
/* diagnostics already printed */
return 1;
}
create notmuch_show_params_t structure for holding parameters passed to show functions. This simplifies the passing of arguments to the show functions. This will be very useful as we accumulate more parameters that will need to be passed. Currently only the entire_thread parameter is passed this way.
2011-05-21 00:01:52 +02:00
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
if (format_sel == NOTMUCH_FORMAT_NOT_SPECIFIED) {
/* if part was requested and format was not specified, use format=raw */
if (params.part >= 0)
format_sel = NOTMUCH_FORMAT_RAW;
else
format_sel = NOTMUCH_FORMAT_TEXT;
}
cli: change argument parsing convention for subcommands previously we deleted the subcommand name from argv before passing to the subcommand. In this version, the deletion is done in the actual subcommands. Although this causes some duplication of code, it allows us to be more flexible about how we parse command line arguments in the subcommand, including possibly using off-the-shelf routines like getopt_long that expect the name of the command in argv[0].
2011-10-21 14:19:17 +02:00
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
switch (format_sel) {
case NOTMUCH_FORMAT_JSON:
format = &format_json;
params.entire_thread = TRUE;
break;
case NOTMUCH_FORMAT_TEXT:
format = &format_text;
break;
case NOTMUCH_FORMAT_MBOX:
if (params.part > 0) {
fprintf (stderr, "Error: specifying parts is incompatible with mbox output format.\n");
return 1;
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
}
cli: omit excluded messages in results where appropriate. In all cases of notmuch count/search/show where the results returned cannot reflect the exclude flag return just the matched not-excluded results. If the caller wishes to have all the matched results (i.e., including the excluded ones) they should call with the --no-exclude option. The relevant cases are count: both threads and messages search: all cases except the summary view show: mbox format
2012-03-01 23:30:43 +01:00
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
format = &format_mbox;
break;
case NOTMUCH_FORMAT_RAW:
format = &format_raw;
/* If --format=raw specified without specifying part, we can only
* output single message, so set part=0 */
if (params.part < 0)
params.part = 0;
params.raw = TRUE;
break;
}
if (params.decrypt || verify) {
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
#ifdef GMIME_ATLEAST_26
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
/* TODO: GMimePasswordRequestFunc */
params.cryptoctx = g_mime_gpg_context_new (NULL, "gpg");
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
#else
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
GMimeSession* session = g_object_new (g_mime_session_get_type(), NULL);
params.cryptoctx = g_mime_gpg_context_new (session, "gpg");
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
#endif
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
if (params.cryptoctx) {
g_mime_gpg_context_set_always_trust ((GMimeGpgContext*) params.cryptoctx, FALSE);
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
} else {
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
params.decrypt = FALSE;
fprintf (stderr, "Failed to construct gpg context.\n");
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
}
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
#ifndef GMIME_ATLEAST_26
g_object_unref (session);
#endif
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
}
config = notmuch_config_open (ctx, NULL, NULL);
if (config == NULL)
return 1;
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
query_string = query_string_from_args (ctx, argc-opt_index, argv+opt_index);
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
if (query_string == NULL) {
fprintf (stderr, "Out of memory\n");
return 1;
}
if (*query_string == '\0') {
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
fprintf (stderr, "Error: notmuch show requires at least one search term.\n");
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
return 1;
}
notmuch = notmuch_database_open (notmuch_config_get_database_path (config),
NOTMUCH_DATABASE_MODE_READ_ONLY);
if (notmuch == NULL)
return 1;
query = notmuch_query_create (notmuch, query_string);
if (query == NULL) {
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
fprintf (stderr, "Out of memory\n");
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
return 1;
}
cli: omit excluded messages in results where appropriate. In all cases of notmuch count/search/show where the results returned cannot reflect the exclude flag return just the matched not-excluded results. If the caller wishes to have all the matched results (i.e., including the excluded ones) they should call with the --no-exclude option. The relevant cases are count: both threads and messages search: all cases except the summary view show: mbox format
2012-03-01 23:30:43 +01:00
/* if format=mbox then we can not output excluded messages as
* there is no way to make the exclude flag available */
if (format_sel == NOTMUCH_FORMAT_MBOX)
notmuch_query_set_omit_excluded_messages (query, TRUE);
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
/* If a single message is requested we do not use search_excludes. */
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
if (params.part >= 0)
cli: reach previously unreachable cleanup code in "notmuch show" The last lines of notmuch_show_command() function were unreachable. Fix it by using a variable for return value. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:23 +01:00
ret = do_show_single (ctx, query, format, &params);
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
else {
if (!no_exclude) {
const char **search_exclude_tags;
size_t search_exclude_tags_length;
unsigned int i;
search_exclude_tags = notmuch_config_get_search_exclude_tags
(config, &search_exclude_tags_length);
for (i = 0; i < search_exclude_tags_length; i++)
notmuch_query_add_tag_exclude (query, search_exclude_tags[i]);
}
cli: reach previously unreachable cleanup code in "notmuch show" The last lines of notmuch_show_command() function were unreachable. Fix it by using a variable for return value. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:23 +01:00
ret = do_show (ctx, query, format, &params);
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
}
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
notmuch_query_destroy (query);
notmuch_database_close (notmuch);
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
if (params.cryptoctx)
g_object_unref(params.cryptoctx);
cli: reach previously unreachable cleanup code in "notmuch show" The last lines of notmuch_show_command() function were unreachable. Fix it by using a variable for return value. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:23 +01:00
return ret;
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
}
Reference in a new issue Copy permalink