debian/notmuch
1
0
Fork 0
mirror of https://git.notmuchmail.org/git/notmuch synced 2024-11-22 19:08:09 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
notmuch/show-message.c

215 lines
6.7 KiB
C
Raw Normal View History

notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
/* notmuch - Not much of an email program, (just index and search)
*
* Copyright © 2009 Carl Worth
* Copyright © 2009 Keith Packard
*
* 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/ .
*
* Authors: Carl Worth <cworth@cworth.org>
* Keith Packard <keithp@keithp.com>
*/
#include "notmuch-client.h"
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
typedef struct show_message_state {
int part_count;
int in_zone;
} show_message_state_t;
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
static void
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
show_message_part (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
show_message_state_t *state,
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,
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_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
int first)
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
{
Render all parts of multipart/encrypted when decrypting. The primary goal here is to keep the decrypted output as similarly structured as undecrypted output as possible. Now, when decrypting parts, only the original encrypted part is replaced by the it's decrypted content. If this part isn't itself a multipart, then all part numbering should remain consistent during decryption. The only draw back here is that the useless application/pgp-encrypted sub-part of the multipart/encrypted part is also emitted. But this part can be easily ignored by clients.
2011-05-27 12:27:37 +02:00
GMimeObject *decryptedpart = 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
int selected;
state->part_count += 1;
Normalize part counting and formatting in show_message_part function. Simplify the function by moving part counting and formatting outside of conditionals, thereby eliminating redundant code. This also wraps message part output handling with proper part formatting.
2011-05-23 07:08:08 +02:00
if (! (GMIME_IS_PART (part) || GMIME_IS_MULTIPART (part) || GMIME_IS_MESSAGE_PART (part))) {
fprintf (stderr, "Warning: Not displaying unknown mime part: %s.\n",
g_type_name (G_OBJECT_TYPE (part)));
return;
}
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
selected = (params->part <= 0 || state->part_count == params->part);
if (selected || state->in_zone) {
Use empty strings instead of NULL in format_reply structure. This keeps things consistent with notmuch-show, and prevents having to check for the existence of the field pointer for simple string output formats.
2011-05-26 03:01:12 +02:00
if (!first && (params->part <= 0 || state->in_zone))
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->part_sep, stdout);
add part_sep formatter to replace "first" argument to part format functions A new field "part_sep" is added to the notmuch_show_format structure, to be used for part separation. This is cleaner than the "first" argument that was being passed around to the part arguments, and allows the function that handles overall part output formatting (show_message_part) to directly handle when outputting the separator.
2011-05-23 04:56:53 +02: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_start)
format->part_start (part, &(state->part_count));
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
}
Normalize part counting and formatting in show_message_part function. Simplify the function by moving part counting and formatting outside of conditionals, thereby eliminating redundant code. This also wraps message part output handling with proper part formatting.
2011-05-23 07:08:08 +02:00
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
/* handle PGP/MIME parts */
if (GMIME_IS_MULTIPART (part) && params->cryptoctx) {
GMimeMultipart *multipart = GMIME_MULTIPART (part);
GError* err = NULL;
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
if (GMIME_IS_MULTIPART_ENCRYPTED (part) && params->decrypt)
{
if ( g_mime_multipart_get_count (multipart) != 2 ) {
/* this violates RFC 3156 section 4, so we won't bother with it. */
fprintf (stderr,
"Error: %d part(s) for a multipart/encrypted message (should be exactly 2)\n",
g_mime_multipart_get_count (multipart));
} else {
GMimeMultipartEncrypted *encrypteddata = GMIME_MULTIPART_ENCRYPTED (part);
Render all parts of multipart/encrypted when decrypting. The primary goal here is to keep the decrypted output as similarly structured as undecrypted output as possible. Now, when decrypting parts, only the original encrypted part is replaced by the it's decrypted content. If this part isn't itself a multipart, then all part numbering should remain consistent during decryption. The only draw back here is that the useless application/pgp-encrypted sub-part of the multipart/encrypted part is also emitted. But this part can be easily ignored by clients.
2011-05-27 12:27:37 +02:00
decryptedpart = g_mime_multipart_encrypted_decrypt (encrypteddata, params->cryptoctx, &err);
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
if (decryptedpart) {
if ((selected || state->in_zone) && format->part_encstatus)
format->part_encstatus (1);
const GMimeSignatureValidity *sigvalidity = g_mime_multipart_encrypted_get_signature_validity (encrypteddata);
if (!sigvalidity)
fprintf (stderr, "Failed to verify signed part: %s\n", (err ? err->message : "no error explanation given"));
if ((selected || state->in_zone) && format->part_sigstatus)
format->part_sigstatus (sigvalidity);
} else {
fprintf (stderr, "Failed to decrypt part: %s\n", (err ? err->message : "no error explanation given"));
if ((selected || state->in_zone) && format->part_encstatus)
format->part_encstatus (0);
}
}
}
else if (GMIME_IS_MULTIPART_SIGNED (part))
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 ( g_mime_multipart_get_count (multipart) != 2 ) {
/* this violates RFC 3156 section 5, so we won't bother with it. */
fprintf (stderr,
"Error: %d part(s) for a multipart/signed message (should be exactly 2)\n",
g_mime_multipart_get_count (multipart));
} else {
/* For some reason the GMimeSignatureValidity returned
* here is not a const (inconsistent with that
* returned by
* g_mime_multipart_encrypted_get_signature_validity,
* and therefore needs to be properly disposed of.
* Hopefully the API will become more consistent. */
GMimeSignatureValidity *sigvalidity = g_mime_multipart_signed_verify (GMIME_MULTIPART_SIGNED (part), params->cryptoctx, &err);
if (!sigvalidity) {
fprintf (stderr, "Failed to verify signed part: %s\n", (err ? err->message : "no error explanation given"));
}
if ((selected || state->in_zone) && format->part_sigstatus)
format->part_sigstatus (sigvalidity);
if (sigvalidity)
g_mime_signature_validity_free (sigvalidity);
}
}
if (err)
g_error_free (err);
}
/* end handle PGP/MIME parts */
if (selected || state->in_zone)
format->part_content (part);
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
if (GMIME_IS_MULTIPART (part)) {
GMimeMultipart *multipart = GMIME_MULTIPART (part);
int i;
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 (selected)
state->in_zone = 1;
Render all parts of multipart/encrypted when decrypting. The primary goal here is to keep the decrypted output as similarly structured as undecrypted output as possible. Now, when decrypting parts, only the original encrypted part is replaced by the it's decrypted content. If this part isn't itself a multipart, then all part numbering should remain consistent during decryption. The only draw back here is that the useless application/pgp-encrypted sub-part of the multipart/encrypted part is also emitted. But this part can be easily ignored by clients.
2011-05-27 12:27:37 +02:00
if (decryptedpart) {
/* We emit the useless application/pgp-encrypted version
* part here only to keep the emitted output as consistent
* as possible between decrypted output and the
* unprocessed multipart/mime. For some strange reason,
* the actual encrypted data is the second part of the
* multipart. */
show_message_part (g_mime_multipart_get_part (multipart, 0), state, format, params, TRUE);
show_message_part (decryptedpart, state, format, params, FALSE);
} else {
for (i = 0; i < g_mime_multipart_get_count (multipart); i++) {
show_message_part (g_mime_multipart_get_part (multipart, i),
state, format, params, i == 0);
}
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
}
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
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 (selected)
state->in_zone = 0;
Normalize part counting and formatting in show_message_part function. Simplify the function by moving part counting and formatting outside of conditionals, thereby eliminating redundant code. This also wraps message part output handling with proper part formatting.
2011-05-23 07:08:08 +02:00
} else if (GMIME_IS_MESSAGE_PART (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
GMimeMessage *mime_message = g_mime_message_part_get_message (GMIME_MESSAGE_PART (part));
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +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 (selected)
state->in_zone = 1;
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
show_message_part (g_mime_message_get_mime_part (mime_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
state, format, params, TRUE);
if (selected)
state->in_zone = 0;
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +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 (selected || state->in_zone) {
if (format->part_end)
format->part_end (part);
}
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
}
notmuch_status_t
show_message_body (const char *filename,
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
const notmuch_show_format_t *format,
notmuch_show_params_t *params)
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
{
GMimeStream *stream = NULL;
GMimeParser *parser = NULL;
GMimeMessage *mime_message = NULL;
notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
FILE *file = 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
show_message_state_t state;
state.part_count = 0;
state.in_zone = 0;
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
file = fopen (filename, "r");
if (! file) {
fprintf (stderr, "Error opening %s: %s\n", filename, strerror (errno));
ret = NOTMUCH_STATUS_FILE_ERROR;
goto DONE;
}
stream = g_mime_stream_file_new (file);
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream), FALSE);
parser = g_mime_parser_new_with_stream (stream);
mime_message = g_mime_parser_construct_message (parser);
show_message_part (g_mime_message_get_mime_part (mime_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
&state,
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
format,
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
params,
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
TRUE);
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
DONE:
if (mime_message)
g_object_unref (mime_message);
if (parser)
g_object_unref (parser);
if (stream)
g_object_unref (stream);
if (file)
fclose (file);
return ret;
}
Reference in a new issue Copy permalink