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

516 lines
15 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>
*/
cli/notmuch-show: support gzipped files This drops "file" from mime_node_context and just uses a local variable. It also uses the new gzip aware utility routines recently added to util/gmime-extra.c. The use of gzopen / gzfile in addition is a bit icky, but the choice is between that, and providing yet another readline implimentation that understands GMime streams.
2019-03-24 04:32:44 +01:00
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
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
#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. */
GMimeStream *stream;
GMimeParser *parser;
GMimeMessage *mime_message;
cli: expose message-wide crypto status from mime-node The mime node context (a per-message context) gains a cryptographic status object, and the mime_node_t object itself can return a view on that status to an interested party. The status is not yet populated, and for now we can keep that view read-only, so that it can only be populated/modified during MIME tree traversal.
2019-05-25 20:04:04 +02:00
_notmuch_message_crypto_t *msg_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
cli/{show,reply}: use repaired form of "Mixed Up" mangled messages When showing or replying to a message that has been mangled in transit by an MTA in the "Mixed up" way, notmuch should instead use the repaired form of the message. Tracking the repaired GMimeObject for the lifetime of the mime_node so that it is cleaned up properly is probably the trickiest part of this patch, but the choices here are based on the idea that the mime_node_context is the memory manager for the whole mime_node tree in the first place, so new GMimeObject tree created on-the-fly during message parsing should be disposed of in the same place. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-28 20:46:48 +02:00
/* repaired/unmangled parts that will need to be cleaned up */
GSList *repaired_parts;
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
/* 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);
cli/{show,reply}: use repaired form of "Mixed Up" mangled messages When showing or replying to a message that has been mangled in transit by an MTA in the "Mixed up" way, notmuch should instead use the repaired form of the message. Tracking the repaired GMimeObject for the lifetime of the mime_node so that it is cleaned up properly is probably the trickiest part of this patch, but the choices here are based on the idea that the mime_node_context is the memory manager for the whole mime_node tree in the first place, so new GMimeObject tree created on-the-fly during message parsing should be disposed of in the same place. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-28 20:46:48 +02:00
if (res->repaired_parts)
g_slist_free_full (res->repaired_parts, g_object_unref);
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 0;
}
cli/{show,reply}: use repaired form of "Mixed Up" mangled messages When showing or replying to a message that has been mangled in transit by an MTA in the "Mixed up" way, notmuch should instead use the repaired form of the message. Tracking the repaired GMimeObject for the lifetime of the mime_node so that it is cleaned up properly is probably the trickiest part of this patch, but the choices here are based on the idea that the mime_node_context is the memory manager for the whole mime_node tree in the first place, so new GMimeObject tree created on-the-fly during message parsing should be disposed of in the same place. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-28 20:46:48 +02:00
/* keep track of objects that need to be destroyed when the mime node
* context goes away. */
static void
_mime_node_context_track_repaired_part (mime_node_context_t *ctx, GMimeObject *part)
{
if (part)
ctx->repaired_parts = g_slist_prepend (ctx->repaired_parts, part);
}
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory
2019-06-13 12:31:01 +02:00
const _notmuch_message_crypto_t *
cli: expose message-wide crypto status from mime-node The mime node context (a per-message context) gains a cryptographic status object, and the mime_node_t object itself can return a view on that status to an interested party. The status is not yet populated, and for now we can keep that view read-only, so that it can only be populated/modified during MIME tree traversal.
2019-05-25 20:04:04 +02:00
mime_node_get_message_crypto_status (mime_node_t *node)
{
return node->ctx->msg_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
notmuch_status_t
mime_node_open (const void *ctx, notmuch_message_t *message,
CLI/show: support --duplicate for structured output This introduces a new mandatory key for message structures, namely "duplicate". Per convention in devel/schemata this does _not_ increase the format version. This means that clients are responsible for checking that it exists, and not crashing if it does not. The main functional change is teaching mime_node_open to understand a 'duplicate' argument. Support for --duplicate in notmuch-reply would make sense, but we defer it to a later commit.
2022-07-01 23:45:44 +02:00
int duplicate,
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;
CLI/show: support --duplicate for structured output This introduces a new mandatory key for message structures, namely "duplicate". Per convention in devel/schemata this does _not_ increase the format version. This means that clients are responsible for checking that it exists, and not crashing if it does not. The main functional change is teaching mime_node_open to understand a 'duplicate' argument. Support for --duplicate in notmuch-reply would make sense, but we defer it to a later commit.
2022-07-01 23:45:44 +02:00
int fd = -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 = 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 */
CLI/show: support --duplicate for structured output This introduces a new mandatory key for message structures, namely "duplicate". Per convention in devel/schemata this does _not_ increase the format version. This means that clients are responsible for checking that it exists, and not crashing if it does not. The main functional change is teaching mime_node_open to understand a 'duplicate' argument. Support for --duplicate in notmuch-reply would make sense, but we defer it to a later commit.
2022-07-01 23:45:44 +02:00
if (duplicate <= 0)
fd = open (filename, O_RDONLY);
cli/notmuch-show: support gzipped files This drops "file" from mime_node_context and just uses a local variable. It also uses the new gzip aware utility routines recently added to util/gmime-extra.c. The use of gzopen / gzfile in addition is a bit icky, but the choice is between that, and providing yet another readline implimentation that understands GMime streams.
2019-03-24 04:32:44 +01:00
if (fd == -1) {
CLI/show: support --duplicate for structured output This introduces a new mandatory key for message structures, namely "duplicate". Per convention in devel/schemata this does _not_ increase the format version. This means that clients are responsible for checking that it exists, and not crashing if it does not. The main functional change is teaching mime_node_open to understand a 'duplicate' argument. Support for --duplicate in notmuch-reply would make sense, but we defer it to a later commit.
2022-07-01 23:45:44 +02:00
/* Slow path - Either we are trying to open a specific file, or
* for some reason the first file in the list is
* not available anymore. The latter is clearly a problem in the
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
* database, but we are not going to let this problem be a
* show stopper */
notmuch_filenames_t *filenames;
CLI/show: support --duplicate for structured output This introduces a new mandatory key for message structures, namely "duplicate". Per convention in devel/schemata this does _not_ increase the format version. This means that clients are responsible for checking that it exists, and not crashing if it does not. The main functional change is teaching mime_node_open to understand a 'duplicate' argument. Support for --duplicate in notmuch-reply would make sense, but we defer it to a later commit.
2022-07-01 23:45:44 +02:00
int i = 1;
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
for (filenames = notmuch_message_get_filenames (message);
notmuch_filenames_valid (filenames);
CLI/show: support --duplicate for structured output This introduces a new mandatory key for message structures, namely "duplicate". Per convention in devel/schemata this does _not_ increase the format version. This means that clients are responsible for checking that it exists, and not crashing if it does not. The main functional change is teaching mime_node_open to understand a 'duplicate' argument. Support for --duplicate in notmuch-reply would make sense, but we defer it to a later commit.
2022-07-01 23:45:44 +02:00
notmuch_filenames_move_to_next (filenames), i++) {
if (i >= duplicate) {
filename = notmuch_filenames_get (filenames);
fd = open (filename, O_RDONLY);
if (fd != -1) {
break;
} else {
if (duplicate > 0) {
fprintf (stderr, "Error opening %s: %s\n", filename, strerror (errno));
status = NOTMUCH_STATUS_FILE_ERROR;
goto DONE;
}
}
}
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
}
talloc_free (filenames);
cli/notmuch-show: support gzipped files This drops "file" from mime_node_context and just uses a local variable. It also uses the new gzip aware utility routines recently added to util/gmime-extra.c. The use of gzopen / gzfile in addition is a bit icky, but the choice is between that, and providing yet another readline implimentation that understands GMime streams.
2019-03-24 04:32:44 +01:00
if (fd == -1) {
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
/* Give up */
fprintf (stderr, "Error opening %s: %s\n", filename, strerror (errno));
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory
2019-06-13 12:31:01 +02:00
status = NOTMUCH_STATUS_FILE_ERROR;
goto DONE;
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
}
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory
2019-06-13 12:31:01 +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
cli/notmuch-show: support gzipped files This drops "file" from mime_node_context and just uses a local variable. It also uses the new gzip aware utility routines recently added to util/gmime-extra.c. The use of gzopen / gzfile in addition is a bit icky, but the choice is between that, and providing yet another readline implimentation that understands GMime streams.
2019-03-24 04:32:44 +01:00
mctx->stream = g_mime_stream_gzfile_new (fd);
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory
2019-06-13 12:31:01 +02:00
if (! mctx->stream) {
Handle errors in mime_node_open
2012-03-06 19:26:57 +01:00
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->parser = g_mime_parser_new_with_stream (mctx->stream);
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory
2019-06-13 12:31:01 +02:00
if (! mctx->parser) {
Handle errors in mime_node_open
2012-03-06 19:26:57 +01:00
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
gmime-cleanup: pass NULL as default GMimeParserOptions This is a functional change, not a straight translation, because we are no longer directly invoking g_mime_parser_options_get_default(), but the GMime source has indicated that the options parameter for g_mime_parser_construct_message() is "nullable" since upstream commit d0ebdd2ea3e6fa635a2a551c846e9bc8b6040353 (which itself precedes GMime 3.0). Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-02 15:19:46 +02:00
mctx->mime_message = g_mime_parser_construct_message (mctx->parser, NULL);
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory
2019-06-13 12:31:01 +02:00
if (! mctx->mime_message) {
Handle errors in mime_node_open
2012-03-06 19:26:57 +01:00
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
mime-node: track whole-message crypto state while walking the tree Deliberately populate the message's cryptographic status while walking the MIME tree from the CLI. Note that the additional numchild argument added to _mime_node_create is a passthrough needed to be able to adequately populate the crypto state object.
2019-05-25 20:04:05 +02:00
mctx->msg_crypto = _notmuch_message_crypto_new (mctx);
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;
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory
2019-06-13 12:31:01 +02:00
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
talloc_free (root);
return status;
}
build: drop support for gmime-2.6 GMime 3.0 is over 2 years old now, and 2.6 has been deprecated in notmuch for about 1.5 years. Comments and documentation no longer need to refer to GMime 2.6, so clean them all up. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-02 15:19:33 +02:00
/* Signature list destructor */
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
build: drop support for gmime-2.6 GMime 3.0 is over 2 years old now, and 2.6 has been deprecated in notmuch for about 1.5 years. Comments and documentation no longer need to refer to GMime 2.6, so clean them all up. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-02 15:19:33 +02:00
/* Set up signature list destructor */
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
static void
set_signature_list_destructor (mime_node_t *node)
{
GMimeSignatureList **proxy = talloc (node, GMimeSignatureList *);
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory
2019-06-13 12:31:01 +02:00
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 (proxy) {
*proxy = node->sig_list;
talloc_set_destructor (proxy, _signature_list_free);
}
}
mime-node: Clean up unwrapped MIME parts correctly. Avoid a memory leak in the notmuch command line. gmime_multipart_encrypted_decrypt returns a GMimeObject marked by GMime as "transfer full", so we are supposed to clean up after it. When parsing a message, notmuch would leak one GMimeObject part per multipart/encrypted MIME layer. We clean it up by analogy with cleaning up the signature list associated with a MIME node. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-03-19 06:41:45 +01:00
/* Unwrapped MIME part destructor */
static int
_unwrapped_child_free (GMimeObject **proxy)
{
g_object_unref (*proxy);
return 0;
}
/* Set up unwrapped MIME part destructor */
static void
set_unwrapped_child_destructor (mime_node_t *node)
{
GMimeObject **proxy = talloc (node, GMimeObject *);
if (proxy) {
*proxy = node->unwrapped_child;
talloc_set_destructor (proxy, _unwrapped_child_free);
}
}
build: drop support for gmime-2.6 GMime 3.0 is over 2 years old now, and 2.6 has been deprecated in notmuch for about 1.5 years. Comments and documentation no longer need to refer to GMime 2.6, so clean them all up. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-02 15:19:33 +02:00
/* Verify a signed mime node */
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
static void
gmime-cleanup: drop all arguments unused in GMime 3 This means dropping GMimeCryptoContext and notmuch_config arguments. All the argument changes are to internal functions, so this is not an API or ABI break. We also get to drop the #define for g_mime_3_unused. signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-02 15:19:41 +02:00
node_verify (mime_node_t *node, GMimeObject *part)
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;
mime-node: track whole-message crypto state while walking the tree Deliberately populate the message's cryptographic status while walking the MIME tree from the CLI. Note that the additional numchild argument added to _mime_node_create is a passthrough needed to be able to adequately populate the crypto state object.
2019-05-25 20:04:05 +02:00
notmuch_status_t 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
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: include wrapped part of PKCS#7 SignedData in the MIME tree Unwrap a PKCS#7 SignedData part unconditionally when the cli is traversing the MIME tree, and return it as a "child" of what would otherwise be a leaf in the tree. Unfortunately, this also breaks the JSON output. We will fix that next. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-05-13 00:29:33 +02:00
if (GMIME_IS_APPLICATION_PKCS7_MIME (part))
node->sig_list = g_mime_application_pkcs7_mime_verify (
GMIME_APPLICATION_PKCS7_MIME (part), GMIME_VERIFY_NONE, &node->unwrapped_child, &err);
else
node->sig_list = g_mime_multipart_signed_verify (
GMIME_MULTIPART_SIGNED (part), GMIME_VERIFY_NONE, &err);
if (node->unwrapped_child) {
node->nchildren = 1;
set_unwrapped_child_destructor (node);
}
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->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);
mime-node: track whole-message crypto state while walking the tree Deliberately populate the message's cryptographic status while walking the MIME tree from the CLI. Note that the additional numchild argument added to _mime_node_create is a passthrough needed to be able to adequately populate the crypto state object.
2019-05-25 20:04:05 +02:00
status = _notmuch_message_crypto_potential_sig_list (node->ctx->msg_crypto, node->sig_list);
if (status) /* this is a warning, not an error */
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory Line breaks were then adjusted manually to keep argc and argv together.
2021-03-13 13:45:34 +01:00
fprintf (stderr, "Warning: failed to note signature status: %s.\n", notmuch_status_to_string (
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
}
build: drop support for gmime-2.6 GMime 3.0 is over 2 years old now, and 2.6 has been deprecated in notmuch for about 1.5 years. Comments and documentation no longer need to refer to GMime 2.6, so clean them all up. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-02 15:19:33 +02:00
/* Decrypt and optionally verify an encrypted mime node */
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
static void
gmime-cleanup: drop all arguments unused in GMime 3 This means dropping GMimeCryptoContext and notmuch_config arguments. All the argument changes are to internal functions, so this is not an API or ABI break. We also get to drop the #define for g_mime_3_unused. signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-02 15:19:41 +02:00
node_decrypt_and_verify (mime_node_t *node, GMimeObject *part)
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;
mime-node: track whole-message crypto state while walking the tree Deliberately populate the message's cryptographic status while walking the MIME tree from the CLI. Note that the additional numchild argument added to _mime_node_create is a passthrough needed to be able to adequately populate the crypto state object.
2019-05-25 20:04:05 +02:00
notmuch_status_t status;
cli: write session keys to database, if asked to do so If the decryption policy is NOTMUCH_DECRYPT_TRUE, that means we want to stash session keys in the database. Note that there is currently no way from the command line to set it this way, though, so it is not yet included in the test suite.
2018-05-11 08:57:56 +02:00
notmuch_message_t *message = NULL;
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
mime-node: rename decrypted_child to unwrapped_child When walking the MIME tree, we might need to extract a new MIME object. Thus far, we've only done it when decrypting multipart/encrypted messages, but PKCS#7 (RFC 8551, S/MIME) has several other transformations that warrant a comparable form of unwrapping. Make this member re-usable for PKCS#7 unwrappings as well as multipart/encrypted decryptions. This change is just a naming change, it has no effect on function. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-03-19 06:41:44 +01:00
if (! node->unwrapped_child) {
cli: write session keys to database, if asked to do so If the decryption policy is NOTMUCH_DECRYPT_TRUE, that means we want to stash session keys in the database. Note that there is currently no way from the command line to set it this way, though, so it is not yet included in the test suite.
2018-05-11 08:57:56 +02:00
for (mime_node_t *parent = node; parent; parent = parent->parent)
if (parent->envelope_file) {
message = parent->envelope_file;
crypto: use stashed session-key properties for decryption, if available When doing any decryption, if the notmuch database knows of any session keys associated with the message in question, try them before defaulting to using default symmetric crypto. This changeset does the primary work in _notmuch_crypto_decrypt, which grows some new parameters to handle it. The primary advantage this patch offers is a significant speedup when rendering large encrypted threads ("notmuch show") if session keys happen to be cached. Additionally, it permits message composition without access to asymmetric secret keys ("notmuch reply"); and it permits recovering a cleartext index when reindexing after a "notmuch restore" for those messages that already have a session key stored. Note that we may try multiple decryptions here (e.g. if there are multiple session keys in the database), but we will ignore and throw away all the GMime errors except for those that come from last decryption attempt. Since we don't necessarily know at the time of the decryption that this *is* the last decryption attempt, we'll ask for the errors each time anyway. This does nothing if no session keys are stashed in the database, which is fine. Actually stashing session keys in the database will come as a subsequent patch.
2017-11-30 09:59:29 +01:00
break;
cli: write session keys to database, if asked to do so If the decryption policy is NOTMUCH_DECRYPT_TRUE, that means we want to stash session keys in the database. Note that there is currently no way from the command line to set it this way, though, so it is not yet included in the test suite.
2018-05-11 08:57:56 +02:00
}
crypto: use stashed session-key properties for decryption, if available When doing any decryption, if the notmuch database knows of any session keys associated with the message in question, try them before defaulting to using default symmetric crypto. This changeset does the primary work in _notmuch_crypto_decrypt, which grows some new parameters to handle it. The primary advantage this patch offers is a significant speedup when rendering large encrypted threads ("notmuch show") if session keys happen to be cached. Additionally, it permits message composition without access to asymmetric secret keys ("notmuch reply"); and it permits recovering a cleartext index when reindexing after a "notmuch restore" for those messages that already have a session key stored. Note that we may try multiple decryptions here (e.g. if there are multiple session keys in the database), but we will ignore and throw away all the GMime errors except for those that come from last decryption attempt. Since we don't necessarily know at the time of the decryption that this *is* the last decryption attempt, we'll ask for the errors each time anyway. This does nothing if no session keys are stashed in the database, which is fine. Actually stashing session keys in the database will come as a subsequent patch.
2017-11-30 09:59:29 +01:00
mime-node: rename decrypted_child to unwrapped_child When walking the MIME tree, we might need to extract a new MIME object. Thus far, we've only done it when decrypting multipart/encrypted messages, but PKCS#7 (RFC 8551, S/MIME) has several other transformations that warrant a comparable form of unwrapping. Make this member re-usable for PKCS#7 unwrappings as well as multipart/encrypted decryptions. This change is just a naming change, it has no effect on function. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-03-19 06:41:44 +01:00
node->unwrapped_child = _notmuch_crypto_decrypt (&node->decrypt_attempted,
crypto: record whether an actual decryption attempt happened In our consolidation of _notmuch_crypto_decrypt, the callers lost track a little bit of whether any actual decryption was attempted. Now that we have the more-subtle "auto" policy, it's possible that _notmuch_crypto_decrypt could be called without having any actual decryption take place. This change lets the callers be a little bit smarter about whether or not any decryption was actually attempted.
2017-12-08 07:23:58 +01:00
node->ctx->crypto->decrypt,
cli: write session keys to database, if asked to do so If the decryption policy is NOTMUCH_DECRYPT_TRUE, that means we want to stash session keys in the database. Note that there is currently no way from the command line to set it this way, though, so it is not yet included in the test suite.
2018-05-11 08:57:56 +02:00
message,
crypto: Make _notmuch_crypto_decrypt take a GMimeObject As we prepare to handle S/MIME-encrypted PKCS#7 EnvelopedData (which is not multipart), we don't want to be limited to passing only GMimeMultipartEncrypted MIME parts to _notmuch_crypto_decrypt. There is no functional change here, just a matter of adjusting how we pass arguments internally. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-05-13 00:29:36 +02:00
part, &decrypt_result, &err);
mime-node: Clean up unwrapped MIME parts correctly. Avoid a memory leak in the notmuch command line. gmime_multipart_encrypted_decrypt returns a GMimeObject marked by GMime as "transfer full", so we are supposed to clean up after it. When parsing a message, notmuch would leak one GMimeObject part per multipart/encrypted MIME layer. We clean it up by analogy with cleaning up the signature list associated with a MIME node. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-03-19 06:41:45 +01:00
if (node->unwrapped_child)
set_unwrapped_child_destructor (node);
crypto: use stashed session-key properties for decryption, if available When doing any decryption, if the notmuch database knows of any session keys associated with the message in question, try them before defaulting to using default symmetric crypto. This changeset does the primary work in _notmuch_crypto_decrypt, which grows some new parameters to handle it. The primary advantage this patch offers is a significant speedup when rendering large encrypted threads ("notmuch show") if session keys happen to be cached. Additionally, it permits message composition without access to asymmetric secret keys ("notmuch reply"); and it permits recovering a cleartext index when reindexing after a "notmuch restore" for those messages that already have a session key stored. Note that we may try multiple decryptions here (e.g. if there are multiple session keys in the database), but we will ignore and throw away all the GMime errors except for those that come from last decryption attempt. Since we don't necessarily know at the time of the decryption that this *is* the last decryption attempt, we'll ask for the errors each time anyway. This does nothing if no session keys are stashed in the database, which is fine. Actually stashing session keys in the database will come as a subsequent patch.
2017-11-30 09:59:29 +01:00
}
mime-node: rename decrypted_child to unwrapped_child When walking the MIME tree, we might need to extract a new MIME object. Thus far, we've only done it when decrypting multipart/encrypted messages, but PKCS#7 (RFC 8551, S/MIME) has several other transformations that warrant a comparable form of unwrapping. Make this member re-usable for PKCS#7 unwrappings as well as multipart/encrypted decryptions. This change is just a naming change, it has no effect on function. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-03-19 06:41:44 +01:00
if (! node->unwrapped_child) {
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
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;
mime-node: track whole-message crypto state while walking the tree Deliberately populate the message's cryptographic status while walking the MIME tree from the CLI. Note that the additional numchild argument added to _mime_node_create is a passthrough needed to be able to adequately populate the crypto state object.
2019-05-25 20:04:05 +02:00
status = _notmuch_message_crypto_successful_decryption (node->ctx->msg_crypto);
if (status) /* this is a warning, not an error */
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory Line breaks were then adjusted manually to keep argc and argv together.
2021-03-13 13:45:34 +01:00
fprintf (stderr, "Warning: failed to note decryption status: %s.\n",
notmuch_status_to_string (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
mime-node: handle decrypt_result more safely If (for whatever reason) we don't get a decrypt_result back, or it's not structured the way we expect it to be, we shouldn't choke on it.
2017-11-30 09:59:26 +01:00
if (decrypt_result) {
/* 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) {
crypto: Avoid pretending to verify signatures on unsigned encrypted mail Unsigned encrypted mail shows up with a weird empty signature list. If we successfully decrypted and there was no signature in it, we should just not show a sigstatus at all. The documentation for g_mime_decrypt_result_get_signatures says: a GMimeSignatureList or NULL if the stream was not signed.
2019-04-20 19:02:57 +02:00
node->verify_attempted = true;
mime-node: handle decrypt_result more safely If (for whatever reason) we don't get a decrypt_result back, or it's not structured the way we expect it to be, we shouldn't choke on it.
2017-11-30 09:59:26 +01:00
g_object_ref (node->sig_list);
set_signature_list_destructor (node);
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory Line breaks were then adjusted manually to keep argc and argv together.
2021-03-13 13:45:34 +01:00
status = _notmuch_message_crypto_potential_sig_list (node->ctx->msg_crypto,
node->sig_list);
mime-node: track whole-message crypto state while walking the tree Deliberately populate the message's cryptographic status while walking the MIME tree from the CLI. Note that the additional numchild argument added to _mime_node_create is a passthrough needed to be able to adequately populate the crypto state object.
2019-05-25 20:04:05 +02:00
if (status) /* this is a warning, not an error */
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory Line breaks were then adjusted manually to keep argc and argv together.
2021-03-13 13:45:34 +01:00
fprintf (stderr, "Warning: failed to note signature status: %s.\n",
notmuch_status_to_string (status));
mime-node: handle decrypt_result more safely If (for whatever reason) we don't get a decrypt_result back, or it's not structured the way we expect it to be, we shouldn't choke on it.
2017-11-30 09:59:26 +01:00
}
cli: write session keys to database, if asked to do so If the decryption policy is NOTMUCH_DECRYPT_TRUE, that means we want to stash session keys in the database. Note that there is currently no way from the command line to set it this way, though, so it is not yet included in the test suite.
2018-05-11 08:57:56 +02:00
if (node->ctx->crypto->decrypt == NOTMUCH_DECRYPT_TRUE && message) {
notmuch_database_t *db = notmuch_message_get_database (message);
const char *session_key = g_mime_decrypt_result_get_session_key (decrypt_result);
if (db && session_key)
print_status_message ("Failed to stash session key in the database",
message,
notmuch_message_add_property (message, "session-key",
session_key));
}
mime-node: handle decrypt_result more safely If (for whatever reason) we don't get a decrypt_result back, or it's not structured the way we expect it to be, we shouldn't choke on it.
2017-11-30 09:59:26 +01:00
g_object_unref (decrypt_result);
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
}
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory
2019-06-13 12:31:01 +02:00
DONE:
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 (err)
g_error_free (err);
}
mime-node: split out _mime_node_set_up_part This is a code reorganization that should have no functional effect, but will make future changes simpler, because a future commit will reuse the _mime_node_set_up_part functionality without touching _mime_node_create. In the course of splitting out this function, I noticed a comment in the codebase that referred to an older name of _mime_node_create (message_part_create), where this functionality originally resided. I've fixed that comment to refer to the new function instead. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-08-29 17:38:46 +02:00
static bool
_mime_node_set_up_part (mime_node_t *node, GMimeObject *part, int numchild);
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: track whole-message crypto state while walking the tree Deliberately populate the message's cryptographic status while walking the MIME tree from the CLI. Note that the additional numchild argument added to _mime_node_create is a passthrough needed to be able to adequately populate the crypto state object.
2019-05-25 20:04:05 +02:00
_mime_node_create (mime_node_t *parent, GMimeObject *part, int numchild)
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);
/* Set basic node properties */
node->ctx = parent->ctx;
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory
2019-06-13 12:31:01 +02:00
if (! talloc_reference (node, node->ctx)) {
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
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
mime-node: split out _mime_node_set_up_part This is a code reorganization that should have no functional effect, but will make future changes simpler, because a future commit will reuse the _mime_node_set_up_part functionality without touching _mime_node_create. In the course of splitting out this function, I noticed a comment in the codebase that referred to an older name of _mime_node_create (message_part_create), where this functionality originally resided. I've fixed that comment to refer to the new function instead. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-08-29 17:38:46 +02:00
if (_mime_node_set_up_part (node, part, numchild))
return node;
talloc_free (node);
return NULL;
}
/* associate a MIME part with a node. */
static bool
_mime_node_set_up_part (mime_node_t *node, GMimeObject *part, int numchild)
{
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)) {
mime-node: split out _mime_node_set_up_part This is a code reorganization that should have no functional effect, but will make future changes simpler, because a future commit will reuse the _mime_node_set_up_part functionality without touching _mime_node_create. In the course of splitting out this function, I noticed a comment in the codebase that referred to an older name of _mime_node_create (message_part_create), where this functionality originally resided. I've fixed that comment to refer to the new function instead. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-08-29 17:38:46 +02:00
node->part = 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
node->nchildren = 0;
} else if (GMIME_IS_MULTIPART (part)) {
cli/{show,reply}: use repaired form of "Mixed Up" mangled messages When showing or replying to a message that has been mangled in transit by an MTA in the "Mixed up" way, notmuch should instead use the repaired form of the message. Tracking the repaired GMimeObject for the lifetime of the mime_node so that it is cleaned up properly is probably the trickiest part of this patch, but the choices here are based on the idea that the mime_node_context is the memory manager for the whole mime_node tree in the first place, so new GMimeObject tree created on-the-fly during message parsing should be disposed of in the same place. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-28 20:46:48 +02:00
GMimeObject *repaired_part = _notmuch_repair_mixed_up_mangled (part);
if (repaired_part) {
/* This was likely "Mixed Up" in transit! We replace it
* with the more likely-to-be-correct variant. */
_mime_node_context_track_repaired_part (node->ctx, repaired_part);
part = repaired_part;
}
mime-node: split out _mime_node_set_up_part This is a code reorganization that should have no functional effect, but will make future changes simpler, because a future commit will reuse the _mime_node_set_up_part functionality without touching _mime_node_create. In the course of splitting out this function, I noticed a comment in the codebase that referred to an older name of _mime_node_create (message_part_create), where this functionality originally resided. I've fixed that comment to refer to the new function instead. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-08-29 17:38:46 +02:00
node->part = 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
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)));
mime-node: split out _mime_node_set_up_part This is a code reorganization that should have no functional effect, but will make future changes simpler, because a future commit will reuse the _mime_node_set_up_part functionality without touching _mime_node_create. In the course of splitting out this function, I noticed a comment in the codebase that referred to an older name of _mime_node_create (message_part_create), where this functionality originally resided. I've fixed that comment to refer to the new function instead. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-08-29 17:38:46 +02:00
return 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
}
mime-node: split out _mime_node_set_up_part This is a code reorganization that should have no functional effect, but will make future changes simpler, because a future commit will reuse the _mime_node_set_up_part functionality without touching _mime_node_create. In the course of splitting out this function, I noticed a comment in the codebase that referred to an older name of _mime_node_create (message_part_create), where this functionality originally resided. I've fixed that comment to refer to the new function instead. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-08-29 17:38:46 +02:00
/* Handle PGP/MIME parts (by definition not cryptographic payload parts) */
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory Line breaks were then adjusted manually to keep argc and argv together.
2021-03-13 13:45:34 +01:00
if (GMIME_IS_MULTIPART_ENCRYPTED (part) && (node->ctx->crypto->decrypt !=
NOTMUCH_DECRYPT_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
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 {
gmime-cleanup: drop all arguments unused in GMime 3 This means dropping GMimeCryptoContext and notmuch_config arguments. All the argument changes are to internal functions, so this is not an API or ABI break. We also get to drop the #define for g_mime_3_unused. signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-02 15:19:41 +02:00
node_decrypt_and_verify (node, 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
}
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 {
gmime-cleanup: drop all arguments unused in GMime 3 This means dropping GMimeCryptoContext and notmuch_config arguments. All the argument changes are to internal functions, so this is not an API or ABI break. We also get to drop the #define for g_mime_3_unused. signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-05-02 15:19:41 +02:00
node_verify (node, 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
}
cli: include wrapped part of PKCS#7 SignedData in the MIME tree Unwrap a PKCS#7 SignedData part unconditionally when the cli is traversing the MIME tree, and return it as a "child" of what would otherwise be a leaf in the tree. Unfortunately, this also breaks the JSON output. We will fix that next. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-05-13 00:29:33 +02:00
} else if (GMIME_IS_APPLICATION_PKCS7_MIME (part) &&
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory Line breaks were then adjusted manually to keep argc and argv together.
2021-03-13 13:45:34 +01:00
GMIME_SECURE_MIME_TYPE_SIGNED_DATA == g_mime_application_pkcs7_mime_get_smime_type (
GMIME_APPLICATION_PKCS7_MIME (part))) {
cli: include wrapped part of PKCS#7 SignedData in the MIME tree Unwrap a PKCS#7 SignedData part unconditionally when the cli is traversing the MIME tree, and return it as a "child" of what would otherwise be a leaf in the tree. Unfortunately, this also breaks the JSON output. We will fix that next. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-05-13 00:29:33 +02:00
/* If node->ctx->crypto->verify is false, it would be better
* to just unwrap (instead of verifying), but
* https://github.com/jstedfast/gmime/issues/67 */
node_verify (node, part);
smime: Pass PKCS#7 envelopedData to node_decrypt_and_verify This change means we can support "notmuch show --decrypt=true" for S/MIME encrypted messages, resolving several outstanding broken tests, including all the remaining S/MIME protected header examples. We do not yet handle indexing the cleartext of S/MIME encrypted messages, though. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-05-13 00:29:38 +02:00
} else if (GMIME_IS_APPLICATION_PKCS7_MIME (part) &&
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory Line breaks were then adjusted manually to keep argc and argv together.
2021-03-13 13:45:34 +01:00
GMIME_SECURE_MIME_TYPE_ENVELOPED_DATA == g_mime_application_pkcs7_mime_get_smime_type (
GMIME_APPLICATION_PKCS7_MIME (part)) &&
smime: Pass PKCS#7 envelopedData to node_decrypt_and_verify This change means we can support "notmuch show --decrypt=true" for S/MIME encrypted messages, resolving several outstanding broken tests, including all the remaining S/MIME protected header examples. We do not yet handle indexing the cleartext of S/MIME encrypted messages, though. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-05-13 00:29:38 +02:00
(node->ctx->crypto->decrypt != NOTMUCH_DECRYPT_FALSE)) {
node_decrypt_and_verify (node, part);
if (node->unwrapped_child && node->nchildren == 0)
node->nchildren = 1;
mime-node: track whole-message crypto state while walking the tree Deliberately populate the message's cryptographic status while walking the MIME tree from the CLI. Note that the additional numchild argument added to _mime_node_create is a passthrough needed to be able to adequately populate the crypto state object.
2019-05-25 20:04:05 +02:00
} else {
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory Line breaks were then adjusted manually to keep argc and argv together.
2021-03-13 13:45:34 +01:00
if (_notmuch_message_crypto_potential_payload (node->ctx->msg_crypto, part, node->parent ?
node->parent->part : NULL, numchild) &&
cli/{show,reply}: skip over legacy-display parts Make use of the previous changes to fast-forward past any legacy-display parts during "notmuch show" and "notmuch reply". Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-08-29 17:38:52 +02:00
node->ctx->msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL) {
GMimeObject *clean_payload = _notmuch_repair_crypto_payload_skip_legacy_display (part);
if (clean_payload != part) {
/* only one layer of recursion is possible here
* because there can be only a single cryptographic
* payload: */
return _mime_node_set_up_part (node, clean_payload, numchild);
}
}
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: split out _mime_node_set_up_part This is a code reorganization that should have no functional effect, but will make future changes simpler, because a future commit will reuse the _mime_node_set_up_part functionality without touching _mime_node_create. In the course of splitting out this function, I noticed a comment in the codebase that referred to an older name of _mime_node_create (message_part_create), where this functionality originally resided. I've fixed that comment to refer to the new function instead. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-08-29 17:38:46 +02:00
return true;
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 *
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
cli: run uncrustify This is the result of running $ uncrustify --replace --config devel/uncrustify.cfg *.c *.h in the top level source directory
2019-06-13 12:31:01 +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)) {
mime-node: rename decrypted_child to unwrapped_child When walking the MIME tree, we might need to extract a new MIME object. Thus far, we've only done it when decrypting multipart/encrypted messages, but PKCS#7 (RFC 8551, S/MIME) has several other transformations that warrant a comparable form of unwrapping. Make this member re-usable for PKCS#7 unwrappings as well as multipart/encrypted decryptions. This change is just a naming change, it has no effect on function. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-03-19 06:41:44 +01:00
if (child == GMIME_MULTIPART_ENCRYPTED_CONTENT && parent->unwrapped_child)
sub = parent->unwrapped_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
else
CLI: replace some constructs with more uncrustify friendly ones In particular - use (bool) instead of !! - cuddle the opening parens of function calls - add parens in some ternery operators
2019-06-13 00:47:20 +02:00
sub = g_mime_multipart_get_part (
GMIME_MULTIPART (parent->part), 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
} else if (GMIME_IS_MESSAGE (parent->part)) {
sub = g_mime_message_get_mime_part (GMIME_MESSAGE (parent->part));
cli: include wrapped part of PKCS#7 SignedData in the MIME tree Unwrap a PKCS#7 SignedData part unconditionally when the cli is traversing the MIME tree, and return it as a "child" of what would otherwise be a leaf in the tree. Unfortunately, this also breaks the JSON output. We will fix that next. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2020-05-13 00:29:33 +02:00
} else if (GMIME_IS_APPLICATION_PKCS7_MIME (parent->part) &&
parent->unwrapped_child &&
child == 0) {
sub = parent->unwrapped_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
} else {
mime-node: split out _mime_node_set_up_part This is a code reorganization that should have no functional effect, but will make future changes simpler, because a future commit will reuse the _mime_node_set_up_part functionality without touching _mime_node_create. In the course of splitting out this function, I noticed a comment in the codebase that referred to an older name of _mime_node_create (message_part_create), where this functionality originally resided. I've fixed that comment to refer to the new function instead. Signed-off-by: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
2019-08-29 17:38:46 +02:00
/* This should have been caught by _mime_node_set_up_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
INTERNAL_ERROR ("Unexpected GMimeObject type: %s",
g_type_name (G_OBJECT_TYPE (parent->part)));
}
mime-node: track whole-message crypto state while walking the tree Deliberately populate the message's cryptographic status while walking the MIME tree from the CLI. Note that the additional numchild argument added to _mime_node_create is a passthrough needed to be able to adequately populate the crypto state object.
2019-05-25 20:04:05 +02:00
node = _mime_node_create (parent, sub, child);
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
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