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

377 lines
11 KiB
C
Raw Normal View History

Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +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
Use https instead of http where possible Many of the external links found in the notmuch source can be resolved using https instead of http. This changeset addresses as many as i could find, without touching the e-mail corpus or expected outputs found in tests.
2016-06-02 18:26:14 +02:00
* along with this program. If not, see https://www.gnu.org/licenses/ .
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
*
* Authors: Carl Worth <cworth@cworth.org>
* Keith Packard <keithp@keithp.com>
* Austin Clements <aclements@csail.mit.edu>
*/
#include "notmuch-client.h"
/* Context that gets inherited from the root node. */
typedef struct mime_node_context {
/* Per-message resources. These are allocated internally and must
* be destroyed. */
FILE *file;
GMimeStream *stream;
GMimeParser *parser;
GMimeMessage *mime_message;
/* Context provided by the caller. */
crypto: rename notmuch_crypto_t to _notmuch_crypto_t The notmuch_crypto_t struct isn't used externally, and we have no plans to explicitly export it. Prefix its name (and associated functions) with _ to make that intent clear.
2017-10-10 07:49:02 +02:00
_notmuch_crypto_t *crypto;
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
} mime_node_context_t;
static int
_mime_node_context_free (mime_node_context_t *res)
{
if (res->mime_message)
g_object_unref (res->mime_message);
if (res->parser)
g_object_unref (res->parser);
if (res->stream)
g_object_unref (res->stream);
if (res->file)
fclose (res->file);
return 0;
}
notmuch_status_t
mime_node_open (const void *ctx, notmuch_message_t *message,
crypto: rename notmuch_crypto_t to _notmuch_crypto_t The notmuch_crypto_t struct isn't used externally, and we have no plans to explicitly export it. Prefix its name (and associated functions) with _ to make that intent clear.
2017-10-10 07:49:02 +02:00
_notmuch_crypto_t *crypto, mime_node_t **root_out)
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
{
const char *filename = notmuch_message_get_filename (message);
mime_node_context_t *mctx;
mime_node_t *root;
notmuch_status_t status;
root = talloc_zero (ctx, mime_node_t);
if (root == NULL) {
fprintf (stderr, "Out of memory.\n");
status = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE;
}
/* Create the tree-wide context */
mctx = talloc_zero (root, mime_node_context_t);
if (mctx == NULL) {
fprintf (stderr, "Out of memory.\n");
status = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE;
}
talloc_set_destructor (mctx, _mime_node_context_free);
show: workaround for the missing file problem This patch fixes the 'Deleted first duplicate file does not stop notmuch show from working' test. If a message to be shown has several duplicated files, and for some reason the first file in the list is not available anymore, notmuch will exit with an error. This is clearly a problem in the database, but we are not going to let this problem be a show-stopper. Let's walk through the list, and show the first existing file. Signed-off-by: Yuri Volchkov <yuri.volchkov@gmail.com>
2017-08-21 17:44:48 +02:00
/* Fast path */
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
mctx->file = fopen (filename, "r");
if (! mctx->file) {
show: workaround for the missing file problem This patch fixes the 'Deleted first duplicate file does not stop notmuch show from working' test. If a message to be shown has several duplicated files, and for some reason the first file in the list is not available anymore, notmuch will exit with an error. This is clearly a problem in the database, but we are not going to let this problem be a show-stopper. Let's walk through the list, and show the first existing file. Signed-off-by: Yuri Volchkov <yuri.volchkov@gmail.com>
2017-08-21 17:44:48 +02:00
/* Slow path - for some reason the first file in the list is
* not available anymore. This is clearly a problem in the
* database, but we are not going to let this problem be a
* show stopper */
notmuch_filenames_t *filenames;
for (filenames = notmuch_message_get_filenames (message);
notmuch_filenames_valid (filenames);
notmuch_filenames_move_to_next (filenames))
{
filename = notmuch_filenames_get (filenames);
mctx->file = fopen (filename, "r");
if (mctx->file)
break;
}
talloc_free (filenames);
if (! mctx->file) {
/* Give up */
fprintf (stderr, "Error opening %s: %s\n", filename, strerror (errno));
status = NOTMUCH_STATUS_FILE_ERROR;
goto DONE;
}
}
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
mctx->stream = g_mime_stream_file_new (mctx->file);
Handle errors in mime_node_open
2012-03-06 19:26:57 +01:00
if (!mctx->stream) {
fprintf (stderr, "Out of memory.\n");
status = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE;
}
cli: convert notmuch_bool_t to stdbool C99 stdbool turned 18 this year. There really is no reason to use our own, except in the library interface for backward compatibility. Convert the cli and test binaries to stdbool.
2017-10-07 10:44:04 +02:00
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (mctx->stream), false);
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
mctx->parser = g_mime_parser_new_with_stream (mctx->stream);
Handle errors in mime_node_open
2012-03-06 19:26:57 +01:00
if (!mctx->parser) {
fprintf (stderr, "Out of memory.\n");
status = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE;
}
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
mctx->mime_message = g_mime_parser_construct_message (mctx->parser);
Handle errors in mime_node_open
2012-03-06 19:26:57 +01:00
if (!mctx->mime_message) {
fprintf (stderr, "Failed to parse %s\n", filename);
status = NOTMUCH_STATUS_FILE_ERROR;
goto DONE;
}
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
cli: modify mime_node_context to use the new crypto struct This simplifies some more interfaces.
2012-05-26 20:45:44 +02:00
mctx->crypto = crypto;
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
/* Create the root node */
root->part = GMIME_OBJECT (mctx->mime_message);
root->envelope_file = message;
root->nchildren = 1;
root->ctx = mctx;
mime node: Record depth-first part numbers This makes the part numbers readily accessible to formatters. Hierarchical part numbering would be a more natural and efficient fit for MIME and may be the way to go in the future, but depth-first numbering maintains compatibility with what we currently do.
2012-01-24 00:33:09 +01:00
root->parent = NULL;
root->part_num = 0;
root->next_child = 0;
root->next_part_num = 1;
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
*root_out = root;
return NOTMUCH_STATUS_SUCCESS;
DONE:
talloc_free (root);
return status;
}
cli: mime node: abstract decryption and signature verification The code filled with #ifdef GMIME_ATLEAST_26 is difficult to read. Abstract the decryption and signature verification into functions, with separate implementations for GMime 2.4 and 2.6, to clarify the code. There should be no functional changes.
2013-03-30 14:53:16 +01:00
/* Signature list destructor (GMime 2.6) */
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
static int
_signature_list_free (GMimeSignatureList **proxy)
{
g_object_unref (*proxy);
return 0;
}
cli: mime node: abstract decryption and signature verification The code filled with #ifdef GMIME_ATLEAST_26 is difficult to read. Abstract the decryption and signature verification into functions, with separate implementations for GMime 2.4 and 2.6, to clarify the code. There should be no functional changes.
2013-03-30 14:53:16 +01:00
/* Set up signature list destructor (GMime 2.6) */
static void
set_signature_list_destructor (mime_node_t *node)
{
GMimeSignatureList **proxy = talloc (node, GMimeSignatureList *);
if (proxy) {
*proxy = node->sig_list;
talloc_set_destructor (proxy, _signature_list_free);
}
}
/* Verify a signed mime node (GMime 2.6) */
static void
node_verify (mime_node_t *node, GMimeObject *part,
crypto: drop pretense of notmuch_crypto_context_t notmuch_crypto_context_t was introduced (i think) as some sort of abstraction layer to make notmuch somewhat independent of GMime. But it isn't even useful for GMime 3.0 or later -- we can drop the pretense that it's some sort of abstraction in this case, and just call it what it is, GMimeCryptoContext, which is useful for building against older versions of GMime. This also renames _notmuch_crypto_get_context() to _notmuch_crypto_get_gmime_context().
2017-10-10 07:49:03 +02:00
g_mime_3_unused(GMimeCryptoContext *cryptoctx))
cli: mime node: abstract decryption and signature verification The code filled with #ifdef GMIME_ATLEAST_26 is difficult to read. Abstract the decryption and signature verification into functions, with separate implementations for GMime 2.4 and 2.6, to clarify the code. There should be no functional changes.
2013-03-30 14:53:16 +01:00
{
GError *err = NULL;
cli: convert notmuch_bool_t to stdbool C99 stdbool turned 18 this year. There really is no reason to use our own, except in the library interface for backward compatibility. Convert the cli and test binaries to stdbool.
2017-10-07 10:44:04 +02:00
node->verify_attempted = true;
cli: mime node: abstract decryption and signature verification The code filled with #ifdef GMIME_ATLEAST_26 is difficult to read. Abstract the decryption and signature verification into functions, with separate implementations for GMime 2.4 and 2.6, to clarify the code. There should be no functional changes.
2013-03-30 14:53:16 +01:00
node->sig_list = g_mime_multipart_signed_verify
(GMIME_MULTIPART_SIGNED (part), cryptoctx, &err);
if (node->sig_list)
set_signature_list_destructor (node);
else
fprintf (stderr, "Failed to verify signed part: %s\n",
err ? err->message : "no error explanation given");
if (err)
g_error_free (err);
}
/* Decrypt and optionally verify an encrypted mime node (GMime 2.6) */
static void
node_decrypt_and_verify (mime_node_t *node, GMimeObject *part,
crypto: drop pretense of notmuch_crypto_context_t notmuch_crypto_context_t was introduced (i think) as some sort of abstraction layer to make notmuch somewhat independent of GMime. But it isn't even useful for GMime 3.0 or later -- we can drop the pretense that it's some sort of abstraction in this case, and just call it what it is, GMimeCryptoContext, which is useful for building against older versions of GMime. This also renames _notmuch_crypto_get_context() to _notmuch_crypto_get_gmime_context().
2017-10-10 07:49:03 +02:00
g_mime_3_unused(GMimeCryptoContext *cryptoctx))
cli: mime node: abstract decryption and signature verification The code filled with #ifdef GMIME_ATLEAST_26 is difficult to read. Abstract the decryption and signature verification into functions, with separate implementations for GMime 2.4 and 2.6, to clarify the code. There should be no functional changes.
2013-03-30 14:53:16 +01:00
{
GError *err = NULL;
GMimeDecryptResult *decrypt_result = NULL;
GMimeMultipartEncrypted *encrypteddata = GMIME_MULTIPART_ENCRYPTED (part);
cli: convert notmuch_bool_t to stdbool C99 stdbool turned 18 this year. There really is no reason to use our own, except in the library interface for backward compatibility. Convert the cli and test binaries to stdbool.
2017-10-07 10:44:04 +02:00
node->decrypt_attempted = true;
cli: mime node: abstract decryption and signature verification The code filled with #ifdef GMIME_ATLEAST_26 is difficult to read. Abstract the decryption and signature verification into functions, with separate implementations for GMime 2.4 and 2.6, to clarify the code. There should be no functional changes.
2013-03-30 14:53:16 +01:00
node->decrypted_child = g_mime_multipart_encrypted_decrypt
gmime-extra: drop compat layer for g_mime_multipart_encrypted_decrypt In practice, we're going to see this function invoked differently depending on which gmime we build against. The compatibility layer forces our code into the lowest-common-denominator -- unable to make use of new features even when built against a newer version. Dropping the compatibility layer paves the way for clearer use of features from GMime 3.0 in future commits.
2017-10-10 07:49:10 +02:00
#if (GMIME_MAJOR_VERSION < 3)
cli: mime node: abstract decryption and signature verification The code filled with #ifdef GMIME_ATLEAST_26 is difficult to read. Abstract the decryption and signature verification into functions, with separate implementations for GMime 2.4 and 2.6, to clarify the code. There should be no functional changes.
2013-03-30 14:53:16 +01:00
(encrypteddata, cryptoctx, &decrypt_result, &err);
gmime-extra: drop compat layer for g_mime_multipart_encrypted_decrypt In practice, we're going to see this function invoked differently depending on which gmime we build against. The compatibility layer forces our code into the lowest-common-denominator -- unable to make use of new features even when built against a newer version. Dropping the compatibility layer paves the way for clearer use of features from GMime 3.0 in future commits.
2017-10-10 07:49:10 +02:00
#else
(encrypteddata, GMIME_DECRYPT_NONE, NULL, &decrypt_result, &err);
#endif
cli: mime node: abstract decryption and signature verification The code filled with #ifdef GMIME_ATLEAST_26 is difficult to read. Abstract the decryption and signature verification into functions, with separate implementations for GMime 2.4 and 2.6, to clarify the code. There should be no functional changes.
2013-03-30 14:53:16 +01:00
if (! node->decrypted_child) {
fprintf (stderr, "Failed to decrypt part: %s\n",
err ? err->message : "no error explanation given");
goto DONE;
}
cli: convert notmuch_bool_t to stdbool C99 stdbool turned 18 this year. There really is no reason to use our own, except in the library interface for backward compatibility. Convert the cli and test binaries to stdbool.
2017-10-07 10:44:04 +02:00
node->decrypt_success = true;
node->verify_attempted = true;
cli: mime node: abstract decryption and signature verification The code filled with #ifdef GMIME_ATLEAST_26 is difficult to read. Abstract the decryption and signature verification into functions, with separate implementations for GMime 2.4 and 2.6, to clarify the code. There should be no functional changes.
2013-03-30 14:53:16 +01:00
/* This may be NULL if the part is not signed. */
node->sig_list = g_mime_decrypt_result_get_signatures (decrypt_result);
if (node->sig_list) {
g_object_ref (node->sig_list);
set_signature_list_destructor (node);
}
g_object_unref (decrypt_result);
DONE:
if (err)
g_error_free (err);
}
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
static mime_node_t *
mime node: Record depth-first part numbers This makes the part numbers readily accessible to formatters. Hierarchical part numbering would be a more natural and efficient fit for MIME and may be the way to go in the future, but depth-first numbering maintains compatibility with what we currently do.
2012-01-24 00:33:09 +01:00
_mime_node_create (mime_node_t *parent, GMimeObject *part)
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
{
mime_node_t *node = talloc_zero (parent, mime_node_t);
crypto: drop pretense of notmuch_crypto_context_t notmuch_crypto_context_t was introduced (i think) as some sort of abstraction layer to make notmuch somewhat independent of GMime. But it isn't even useful for GMime 3.0 or later -- we can drop the pretense that it's some sort of abstraction in this case, and just call it what it is, GMimeCryptoContext, which is useful for building against older versions of GMime. This also renames _notmuch_crypto_get_context() to _notmuch_crypto_get_gmime_context().
2017-10-10 07:49:03 +02:00
GMimeCryptoContext *cryptoctx = NULL;
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
/* Set basic node properties */
node->part = part;
node->ctx = parent->ctx;
if (!talloc_reference (node, node->ctx)) {
fprintf (stderr, "Out of memory.\n");
talloc_free (node);
return NULL;
}
mime node: Record depth-first part numbers This makes the part numbers readily accessible to formatters. Hierarchical part numbering would be a more natural and efficient fit for MIME and may be the way to go in the future, but depth-first numbering maintains compatibility with what we currently do.
2012-01-24 00:33:09 +01:00
node->parent = parent;
node->part_num = node->next_part_num = -1;
node->next_child = 0;
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
/* Deal with the different types of parts */
if (GMIME_IS_PART (part)) {
node->nchildren = 0;
} else if (GMIME_IS_MULTIPART (part)) {
node->nchildren = g_mime_multipart_get_count (GMIME_MULTIPART (part));
} else if (GMIME_IS_MESSAGE_PART (part)) {
/* Promote part to an envelope and open it */
GMimeMessagePart *message_part = GMIME_MESSAGE_PART (part);
GMimeMessage *message = g_mime_message_part_get_message (message_part);
node->envelope_part = message_part;
node->part = GMIME_OBJECT (message);
node->nchildren = 1;
} else {
fprintf (stderr, "Warning: Unknown mime part type: %s.\n",
g_type_name (G_OBJECT_TYPE (part)));
talloc_free (node);
return NULL;
}
crypto: Avoid explicit handling of GMimeCryptoContext in gmime 3 gmime 3.0 knows how to select the correct GMimeCryptoContext automatically, so a bunch of the code in notmuch can be dropped in that case. The #ifdef removal of the crypto stuff is better than #define aliasing in gmime-extra.h for this stuff. When built against gmime 3.0: * it reduces compiled code, and * it avoids initializing unused gpgme contexts (based on a patch from dkg)
2017-07-16 01:01:45 +02:00
#if (GMIME_MAJOR_VERSION < 3)
cli: use new notmuch_crypto_get_context in mime-node.c This has the affect of lazily creating the crypto contexts only when needed. This removes code duplication from notmuch-show and notmuch-reply, and should speed up these functions considerably if the crypto flags are provided but the messages don't have any cryptographic parts.
2012-05-26 20:45:46 +02:00
if ((GMIME_IS_MULTIPART_ENCRYPTED (part) && node->ctx->crypto->decrypt)
|| (GMIME_IS_MULTIPART_SIGNED (part) && node->ctx->crypto->verify)) {
GMimeContentType *content_type = g_mime_object_get_content_type (part);
const char *protocol = g_mime_content_type_get_parameter (content_type, "protocol");
crypto: drop pretense of notmuch_crypto_context_t notmuch_crypto_context_t was introduced (i think) as some sort of abstraction layer to make notmuch somewhat independent of GMime. But it isn't even useful for GMime 3.0 or later -- we can drop the pretense that it's some sort of abstraction in this case, and just call it what it is, GMimeCryptoContext, which is useful for building against older versions of GMime. This also renames _notmuch_crypto_get_context() to _notmuch_crypto_get_gmime_context().
2017-10-10 07:49:03 +02:00
cryptoctx = _notmuch_crypto_get_gmime_context (node->ctx->crypto, protocol);
cli/crypto: treat failure to create a crypto context as fatal. Silently ignoring signed/encrypted parts seems like the wrong idea, and it also complicates future gmime-3.0 compatibility changes.
2017-07-16 01:01:43 +02:00
if (!cryptoctx)
return NULL;
cli: use new notmuch_crypto_get_context in mime-node.c This has the affect of lazily creating the crypto contexts only when needed. This removes code duplication from notmuch-show and notmuch-reply, and should speed up these functions considerably if the crypto flags are provided but the messages don't have any cryptographic parts.
2012-05-26 20:45:46 +02:00
}
crypto: Avoid explicit handling of GMimeCryptoContext in gmime 3 gmime 3.0 knows how to select the correct GMimeCryptoContext automatically, so a bunch of the code in notmuch can be dropped in that case. The #ifdef removal of the crypto stuff is better than #define aliasing in gmime-extra.h for this stuff. When built against gmime 3.0: * it reduces compiled code, and * it avoids initializing unused gpgme contexts (based on a patch from dkg)
2017-07-16 01:01:45 +02:00
#endif
cli: use new notmuch_crypto_get_context in mime-node.c This has the affect of lazily creating the crypto contexts only when needed. This removes code duplication from notmuch-show and notmuch-reply, and should speed up these functions considerably if the crypto flags are provided but the messages don't have any cryptographic parts.
2012-05-26 20:45:46 +02:00
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
/* Handle PGP/MIME parts */
cli/crypto: treat failure to create a crypto context as fatal. Silently ignoring signed/encrypted parts seems like the wrong idea, and it also complicates future gmime-3.0 compatibility changes.
2017-07-16 01:01:43 +02:00
if (GMIME_IS_MULTIPART_ENCRYPTED (part) && node->ctx->crypto->decrypt) {
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
if (node->nchildren != 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 (must be exactly 2)\n",
node->nchildren);
} else {
cli: mime node: abstract decryption and signature verification The code filled with #ifdef GMIME_ATLEAST_26 is difficult to read. Abstract the decryption and signature verification into functions, with separate implementations for GMime 2.4 and 2.6, to clarify the code. There should be no functional changes.
2013-03-30 14:53:16 +01:00
node_decrypt_and_verify (node, part, cryptoctx);
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
}
cli/crypto: treat failure to create a crypto context as fatal. Silently ignoring signed/encrypted parts seems like the wrong idea, and it also complicates future gmime-3.0 compatibility changes.
2017-07-16 01:01:43 +02:00
} else if (GMIME_IS_MULTIPART_SIGNED (part) && node->ctx->crypto->verify) {
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
if (node->nchildren != 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 "
"(must be exactly 2)\n",
node->nchildren);
} else {
cli: mime node: abstract decryption and signature verification The code filled with #ifdef GMIME_ATLEAST_26 is difficult to read. Abstract the decryption and signature verification into functions, with separate implementations for GMime 2.4 and 2.6, to clarify the code. There should be no functional changes.
2013-03-30 14:53:16 +01:00
node_verify (node, part, cryptoctx);
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
}
}
return node;
}
mime_node_t *
mime node: Record depth-first part numbers This makes the part numbers readily accessible to formatters. Hierarchical part numbering would be a more natural and efficient fit for MIME and may be the way to go in the future, but depth-first numbering maintains compatibility with what we currently do.
2012-01-24 00:33:09 +01:00
mime_node_child (mime_node_t *parent, int child)
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
{
GMimeObject *sub;
mime node: Record depth-first part numbers This makes the part numbers readily accessible to formatters. Hierarchical part numbering would be a more natural and efficient fit for MIME and may be the way to go in the future, but depth-first numbering maintains compatibility with what we currently do.
2012-01-24 00:33:09 +01:00
mime_node_t *node;
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
Avoid potentially dereferencing a NULL pointer GMIME_IS_MULTIPART and GMIME_IS_MESSAGE both handle NULL pointers gracefully, but the G_OBJECT_TYPE used in the error handling block dereferences it without checking it first. Fix this by checking whether parent->part is valid. Found using the clang static analyzer. Signed-off-by: Justus Winter <4winter@informatik.uni-hamburg.de>
2012-09-24 17:21:20 +02:00
if (!parent || !parent->part || child < 0 || child >= parent->nchildren)
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
return NULL;
if (GMIME_IS_MULTIPART (parent->part)) {
if (child == 1 && parent->decrypted_child)
sub = parent->decrypted_child;
else
sub = g_mime_multipart_get_part
(GMIME_MULTIPART (parent->part), child);
} else if (GMIME_IS_MESSAGE (parent->part)) {
sub = g_mime_message_get_mime_part (GMIME_MESSAGE (parent->part));
} else {
/* This should have been caught by message_part_create */
INTERNAL_ERROR ("Unexpected GMimeObject type: %s",
g_type_name (G_OBJECT_TYPE (parent->part)));
}
mime node: Record depth-first part numbers This makes the part numbers readily accessible to formatters. Hierarchical part numbering would be a more natural and efficient fit for MIME and may be the way to go in the future, but depth-first numbering maintains compatibility with what we currently do.
2012-01-24 00:33:09 +01:00
node = _mime_node_create (parent, sub);
if (child == parent->next_child && parent->next_part_num != -1) {
/* We're traversing in depth-first order. Record the child's
* depth-first numbering. */
node->part_num = parent->next_part_num;
node->next_part_num = node->part_num + 1;
/* Prepare the parent for its next depth-first child. */
parent->next_child++;
parent->next_part_num = -1;
if (node->nchildren == 0) {
/* We've reached a leaf, so find the parent that has more
* children and set it up to number its next child. */
mime_node_t *iter = node->parent;
while (iter && iter->next_child == iter->nchildren)
iter = iter->parent;
if (iter)
iter->next_part_num = node->part_num + 1;
}
}
return node;
Introduce a generic tree-like abstraction for MIME traversal. This wraps all of the complex MIME part handling in a single, simple function that gets part N from *any* MIME object, so traversing a MIME part tree becomes a two-line for loop. Furthermore, the MIME node structure provides easy access to envelopes for message parts as well as cryptographic information. This code is directly derived from the current show_message_body code (much of it is identical), but the control relation is inverted: instead of show_message_body controlling the traversal of the MIME structure and invoking callbacks, the caller controls the traversal of the MIME structure.
2011-12-24 19:52:44 +01:00
}
Utility function to seek in MIME trees in depth-first order. This function matches how we number parts for the --part argument to show. It will allow us to jump directly to the desired part, rather than traversing the entire tree and carefully tracking whether or not we're "in the zone".
2011-12-24 19:52:45 +01:00
static mime_node_t *
_mime_node_seek_dfs_walk (mime_node_t *node, int *n)
{
int i;
if (*n == 0)
return node;
*n -= 1;
cli: simplify mime node walk The function is more straighforward to read when it's clear that the only non-NULL return is at one place. No functional changes.
2017-01-06 21:14:49 +01:00
for (i = 0; i < node->nchildren; i++) {
Utility function to seek in MIME trees in depth-first order. This function matches how we number parts for the --part argument to show. It will allow us to jump directly to the desired part, rather than traversing the entire tree and carefully tracking whether or not we're "in the zone".
2011-12-24 19:52:45 +01:00
mime_node_t *child = mime_node_child (node, i);
cli: simplify mime node walk The function is more straighforward to read when it's clear that the only non-NULL return is at one place. No functional changes.
2017-01-06 21:14:49 +01:00
mime_node_t *ret = _mime_node_seek_dfs_walk (child, n);
if (ret)
return ret;
talloc_free (child);
Utility function to seek in MIME trees in depth-first order. This function matches how we number parts for the --part argument to show. It will allow us to jump directly to the desired part, rather than traversing the entire tree and carefully tracking whether or not we're "in the zone".
2011-12-24 19:52:45 +01:00
}
cli: simplify mime node walk The function is more straighforward to read when it's clear that the only non-NULL return is at one place. No functional changes.
2017-01-06 21:14:49 +01:00
return NULL;
Utility function to seek in MIME trees in depth-first order. This function matches how we number parts for the --part argument to show. It will allow us to jump directly to the desired part, rather than traversing the entire tree and carefully tracking whether or not we're "in the zone".
2011-12-24 19:52:45 +01:00
}
mime_node_t *
mime_node_seek_dfs (mime_node_t *node, int n)
{
if (n < 0)
return NULL;
return _mime_node_seek_dfs_walk (node, &n);
}
Reference in a new issue Copy permalink