X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch-reply.c;h=6f368c93206d152fdb93a29320a74217a51946ae;hp=7184a5dfcf887bb6fcb81bc8f1ee63171f7bb286;hb=429ebf5d20a943fb520d7321c5dde721265b0155;hpb=5fddc07dc31481453c1af186bf7da241c00cdbf1 diff --git a/notmuch-reply.c b/notmuch-reply.c index 7184a5df..6f368c93 100644 --- a/notmuch-reply.c +++ b/notmuch-reply.c @@ -98,25 +98,77 @@ format_part_reply (mime_node_t *node) format_part_reply (mime_node_child (node, i)); } -/* Is the given address configured as one of the user's "personal" or - * "other" addresses. */ -static int -address_is_users (const char *address, notmuch_config_t *config) +typedef enum { + USER_ADDRESS_IN_STRING, + STRING_IN_USER_ADDRESS, + STRING_IS_USER_ADDRESS, +} address_match_t; + +/* Match given string against given address according to mode. */ +static notmuch_bool_t +match_address (const char *str, const char *address, address_match_t mode) +{ + switch (mode) { + case USER_ADDRESS_IN_STRING: + return strcasestr (str, address) != NULL; + case STRING_IN_USER_ADDRESS: + return strcasestr (address, str) != NULL; + case STRING_IS_USER_ADDRESS: + return strcasecmp (address, str) == 0; + } + + return FALSE; +} + +/* Match given string against user's configured "primary" and "other" + * addresses according to mode. */ +static const char * +address_match (const char *str, notmuch_config_t *config, address_match_t mode) { const char *primary; const char **other; size_t i, other_len; + if (!str || *str == '\0') + return NULL; + primary = notmuch_config_get_user_primary_email (config); - if (strcasecmp (primary, address) == 0) - return 1; + if (match_address (str, primary, mode)) + return primary; other = notmuch_config_get_user_other_email (config, &other_len); - for (i = 0; i < other_len; i++) - if (strcasecmp (other[i], address) == 0) - return 1; + for (i = 0; i < other_len; i++) { + if (match_address (str, other[i], mode)) + return other[i]; + } - return 0; + return NULL; +} + +/* Does the given string contain an address configured as one of the + * user's "primary" or "other" addresses. If so, return the matching + * address, NULL otherwise. */ +static const char * +user_address_in_string (const char *str, notmuch_config_t *config) +{ + return address_match (str, config, USER_ADDRESS_IN_STRING); +} + +/* Do any of the addresses configured as one of the user's "primary" + * or "other" addresses contain the given string. If so, return the + * matching address, NULL otherwise. */ +static const char * +string_in_user_address (const char *str, notmuch_config_t *config) +{ + return address_match (str, config, STRING_IN_USER_ADDRESS); +} + +/* Is the given address configured as one of the user's "primary" or + * "other" addresses. */ +static notmuch_bool_t +address_is_users (const char *address, notmuch_config_t *config) +{ + return address_match (address, config, STRING_IS_USER_ADDRESS) != NULL; } /* Scan addresses in 'list'. @@ -325,19 +377,18 @@ add_recipients_from_message (GMimeMessage *reply, static const char * guess_from_received_header (notmuch_config_t *config, notmuch_message_t *message) { - const char *received,*primary,*by; - const char **other; - char *tohdr; + const char *addr, *received, *by; char *mta,*ptr,*token; char *domain=NULL; char *tld=NULL; const char *delim=". \t"; - size_t i,j,other_len; + size_t i; - const char *to_headers[] = {"Envelope-to", "X-Original-To"}; - - primary = notmuch_config_get_user_primary_email (config); - other = notmuch_config_get_user_other_email (config, &other_len); + const char *to_headers[] = { + "Envelope-to", + "X-Original-To", + "Delivered-To", + }; /* sadly, there is no standard way to find out to which email * address a mail was delivered - what is in the headers depends @@ -348,28 +399,19 @@ guess_from_received_header (notmuch_config_t *config, notmuch_message_t *message * the To: or Cc: header. From here we try the following in order: * 1) check for an Envelope-to: header * 2) check for an X-Original-To: header - * 3) check for a (for ) clause in Received: headers - * 4) check for the domain part of known email addresses in the + * 3) check for a Delivered-To: header + * 4) check for a (for ) clause in Received: headers + * 5) check for the domain part of known email addresses in the * 'by' part of Received headers * If none of these work, we give up and return NULL */ - for (i = 0; i < sizeof(to_headers)/sizeof(*to_headers); i++) { - tohdr = xstrdup(notmuch_message_get_header (message, to_headers[i])); - if (tohdr && *tohdr) { - /* tohdr is potentialy a list of email addresses, so here we - * check if one of the email addresses is a substring of tohdr - */ - if (strcasestr(tohdr, primary)) { - free(tohdr); - return primary; - } - for (j = 0; j < other_len; j++) - if (strcasestr (tohdr, other[j])) { - free(tohdr); - return other[j]; - } - free(tohdr); - } + for (i = 0; i < ARRAY_SIZE (to_headers); i++) { + const char *tohdr = notmuch_message_get_header (message, to_headers[i]); + + /* Note: tohdr potentially contains a list of email addresses. */ + addr = user_address_in_string (tohdr, config); + if (addr) + return addr; } /* We get the concatenated Received: headers and search from the @@ -387,19 +429,12 @@ guess_from_received_header (notmuch_config_t *config, notmuch_message_t *message * header */ ptr = strstr (received, " for "); - if (ptr) { - /* the text following is potentialy a list of email addresses, - * so again we check if one of the email addresses is a - * substring of ptr - */ - if (strcasestr(ptr, primary)) { - return primary; - } - for (i = 0; i < other_len; i++) - if (strcasestr (ptr, other[i])) { - return other[i]; - } - } + + /* Note: ptr potentially contains a list of email addresses. */ + addr = user_address_in_string (ptr, config); + if (addr) + return addr; + /* Finally, we parse all the " by MTA ..." headers to guess the * email address that this was originally delivered to. * We extract just the MTA here by removing leading whitespace and @@ -440,15 +475,11 @@ guess_from_received_header (notmuch_config_t *config, notmuch_message_t *message */ *(tld-1) = '.'; - if (strcasestr(primary, domain)) { - free(mta); - return primary; + addr = string_in_user_address (domain, config); + if (addr) { + free (mta); + return addr; } - for (i = 0; i < other_len; i++) - if (strcasestr (other[i],domain)) { - free(mta); - return other[i]; - } } free (mta); } @@ -544,8 +575,7 @@ notmuch_reply_format_default(void *ctx, g_object_unref (G_OBJECT (reply)); reply = NULL; - if (mime_node_open (ctx, message, params->cryptoctx, params->decrypt, - &root) == NOTMUCH_STATUS_SUCCESS) { + if (mime_node_open (ctx, message, &(params->crypto), &root) == NOTMUCH_STATUS_SUCCESS) { format_part_reply (root); talloc_free (root); } @@ -574,8 +604,7 @@ notmuch_reply_format_json(void *ctx, messages = notmuch_query_search_messages (query); message = notmuch_messages_get (messages); - if (mime_node_open (ctx, message, params->cryptoctx, params->decrypt, - &node) != NOTMUCH_STATUS_SUCCESS) + if (mime_node_open (ctx, message, &(params->crypto), &node) != NOTMUCH_STATUS_SUCCESS) return 1; reply = create_reply_message (ctx, config, message, reply_all); @@ -675,7 +704,12 @@ notmuch_reply_command (void *ctx, int argc, char *argv[]) char *query_string; int opt_index, ret = 0; int (*reply_format_func)(void *ctx, notmuch_config_t *config, notmuch_query_t *query, notmuch_show_params_t *params, notmuch_bool_t reply_all); - notmuch_show_params_t params = { .part = -1 }; + notmuch_show_params_t params = { + .part = -1, + .crypto = { + .decrypt = FALSE + } + }; int format = FORMAT_DEFAULT; int reply_all = TRUE; @@ -689,7 +723,7 @@ notmuch_reply_command (void *ctx, int argc, char *argv[]) (notmuch_keyword_t []){ { "all", TRUE }, { "sender", FALSE }, { 0, 0 } } }, - { NOTMUCH_OPT_BOOLEAN, ¶ms.decrypt, "decrypt", 'd', 0 }, + { NOTMUCH_OPT_BOOLEAN, ¶ms.crypto.decrypt, "decrypt", 'd', 0 }, { 0, 0, 0, 0, 0 } }; @@ -706,18 +740,18 @@ notmuch_reply_command (void *ctx, int argc, char *argv[]) else reply_format_func = notmuch_reply_format_default; - if (params.decrypt) { + if (params.crypto.decrypt) { #ifdef GMIME_ATLEAST_26 /* TODO: GMimePasswordRequestFunc */ - params.cryptoctx = g_mime_gpg_context_new (NULL, "gpg"); + params.crypto.gpgctx = g_mime_gpg_context_new (NULL, "gpg"); #else GMimeSession* session = g_object_new (g_mime_session_get_type(), NULL); - params.cryptoctx = g_mime_gpg_context_new (session, "gpg"); + params.crypto.gpgctx = g_mime_gpg_context_new (session, "gpg"); #endif - if (params.cryptoctx) { - g_mime_gpg_context_set_always_trust ((GMimeGpgContext*) params.cryptoctx, FALSE); + if (params.crypto.gpgctx) { + g_mime_gpg_context_set_always_trust ((GMimeGpgContext*) params.crypto.gpgctx, FALSE); } else { - params.decrypt = FALSE; + params.crypto.decrypt = FALSE; fprintf (stderr, "Failed to construct gpg context.\n"); } #ifndef GMIME_ATLEAST_26 @@ -753,11 +787,9 @@ notmuch_reply_command (void *ctx, int argc, char *argv[]) if (reply_format_func (ctx, config, query, ¶ms, reply_all) != 0) return 1; + notmuch_crypto_cleanup (¶ms.crypto); notmuch_query_destroy (query); notmuch_database_destroy (notmuch); - if (params.cryptoctx) - g_object_unref(params.cryptoctx); - return ret; }