X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch-reply.c;h=5adbab624ad7a2cbb17a6a7b5a98b8feca8937f7;hp=ac46d0265f53cba48c04e303f7672444180fc547;hb=a843fa48fedb7a3ce02af412404ba4359cdce5e0;hpb=dc51bf0ad4ce84414e79d2f30752502f7c0d46c0 diff --git a/notmuch-reply.c b/notmuch-reply.c index ac46d026..5adbab62 100644 --- a/notmuch-reply.c +++ b/notmuch-reply.c @@ -14,13 +14,14 @@ * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with this program. If not, see http://www.gnu.org/licenses/ . + * along with this program. If not, see https://www.gnu.org/licenses/ . * * Authors: Carl Worth * Keith Packard */ #include "notmuch-client.h" +#include "string-util.h" #include "sprinter.h" static void @@ -79,7 +80,8 @@ format_part_reply (mime_node_t *node) show_text_part_content (node->part, stream_stdout, NOTMUCH_SHOW_TEXT_PART_REPLY); g_object_unref(stream_stdout); } else if (disposition && - strcmp (disposition->disposition, GMIME_DISPOSITION_ATTACHMENT) == 0) { + strcasecmp (g_mime_content_disposition_get_disposition (disposition), + GMIME_DISPOSITION_ATTACHMENT) == 0) { const char *filename = g_mime_part_get_filename (GMIME_PART (node->part)); printf ("Attachment: %s (%s)\n", filename, g_mime_content_type_to_string (content_type)); @@ -322,7 +324,7 @@ add_recipients_from_message (GMimeMessage *reply, unsigned int n = 0; /* Some mailing lists munge the Reply-To header despite it being A Bad - * Thing, see http://www.unicom.com/pw/reply-to-harmful.html + * Thing, see http://marc.merlins.org/netrants/reply-to-harmful.html * * The munging is easy to detect, because it results in a * redundant reply-to header, (with an address that already exists @@ -330,7 +332,7 @@ add_recipients_from_message (GMimeMessage *reply, * field and use the From header. This ensures the original sender * will get the reply even if not subscribed to the list. Note * that the address in the Reply-To header will always appear in - * the reply. + * the reply if reply_all is true. */ if (reply_to_header_is_redundant (message)) { reply_to_map[0].header = "from"; @@ -369,78 +371,44 @@ add_recipients_from_message (GMimeMessage *reply, return from_addr; } +/* + * Look for the user's address in " for " in the + * received headers. + * + * Return the address that was found, if any, and NULL otherwise. + */ static const char * -guess_from_received_header (notmuch_config_t *config, notmuch_message_t *message) +guess_from_in_received_for (notmuch_config_t *config, const char *received) { - const char *addr, *received, *by; - char *mta,*ptr,*token; - char *domain=NULL; - char *tld=NULL; - const char *delim=". \t"; - size_t i; - - 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 - * on the MTAs used along the way. So we are trying a number of - * heuristics which hopefully will answer this question. - - * We only got here if none of the users email addresses are in - * 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 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 < ARRAY_SIZE (to_headers); i++) { - const char *tohdr = notmuch_message_get_header (message, to_headers[i]); + const char *ptr; - /* 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 - * front (last Received: header added) and try to extract from - * them indications to which email address this message was - * delivered. - * The Received: header is special in our get_header function - * and is always concatenated. - */ - received = notmuch_message_get_header (message, "received"); - if (received == NULL) + ptr = strstr (received, " for "); + if (! ptr) return NULL; - /* First we look for a " for " in the received - * header - */ - ptr = strstr (received, " for "); + return user_address_in_string (ptr, config); +} - /* 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 - * assuming that the MTA name ends at the next whitespace. - * We test for *(by+4) to be non-'\0' to make sure there's - * something there at all - and then assume that the first - * whitespace delimited token that follows is the receiving - * system in this step of the receive chain - */ - by = received; - while((by = strstr (by, " by ")) != NULL) { +/* + * Parse all the " by MTA ..." parts in received headers to guess the + * email address that this was originally delivered to. + * + * Extract just the MTA here by removing leading whitespace and + * assuming that the MTA name ends at the next whitespace. Test for + * *(by+4) to be non-'\0' to make sure there's something there at all + * - and then assume that the first whitespace delimited token that + * follows is the receiving system in this step of the receive chain. + * + * Return the address that was found, if any, and NULL otherwise. + */ +static const char * +guess_from_in_received_by (notmuch_config_t *config, const char *received) +{ + const char *addr; + const char *by = received; + char *domain, *tld, *mta, *ptr, *token; + + while ((by = strstr (by, " by ")) != NULL) { by += 4; if (*by == '\0') break; @@ -450,11 +418,12 @@ guess_from_received_header (notmuch_config_t *config, notmuch_message_t *message free (mta); break; } - /* Now extract the last two components of the MTA host name - * as domain and tld. + /* + * Now extract the last two components of the MTA host name as + * domain and tld. */ domain = tld = NULL; - while ((ptr = strsep (&token, delim)) != NULL) { + while ((ptr = strsep (&token, ". \t")) != NULL) { if (*ptr == '\0') continue; domain = tld; @@ -462,13 +431,14 @@ guess_from_received_header (notmuch_config_t *config, notmuch_message_t *message } if (domain) { - /* Recombine domain and tld and look for it among the configured - * email addresses. - * This time we have a known domain name and nothing else - so - * the test is the other way around: we check if this is a - * substring of one of the email addresses. + /* + * Recombine domain and tld and look for it among the + * configured email addresses. This time we have a known + * domain name and nothing else - so the test is the other + * way around: we check if this is a substring of one of + * the email addresses. */ - *(tld-1) = '.'; + *(tld - 1) = '.'; addr = string_in_user_address (domain, config); if (addr) { @@ -482,6 +452,70 @@ guess_from_received_header (notmuch_config_t *config, notmuch_message_t *message return NULL; } +/* + * Get the concatenated Received: headers and search from the front + * (last Received: header added) and try to extract from them + * indications to which email address this message was delivered. + * + * The Received: header is special in our get_header function and is + * always concatenated. + * + * Return the address that was found, if any, and NULL otherwise. + */ +static const char * +guess_from_in_received_headers (notmuch_config_t *config, + notmuch_message_t *message) +{ + const char *received, *addr; + char *sanitized; + + received = notmuch_message_get_header (message, "received"); + if (! received) + return NULL; + + sanitized = sanitize_string (NULL, received); + if (! sanitized) + return NULL; + + addr = guess_from_in_received_for (config, sanitized); + if (! addr) + addr = guess_from_in_received_by (config, sanitized); + + talloc_free (sanitized); + + return addr; +} + +/* + * Try to find user's email address in one of the extra To-like + * headers: Envelope-To, X-Original-To, and Delivered-To (searched in + * that order). + * + * Return the address that was found, if any, and NULL otherwise. + */ +static const char * +get_from_in_to_headers (notmuch_config_t *config, notmuch_message_t *message) +{ + size_t i; + const char *tohdr, *addr; + const char *to_headers[] = { + "Envelope-to", + "X-Original-To", + "Delivered-To", + }; + + for (i = 0; i < ARRAY_SIZE (to_headers); i++) { + 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; + } + + return NULL; +} + static GMimeMessage * create_reply_message(void *ctx, notmuch_config_t *config, @@ -508,9 +542,30 @@ create_reply_message(void *ctx, from_addr = add_recipients_from_message (reply, config, message, reply_all); + /* + * Sadly, there is no standard way to find out to which email + * address a mail was delivered - what is in the headers depends + * on the MTAs used along the way. + * + * If none of the user's email addresses are in the To: or Cc: + * headers, we try a number of heuristics which hopefully will + * answer this question. + * + * First, check for Envelope-To:, X-Original-To:, and + * Delivered-To: headers. + */ if (from_addr == NULL) - from_addr = guess_from_received_header (config, message); + from_addr = get_from_in_to_headers (config, message); + /* + * Check for a (for ) clause in Received: headers, + * and the domain part of known email addresses in the 'by' part + * of Received: headers + */ + if (from_addr == NULL) + from_addr = guess_from_in_received_headers (config, message); + + /* Default to user's primary address. */ if (from_addr == NULL) from_addr = notmuch_config_get_user_primary_email (config); @@ -543,68 +598,42 @@ create_reply_message(void *ctx, static int notmuch_reply_format_default(void *ctx, notmuch_config_t *config, - notmuch_query_t *query, + notmuch_message_t *message, notmuch_show_params_t *params, notmuch_bool_t reply_all, unused (sprinter_t *sp)) { GMimeMessage *reply; - notmuch_messages_t *messages; - notmuch_message_t *message; mime_node_t *root; - for (messages = notmuch_query_search_messages (query); - notmuch_messages_valid (messages); - notmuch_messages_move_to_next (messages)) - { - message = notmuch_messages_get (messages); - - reply = create_reply_message (ctx, config, message, reply_all); - - /* If reply creation failed, we're out of memory, so don't - * bother trying any more messages. - */ - if (!reply) { - notmuch_message_destroy (message); - return 1; - } - - show_reply_headers (reply); + reply = create_reply_message (ctx, config, message, reply_all); + if (!reply) + return 1; - g_object_unref (G_OBJECT (reply)); - reply = NULL; + show_reply_headers (reply); - if (mime_node_open (ctx, message, &(params->crypto), &root) == NOTMUCH_STATUS_SUCCESS) { - format_part_reply (root); - talloc_free (root); - } + g_object_unref (G_OBJECT (reply)); - notmuch_message_destroy (message); + if (mime_node_open (ctx, message, ¶ms->crypto, &root) == NOTMUCH_STATUS_SUCCESS) { + format_part_reply (root); + talloc_free (root); } + return 0; } static int notmuch_reply_format_sprinter(void *ctx, notmuch_config_t *config, - notmuch_query_t *query, + notmuch_message_t *message, notmuch_show_params_t *params, notmuch_bool_t reply_all, sprinter_t *sp) { GMimeMessage *reply; - notmuch_messages_t *messages; - notmuch_message_t *message; mime_node_t *node; - if (notmuch_query_count_messages (query) != 1) { - fprintf (stderr, "Error: search term did not match precisely one message.\n"); - return 1; - } - - messages = notmuch_query_search_messages (query); - message = notmuch_messages_get (messages); - if (mime_node_open (ctx, message, &(params->crypto), &node) != NOTMUCH_STATUS_SUCCESS) + if (mime_node_open (ctx, message, ¶ms->crypto, &node) != NOTMUCH_STATUS_SUCCESS) return 1; reply = create_reply_message (ctx, config, message, reply_all); @@ -617,15 +646,13 @@ notmuch_reply_format_sprinter(void *ctx, sp->map_key (sp, "reply-headers"); format_headers_sprinter (sp, reply, TRUE); g_object_unref (G_OBJECT (reply)); - reply = NULL; /* Start the original */ sp->map_key (sp, "original"); - format_part_sprinter (ctx, sp, node, TRUE, TRUE); + format_part_sprinter (ctx, sp, node, TRUE, TRUE, FALSE); /* End */ sp->end (sp); - notmuch_message_destroy (message); return 0; } @@ -634,60 +661,45 @@ notmuch_reply_format_sprinter(void *ctx, static int notmuch_reply_format_headers_only(void *ctx, notmuch_config_t *config, - notmuch_query_t *query, + notmuch_message_t *message, unused (notmuch_show_params_t *params), notmuch_bool_t reply_all, unused (sprinter_t *sp)) { GMimeMessage *reply; - notmuch_messages_t *messages; - notmuch_message_t *message; const char *in_reply_to, *orig_references, *references; - char *reply_headers; - for (messages = notmuch_query_search_messages (query); - notmuch_messages_valid (messages); - notmuch_messages_move_to_next (messages)) - { - message = notmuch_messages_get (messages); - - /* The 0 means we do not want headers in a "pretty" order. */ - reply = g_mime_message_new (0); - if (reply == NULL) { - fprintf (stderr, "Out of memory\n"); - return 1; - } - - in_reply_to = talloc_asprintf (ctx, "<%s>", - notmuch_message_get_message_id (message)); + /* The 0 means we do not want headers in a "pretty" order. */ + reply = g_mime_message_new (0); + if (reply == NULL) { + fprintf (stderr, "Out of memory\n"); + return 1; + } - g_mime_object_set_header (GMIME_OBJECT (reply), - "In-Reply-To", in_reply_to); + in_reply_to = talloc_asprintf (ctx, "<%s>", + notmuch_message_get_message_id (message)); + g_mime_object_set_header (GMIME_OBJECT (reply), "In-Reply-To", in_reply_to); - orig_references = notmuch_message_get_header (message, "references"); + orig_references = notmuch_message_get_header (message, "references"); - /* We print In-Reply-To followed by References because git format-patch treats them - * specially. Git does not interpret the other headers specially - */ - references = talloc_asprintf (ctx, "%s%s%s", - orig_references ? orig_references : "", - orig_references ? " " : "", - in_reply_to); - g_mime_object_set_header (GMIME_OBJECT (reply), - "References", references); + /* + * We print In-Reply-To followed by References because git + * format-patch treats them specially. Git does not interpret the + * other headers specially. + */ + references = talloc_asprintf (ctx, "%s%s%s", + orig_references ? orig_references : "", + orig_references ? " " : "", + in_reply_to); + g_mime_object_set_header (GMIME_OBJECT (reply), "References", references); - (void)add_recipients_from_message (reply, config, message, reply_all); + (void)add_recipients_from_message (reply, config, message, reply_all); - reply_headers = g_mime_object_to_string (GMIME_OBJECT (reply)); - printf ("%s", reply_headers); - free (reply_headers); + show_reply_headers (reply); - g_object_unref (G_OBJECT (reply)); - reply = NULL; + g_object_unref (G_OBJECT (reply)); - notmuch_message_destroy (message); - } return 0; } @@ -698,29 +710,87 @@ enum { FORMAT_HEADERS_ONLY, }; -int -notmuch_reply_command (notmuch_config_t *config, int argc, char *argv[]) +static int do_reply(notmuch_config_t *config, + notmuch_query_t *query, + notmuch_show_params_t *params, + int format, + notmuch_bool_t reply_all) { - notmuch_database_t *notmuch; - notmuch_query_t *query; - char *query_string; - int opt_index, ret = 0; + notmuch_messages_t *messages; + notmuch_message_t *message; + notmuch_status_t status; + struct sprinter *sp = NULL; + int ret = 0; int (*reply_format_func) (void *ctx, notmuch_config_t *config, - notmuch_query_t *query, + notmuch_message_t *message, notmuch_show_params_t *params, notmuch_bool_t reply_all, struct sprinter *sp); + + if (format == FORMAT_JSON || format == FORMAT_SEXP) { + unsigned count; + + status = notmuch_query_count_messages_st (query, &count); + if (print_status_query ("notmuch reply", query, status)) + return 1; + + if (count != 1) { + fprintf (stderr, "Error: search term did not match precisely one message (matched %d messages).\n", count); + return 1; + } + } + + if (format == FORMAT_HEADERS_ONLY) { + reply_format_func = notmuch_reply_format_headers_only; + } else if (format == FORMAT_JSON) { + reply_format_func = notmuch_reply_format_sprinter; + sp = sprinter_json_create (config, stdout); + } else if (format == FORMAT_SEXP) { + reply_format_func = notmuch_reply_format_sprinter; + sp = sprinter_sexp_create (config, stdout); + } else { + reply_format_func = notmuch_reply_format_default; + } + + status = notmuch_query_search_messages_st (query, &messages); + if (print_status_query ("notmuch reply", query, status)) + return 1; + + for (; + notmuch_messages_valid (messages); + notmuch_messages_move_to_next (messages)) + { + message = notmuch_messages_get (messages); + + ret = reply_format_func(config, config, message, params, reply_all, sp); + + notmuch_message_destroy (message); + + if (ret) + break; + } + + return ret; +} + +int +notmuch_reply_command (notmuch_config_t *config, int argc, char *argv[]) +{ + notmuch_database_t *notmuch; + notmuch_query_t *query; + char *query_string; + int opt_index; notmuch_show_params_t params = { .part = -1, .crypto = { .verify = FALSE, - .decrypt = FALSE + .decrypt = FALSE, + .gpgpath = NULL } }; int format = FORMAT_DEFAULT; int reply_all = TRUE; - struct sprinter *sp = NULL; notmuch_opt_desc_t options[] = { { NOTMUCH_OPT_KEYWORD, &format, "format", 'f', @@ -735,56 +805,49 @@ notmuch_reply_command (notmuch_config_t *config, int argc, char *argv[]) { "sender", FALSE }, { 0, 0 } } }, { NOTMUCH_OPT_BOOLEAN, ¶ms.crypto.decrypt, "decrypt", 'd', 0 }, + { NOTMUCH_OPT_INHERIT, (void *) ¬much_shared_options, NULL, 0, 0 }, { 0, 0, 0, 0, 0 } }; opt_index = parse_arguments (argc, argv, options, 1); - if (opt_index < 0) { - /* diagnostics already printed */ - return 1; - } + if (opt_index < 0) + return EXIT_FAILURE; - if (format == FORMAT_HEADERS_ONLY) { - reply_format_func = notmuch_reply_format_headers_only; - } else if (format == FORMAT_JSON) { - reply_format_func = notmuch_reply_format_sprinter; - sp = sprinter_json_create (config, stdout); - } else if (format == FORMAT_SEXP) { - reply_format_func = notmuch_reply_format_sprinter; - sp = sprinter_sexp_create (config, stdout); - } else { - reply_format_func = notmuch_reply_format_default; - } + notmuch_process_shared_options (argv[0]); notmuch_exit_if_unsupported_format (); query_string = query_string_from_args (config, argc-opt_index, argv+opt_index); if (query_string == NULL) { fprintf (stderr, "Out of memory\n"); - return 1; + return EXIT_FAILURE; } if (*query_string == '\0') { fprintf (stderr, "Error: notmuch reply requires at least one search term.\n"); - return 1; + return EXIT_FAILURE; } + params.crypto.gpgpath = notmuch_config_get_crypto_gpg_path (config); + if (notmuch_database_open (notmuch_config_get_database_path (config), NOTMUCH_DATABASE_MODE_READ_ONLY, ¬much)) - return 1; + return EXIT_FAILURE; + + notmuch_exit_if_unmatched_db_uuid (notmuch); query = notmuch_query_create (notmuch, query_string); if (query == NULL) { fprintf (stderr, "Out of memory\n"); - return 1; + return EXIT_FAILURE; } - if (reply_format_func (config, config, query, ¶ms, reply_all, sp) != 0) - return 1; + if (do_reply (config, query, ¶ms, format, reply_all) != 0) + return EXIT_FAILURE; notmuch_crypto_cleanup (¶ms.crypto); notmuch_query_destroy (query); notmuch_database_destroy (notmuch); - return ret; + return EXIT_SUCCESS; }