X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch-reply.c;h=cf4248bd6794303c15307ed57efa7fcfd2629499;hp=b380678e72046ca4501c6d08d5a5b0db46acdcda;hb=932c0ff879ddaf38f1e4ae325c061132d6af1026;hpb=301a65b0f2f7e4551ded7104d779b8600a806b2b diff --git a/notmuch-reply.c b/notmuch-reply.c index b380678e..cf4248bd 100644 --- a/notmuch-reply.c +++ b/notmuch-reply.c @@ -192,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)) { @@ -200,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; @@ -227,52 +227,22 @@ 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, + InternetAddressList *reply_to_list) { - const char *reply_to, *to, *cc, *addr; - InternetAddressList *list; + const char *to, *cc, *addr; 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) + if (reply_to_list == NULL || + internet_address_list_length (reply_to_list) != 1) return 0; - address = internet_address_list_get_address (list, 0); + address = internet_address_list_get_address (reply_to_list, 0); if (INTERNET_ADDRESS_IS_GROUP (address)) return 0; @@ -291,6 +261,60 @@ 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) { + InternetAddressList *reply_to_list; + + /* + * 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. + */ + reply_to_list = internet_address_list_parse_string (reply_to); + if (! reply_to_header_is_redundant (message, reply_to_list)) + return reply_to_list; + + g_object_unref (G_OBJECT (reply_to_list)); + } + + 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'. * @@ -307,49 +331,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://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_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 @@ -520,6 +525,7 @@ static GMimeMessage * create_reply_message(void *ctx, notmuch_config_t *config, notmuch_message_t *message, + GMimeMessage *mime_message, notmuch_bool_t reply_all, notmuch_bool_t limited) { @@ -550,8 +556,8 @@ create_reply_message(void *ctx, g_mime_object_set_header (GMIME_OBJECT (reply), "References", references); - from_addr = add_recipients_from_message (reply, config, - message, reply_all); + 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) @@ -650,7 +656,8 @@ static int do_reply(notmuch_config_t *config, if (mime_node_open (config, message, ¶ms->crypto, &node)) return 1; - reply = create_reply_message (config, config, message, reply_all, + reply = create_reply_message (config, config, message, + GMIME_MESSAGE (node->part), reply_all, format == FORMAT_HEADERS_ONLY); if (!reply) return 1;