X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch-reply.c;h=430c466c013e2cf511b6ce9fc8f201e4a93b81f9;hp=4464741fe3567e974e6f07038b93f6446b744150;hb=4ce7591610444a1c5ef6f56b57af8e180437fa62;hpb=243d7e30dcd80041760307d8d0d2a1839f36eca2 diff --git a/notmuch-reply.c b/notmuch-reply.c index 4464741f..430c466c 100644 --- a/notmuch-reply.c +++ b/notmuch-reply.c @@ -14,7 +14,7 @@ * 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 @@ -25,47 +25,41 @@ #include "sprinter.h" static void -show_reply_headers (GMimeMessage *message) +show_reply_headers (GMimeStream *stream, GMimeMessage *message) { - GMimeStream *stream_stdout = NULL; - - stream_stdout = g_mime_stream_file_new (stdout); - if (stream_stdout) { - g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE); - /* Output RFC 2822 formatted (and RFC 2047 encoded) headers. */ - g_mime_object_write_to_stream (GMIME_OBJECT(message), stream_stdout); - g_object_unref(stream_stdout); + /* Output RFC 2822 formatted (and RFC 2047 encoded) headers. */ + if (g_mime_object_write_to_stream (GMIME_OBJECT(message), stream) < 0) { + INTERNAL_ERROR("failed to write headers to stdout\n"); } } static void -format_part_reply (mime_node_t *node) +format_part_reply (GMimeStream *stream, mime_node_t *node) { int i; if (node->envelope_file) { - printf ("On %s, %s wrote:\n", - notmuch_message_get_header (node->envelope_file, "date"), - notmuch_message_get_header (node->envelope_file, "from")); + g_mime_stream_printf (stream, "On %s, %s wrote:\n", + notmuch_message_get_header (node->envelope_file, "date"), + notmuch_message_get_header (node->envelope_file, "from")); } else if (GMIME_IS_MESSAGE (node->part)) { GMimeMessage *message = GMIME_MESSAGE (node->part); - InternetAddressList *recipients; - const char *recipients_string; + char *recipients_string; - printf ("> From: %s\n", g_mime_message_get_sender (message)); - recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_TO); - recipients_string = internet_address_list_to_string (recipients, 0); + g_mime_stream_printf (stream, "> From: %s\n", g_mime_message_get_from_string (message)); + recipients_string = g_mime_message_get_address_string (message, GMIME_ADDRESS_TYPE_TO); if (recipients_string) - printf ("> To: %s\n", - recipients_string); - recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_CC); - recipients_string = internet_address_list_to_string (recipients, 0); + g_mime_stream_printf (stream, "> To: %s\n", + recipients_string); + g_free (recipients_string); + recipients_string = g_mime_message_get_address_string (message, GMIME_ADDRESS_TYPE_CC); if (recipients_string) - printf ("> Cc: %s\n", - recipients_string); - printf ("> Subject: %s\n", g_mime_message_get_subject (message)); - printf ("> Date: %s\n", g_mime_message_get_date_as_string (message)); - printf (">\n"); + g_mime_stream_printf (stream, "> Cc: %s\n", + recipients_string); + g_free (recipients_string); + g_mime_stream_printf (stream, "> Subject: %s\n", g_mime_message_get_subject (message)); + g_mime_stream_printf (stream, "> Date: %s\n", g_mime_message_get_date_string (node, message)); + g_mime_stream_printf (stream, ">\n"); } else if (GMIME_IS_PART (node->part)) { GMimeContentType *content_type = g_mime_object_get_content_type (node->part); GMimeContentDisposition *disposition = g_mime_object_get_content_disposition (node->part); @@ -75,23 +69,21 @@ format_part_reply (mime_node_t *node) /* Ignore PGP/MIME cruft parts */ } else if (g_mime_content_type_is_type (content_type, "text", "*") && !g_mime_content_type_is_type (content_type, "text", "html")) { - GMimeStream *stream_stdout = g_mime_stream_file_new (stdout); - g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE); - show_text_part_content (node->part, stream_stdout, NOTMUCH_SHOW_TEXT_PART_REPLY); - g_object_unref(stream_stdout); + show_text_part_content (node->part, stream, NOTMUCH_SHOW_TEXT_PART_REPLY); } 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)); + g_mime_stream_printf (stream, "Attachment: %s (%s)\n", filename, + g_mime_content_type_to_string (content_type)); } else { - printf ("Non-text part: %s\n", - g_mime_content_type_to_string (content_type)); + g_mime_stream_printf (stream, "Non-text part: %s\n", + g_mime_content_type_to_string (content_type)); } } for (i = 0; i < node->nchildren; i++) - format_part_reply (mime_node_child (node, i)); + format_part_reply (stream, mime_node_child (node, i)); } typedef enum { @@ -191,6 +183,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)) { @@ -199,9 +194,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; @@ -226,68 +218,93 @@ 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) +static notmuch_bool_t +reply_to_header_is_redundant (GMimeMessage *message, + InternetAddressList *reply_to_list) { - const char *reply_to, *to, *cc, *addr; - InternetAddressList *list; + const char *addr, *reply_to; InternetAddress *address; InternetAddressMailbox *mailbox; + InternetAddressList *recipients; + notmuch_bool_t ret = FALSE; + int i; - 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; mailbox = INTERNET_ADDRESS_MAILBOX (address); - addr = internet_address_mailbox_get_addr (mailbox); + reply_to = internet_address_mailbox_get_addr (mailbox); - to = notmuch_message_get_header (message, "to"); - cc = notmuch_message_get_header (message, "cc"); + recipients = g_mime_message_get_all_recipients (message); - if ((to && strstr (to, addr) != 0) || - (cc && strstr (cc, addr) != 0)) - { - return 1; + for (i = 0; i < internet_address_list_length (recipients); i++) { + address = internet_address_list_get_address (recipients, i); + if (INTERNET_ADDRESS_IS_GROUP (address)) + continue; + + mailbox = INTERNET_ADDRESS_MAILBOX (address); + addr = internet_address_mailbox_get_addr (mailbox); + if (strcmp (addr, reply_to) == 0) { + ret = TRUE; + break; + } } - return 0; + g_object_unref (G_OBJECT (recipients)); + + return ret; +} + +static InternetAddressList *get_sender(GMimeMessage *message) +{ + InternetAddressList *reply_to_list; + + reply_to_list = g_mime_message_get_reply_to_list (message); + if (reply_to_list && + internet_address_list_length (reply_to_list) > 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_list)) + return reply_to_list; + + g_mime_2_6_unref (G_OBJECT (reply_to_list)); + } + + return g_mime_message_get_from (message); +} + +static InternetAddressList *get_to(GMimeMessage *message) +{ + return g_mime_message_get_addresses (message, GMIME_ADDRESS_TYPE_TO); +} + +static InternetAddressList *get_cc(GMimeMessage *message) +{ + return g_mime_message_get_addresses (message, GMIME_ADDRESS_TYPE_CC); +} + +static InternetAddressList *get_bcc(GMimeMessage *message) +{ + return g_mime_message_get_addresses (message, GMIME_ADDRESS_TYPE_BCC); } /* Augment the recipients of 'reply' from the "Reply-to:", "From:", @@ -305,50 +322,35 @@ reply_to_header_is_redundant (notmuch_message_t *message) static const char * add_recipients_from_message (GMimeMessage *reply, notmuch_config_t *config, - notmuch_message_t *message, + GMimeMessage *message, notmuch_bool_t reply_all) { + + /* There is a memory leak here with gmime-2.6 because get_sender + * returns a newly allocated list, while the others return + * references to libgmime owned data. This leak will be fixed with + * the transition to gmime-3.0. + */ struct { - const char *header; - const char *fallback; + InternetAddressList * (*get_header)(GMimeMessage *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_ADDRESS_TYPE_TO }, + { get_to, GMIME_ADDRESS_TYPE_TO }, + { get_cc, GMIME_ADDRESS_TYPE_CC }, + { get_bcc, GMIME_ADDRESS_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); - 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 @@ -519,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)); + + 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, reply_all); + 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 @@ -571,187 +589,108 @@ 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); + 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), - "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 (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 %u 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 (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 { + GMimeStream *stream_stdout = stream_stdout = g_mime_stream_stdout_new (); + if (stream_stdout) { + show_reply_headers (stream_stdout, reply); + if (format == FORMAT_DEFAULT) + format_part_reply (stream_stdout, node); + } + g_mime_stream_flush (stream_stdout); + g_object_unref(stream_stdout); + } 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[]) { @@ -759,23 +698,11 @@ 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, - .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', @@ -800,18 +727,6 @@ notmuch_reply_command (notmuch_config_t *config, int argc, char *argv[]) notmuch_process_shared_options (argv[0]); - 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_exit_if_unsupported_format (); query_string = query_string_from_args (config, argc-opt_index, argv+opt_index); @@ -831,13 +746,15 @@ notmuch_reply_command (notmuch_config_t *config, int argc, char *argv[]) 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);