X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch-reply.c;h=98034485c546080f48a8c1a9161a584d65fb7412;hp=47993d223090ee423b7c42126122dcd688215c8b;hb=536b1f9df989915161024d2334e206f538d59f9b;hpb=998a8a95c3cd19950b78c50912345669952ba3eb diff --git a/notmuch-reply.c b/notmuch-reply.c index 47993d22..98034485 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)); @@ -190,6 +192,9 @@ scan_address_list (InternetAddressList *list, int i; unsigned int n = 0; + if (list == NULL) + return 0; + for (i = 0; i < internet_address_list_length (list); i++) { address = internet_address_list_get_address (list, i); if (INTERNET_ADDRESS_IS_GROUP (address)) { @@ -198,9 +203,6 @@ scan_address_list (InternetAddressList *list, group = INTERNET_ADDRESS_GROUP (address); group_list = internet_address_group_get_members (group); - if (group_list == NULL) - continue; - n += scan_address_list (group_list, config, message, type, user_from); } else { InternetAddressMailbox *mailbox; @@ -225,46 +227,17 @@ scan_address_list (InternetAddressList *list, return n; } -/* Scan addresses in 'recipients'. - * - * See the documentation of scan_address_list() above. This function - * does exactly the same, but converts 'recipients' to an - * InternetAddressList first. - */ -static unsigned int -scan_address_string (const char *recipients, - notmuch_config_t *config, - GMimeMessage *message, - GMimeRecipientType type, - const char **user_from) -{ - InternetAddressList *list; - - if (recipients == NULL) - return 0; - - list = internet_address_list_parse_string (recipients); - if (list == NULL) - return 0; - - return scan_address_list (list, config, message, type, user_from); -} - /* Does the address in the Reply-To header of 'message' already appear * in either the 'To' or 'Cc' header of the message? */ static int -reply_to_header_is_redundant (notmuch_message_t *message) +reply_to_header_is_redundant (notmuch_message_t *message, const char *reply_to) { - const char *reply_to, *to, *cc, *addr; + const char *to, *cc, *addr; InternetAddressList *list; InternetAddress *address; InternetAddressMailbox *mailbox; - reply_to = notmuch_message_get_header (message, "reply-to"); - if (reply_to == NULL || *reply_to == '\0') - return 0; - list = internet_address_list_parse_string (reply_to); if (internet_address_list_length (list) != 1) @@ -289,6 +262,55 @@ reply_to_header_is_redundant (notmuch_message_t *message) return 0; } +static InternetAddressList *get_sender(notmuch_message_t *message, + GMimeMessage *mime_message) +{ + const char *reply_to; + + reply_to = g_mime_message_get_reply_to (mime_message); + if (reply_to && *reply_to) { + /* + * Some mailing lists munge the Reply-To header despite it + * being A Bad 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 in either To or Cc). So in this case, we ignore the + * Reply-To 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 if reply_all is true. + */ + if (! reply_to_header_is_redundant (message, reply_to)) + return internet_address_list_parse_string (reply_to); + } + + return internet_address_list_parse_string ( + g_mime_message_get_sender (mime_message)); +} + +static InternetAddressList *get_to(unused(notmuch_message_t *message), + GMimeMessage *mime_message) +{ + return g_mime_message_get_recipients (mime_message, + GMIME_RECIPIENT_TYPE_TO); +} + +static InternetAddressList *get_cc(unused(notmuch_message_t *message), + GMimeMessage *mime_message) +{ + return g_mime_message_get_recipients (mime_message, + GMIME_RECIPIENT_TYPE_CC); +} + +static InternetAddressList *get_bcc(unused(notmuch_message_t *message), + GMimeMessage *mime_message) +{ + return g_mime_message_get_recipients (mime_message, + GMIME_RECIPIENT_TYPE_BCC); +} + /* Augment the recipients of 'reply' from the "Reply-to:", "From:", * "To:", "Cc:", and "Bcc:" headers of 'message'. * @@ -305,49 +327,30 @@ static const char * add_recipients_from_message (GMimeMessage *reply, notmuch_config_t *config, notmuch_message_t *message, + GMimeMessage *mime_message, notmuch_bool_t reply_all) { struct { - const char *header; - const char *fallback; + InternetAddressList * (*get_header)(notmuch_message_t *message, + GMimeMessage *mime_message); GMimeRecipientType recipient_type; } reply_to_map[] = { - { "reply-to", "from", GMIME_RECIPIENT_TYPE_TO }, - { "to", NULL, GMIME_RECIPIENT_TYPE_TO }, - { "cc", NULL, GMIME_RECIPIENT_TYPE_CC }, - { "bcc", NULL, GMIME_RECIPIENT_TYPE_BCC } + { get_sender, GMIME_RECIPIENT_TYPE_TO }, + { get_to, GMIME_RECIPIENT_TYPE_TO }, + { get_cc, GMIME_RECIPIENT_TYPE_CC }, + { get_bcc, GMIME_RECIPIENT_TYPE_BCC }, }; const char *from_addr = NULL; unsigned int i; 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 - * - * The munging is easy to detect, because it results in a - * redundant reply-to header, (with an address that already exists - * in either To or Cc). So in this case, we ignore the Reply-To - * 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. - */ - if (reply_to_header_is_redundant (message)) { - reply_to_map[0].header = "from"; - reply_to_map[0].fallback = NULL; - } - for (i = 0; i < ARRAY_SIZE (reply_to_map); i++) { - const char *recipients; + InternetAddressList *recipients; - recipients = notmuch_message_get_header (message, - reply_to_map[i].header); - if ((recipients == NULL || recipients[0] == '\0') && reply_to_map[i].fallback) - recipients = notmuch_message_get_header (message, - reply_to_map[i].fallback); + recipients = reply_to_map[i].get_header (message, mime_message); - n += scan_address_string (recipients, config, reply, - reply_to_map[i].recipient_type, &from_addr); + n += scan_address_list (recipients, config, reply, + reply_to_map[i].recipient_type, &from_addr); if (!reply_all && n) { /* Stop adding new recipients in reply-to-sender mode if @@ -465,14 +468,21 @@ 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; - addr = guess_from_in_received_for (config, received); + 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, received); + addr = guess_from_in_received_by (config, sanitized); + + talloc_free (sanitized); return addr; } @@ -511,27 +521,43 @@ static GMimeMessage * create_reply_message(void *ctx, notmuch_config_t *config, notmuch_message_t *message, - notmuch_bool_t reply_all) + GMimeMessage *mime_message, + notmuch_bool_t reply_all, + notmuch_bool_t limited) { const char *subject, *from_addr = NULL; const char *in_reply_to, *orig_references, *references; - /* The 1 means we want headers in a "pretty" order. */ - GMimeMessage *reply = g_mime_message_new (1); + /* + * Use the below header order for limited headers, "pretty" order + * otherwise. + */ + GMimeMessage *reply = g_mime_message_new (limited ? 0 : 1); if (reply == NULL) { fprintf (stderr, "Out of memory\n"); return NULL; } - subject = notmuch_message_get_header (message, "subject"); - if (subject) { - if (strncasecmp (subject, "Re:", 3)) - subject = talloc_asprintf (ctx, "Re: %s", subject); - g_mime_message_set_subject (reply, subject); - } + in_reply_to = talloc_asprintf (ctx, "<%s>", + notmuch_message_get_message_id (message)); - from_addr = add_recipients_from_message (reply, config, - message, reply_all); + g_mime_object_set_header (GMIME_OBJECT (reply), "In-Reply-To", in_reply_to); + + orig_references = notmuch_message_get_header (message, "references"); + if (orig_references && *orig_references) + references = talloc_asprintf (ctx, "%s %s", orig_references, + in_reply_to); + else + references = talloc_strdup (ctx, in_reply_to); + + g_mime_object_set_header (GMIME_OBJECT (reply), "References", references); + + from_addr = add_recipients_from_message (reply, config, message, + mime_message, reply_all); + + /* The above is all that is needed for limited headers. */ + if (limited) + return reply; /* * Sadly, there is no standard way to find out to which email @@ -563,187 +589,103 @@ create_reply_message(void *ctx, from_addr = talloc_asprintf (ctx, "%s <%s>", notmuch_config_get_user_name (config), from_addr); - g_mime_object_set_header (GMIME_OBJECT (reply), - "From", from_addr); - - in_reply_to = talloc_asprintf (ctx, "<%s>", - notmuch_message_get_message_id (message)); + g_mime_object_set_header (GMIME_OBJECT (reply), "From", from_addr); - g_mime_object_set_header (GMIME_OBJECT (reply), - "In-Reply-To", in_reply_to); - - orig_references = notmuch_message_get_header (message, "references"); - if (!orig_references) - /* Treat errors like missing References headers. */ - orig_references = ""; - 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); + subject = notmuch_message_get_header (message, "subject"); + if (subject) { + if (strncasecmp (subject, "Re:", 3)) + subject = talloc_asprintf (ctx, "Re: %s", subject); + g_mime_message_set_subject (reply, subject); + } return reply; } -static int -notmuch_reply_format_default(void *ctx, - notmuch_config_t *config, - notmuch_query_t *query, - notmuch_show_params_t *params, - notmuch_bool_t reply_all, - unused (sprinter_t *sp)) +enum { + FORMAT_DEFAULT, + FORMAT_JSON, + FORMAT_SEXP, + FORMAT_HEADERS_ONLY, +}; + +static int do_reply(notmuch_config_t *config, + notmuch_query_t *query, + notmuch_show_params_t *params, + int format, + notmuch_bool_t reply_all) { GMimeMessage *reply; + mime_node_t *node; 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); + notmuch_status_t status; + struct sprinter *sp = NULL; - reply = create_reply_message (ctx, config, message, reply_all); + if (format == FORMAT_JSON || format == FORMAT_SEXP) { + unsigned count; - /* If reply creation failed, we're out of memory, so don't - * bother trying any more messages. - */ - if (!reply) { - notmuch_message_destroy (message); + status = notmuch_query_count_messages_st (query, &count); + if (print_status_query ("notmuch reply", query, status)) return 1; - } - show_reply_headers (reply); - - g_object_unref (G_OBJECT (reply)); - reply = NULL; - - if (mime_node_open (ctx, message, &(params->crypto), &root) == NOTMUCH_STATUS_SUCCESS) { - format_part_reply (root); - talloc_free (root); + if (count != 1) { + fprintf (stderr, "Error: search term did not match precisely one message (matched %d messages).\n", count); + return 1; } - notmuch_message_destroy (message); - } - return 0; -} - -static int -notmuch_reply_format_sprinter(void *ctx, - notmuch_config_t *config, - notmuch_query_t *query, - 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; + if (format == FORMAT_JSON) + sp = sprinter_json_create (config, stdout); + else + sp = sprinter_sexp_create (config, stdout); } - messages = notmuch_query_search_messages (query); - message = notmuch_messages_get (messages); - if (mime_node_open (ctx, message, &(params->crypto), &node) != NOTMUCH_STATUS_SUCCESS) + status = notmuch_query_search_messages_st (query, &messages); + if (print_status_query ("notmuch reply", query, status)) return 1; - reply = create_reply_message (ctx, config, message, reply_all); - if (!reply) - return 1; - - sp->begin_map (sp); - - /* The headers of the reply message we've created */ - 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, FALSE); - - /* End */ - sp->end (sp); - notmuch_message_destroy (message); - - return 0; -} - -/* This format is currently tuned for a git send-email --notmuch hook */ -static int -notmuch_reply_format_headers_only(void *ctx, - notmuch_config_t *config, - notmuch_query_t *query, - 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); + for (; 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"); + if (mime_node_open (config, message, ¶ms->crypto, &node)) return 1; - } - - 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); + reply = create_reply_message (config, config, message, + GMIME_MESSAGE (node->part), reply_all, + format == FORMAT_HEADERS_ONLY); + if (!reply) + return 1; - orig_references = notmuch_message_get_header (message, "references"); + if (format == FORMAT_JSON || format == FORMAT_SEXP) { + sp->begin_map (sp); - /* 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); + /* The headers of the reply message we've created */ + sp->map_key (sp, "reply-headers"); + format_headers_sprinter (sp, reply, TRUE); - (void)add_recipients_from_message (reply, config, message, reply_all); + /* Start the original */ + sp->map_key (sp, "original"); + format_part_sprinter (config, sp, node, TRUE, TRUE, FALSE); - reply_headers = g_mime_object_to_string (GMIME_OBJECT (reply)); - printf ("%s", reply_headers); - free (reply_headers); + /* End */ + sp->end (sp); + } else { + show_reply_headers (reply); + if (format == FORMAT_DEFAULT) + format_part_reply (node); + } g_object_unref (G_OBJECT (reply)); - reply = NULL; + talloc_free (node); notmuch_message_destroy (message); } + return 0; } -enum { - FORMAT_DEFAULT, - FORMAT_JSON, - FORMAT_SEXP, - FORMAT_HEADERS_ONLY, -}; - int notmuch_reply_command (notmuch_config_t *config, int argc, char *argv[]) { @@ -751,22 +693,16 @@ notmuch_reply_command (notmuch_config_t *config, int argc, char *argv[]) notmuch_query_t *query; char *query_string; int opt_index; - int (*reply_format_func) (void *ctx, - notmuch_config_t *config, - notmuch_query_t *query, - notmuch_show_params_t *params, - notmuch_bool_t reply_all, - struct sprinter *sp); 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', @@ -781,6 +717,7 @@ 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 } }; @@ -788,17 +725,7 @@ notmuch_reply_command (notmuch_config_t *config, int argc, char *argv[]) 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 (); @@ -813,17 +740,21 @@ notmuch_reply_command (notmuch_config_t *config, int argc, char *argv[]) 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 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 EXIT_FAILURE; } - if (reply_format_func (config, config, query, ¶ms, reply_all, sp) != 0) + if (do_reply (config, query, ¶ms, format, reply_all) != 0) return EXIT_FAILURE; notmuch_crypto_cleanup (¶ms.crypto);