]> git.notmuchmail.org Git - notmuch/blobdiff - notmuch-reply.c
test: Test upgrade to ghost messages feature
[notmuch] / notmuch-reply.c
index 51cb6de8dc66c3ca9f20548a2a1a616e339af98c..7c1c80959ed6cee221479353bbb84345a6875055 100644 (file)
  */
 
 #include "notmuch-client.h"
-#include "gmime-filter-headers.h"
+#include "string-util.h"
+#include "sprinter.h"
 
 static void
 show_reply_headers (GMimeMessage *message)
 {
-    GMimeStream *stream_stdout = NULL, *stream_filter = NULL;
+    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);
-       stream_filter = g_mime_stream_filter_new(stream_stdout);
-       if (stream_filter) {
-               g_mime_stream_filter_add(GMIME_STREAM_FILTER(stream_filter),
-                                        g_mime_filter_headers_new());
-               g_mime_object_write_to_stream(GMIME_OBJECT(message), stream_filter);
-               g_object_unref(stream_filter);
-       }
+       /* 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);
     }
 }
@@ -374,73 +370,44 @@ add_recipients_from_message (GMimeMessage *reply,
     return from_addr;
 }
 
+/*
+ * Look for the user's address in " for <email@add.res>" 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"};
-
-    /* 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 (for <email@add.res>) clause in Received: headers
-     * 4) 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]);
-
-       /* Note: tohdr potentially contains a list of email addresses. */
-       addr = user_address_in_string (tohdr, config);
-       if (addr)
-           return addr;
-    }
+    const char *ptr;
 
-    /* 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 <email@add.res>" 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 +417,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 +430,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 +451,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 +541,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 = get_from_in_to_headers (config, message);
+
+    /*
+     * Check for a (for <email@add.res>) 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_received_header (config, message);
+       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);
 
@@ -527,9 +581,12 @@ create_reply_message(void *ctx,
                              "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 ? " " : "",
+                                 *orig_references ? orig_references : "",
+                                 *orig_references ? " " : "",
                                  in_reply_to);
     g_mime_object_set_header (GMIME_OBJECT (reply),
                              "References", references);
@@ -542,7 +599,8 @@ notmuch_reply_format_default(void *ctx,
                             notmuch_config_t *config,
                             notmuch_query_t *query,
                             notmuch_show_params_t *params,
-                            notmuch_bool_t reply_all)
+                            notmuch_bool_t reply_all,
+                            unused (sprinter_t *sp))
 {
     GMimeMessage *reply;
     notmuch_messages_t *messages;
@@ -570,8 +628,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);
        }
@@ -582,11 +639,12 @@ notmuch_reply_format_default(void *ctx,
 }
 
 static int
-notmuch_reply_format_json(void *ctx,
-                         notmuch_config_t *config,
-                         notmuch_query_t *query,
-                         notmuch_show_params_t *params,
-                         notmuch_bool_t reply_all)
+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;
@@ -600,27 +658,27 @@ 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);
     if (!reply)
        return 1;
 
+    sp->begin_map (sp);
+
     /* The headers of the reply message we've created */
-    printf ("{\"reply-headers\": ");
-    format_headers_json (ctx, reply, TRUE);
+    sp->map_key (sp, "reply-headers");
+    format_headers_sprinter (sp, reply, TRUE);
     g_object_unref (G_OBJECT (reply));
     reply = NULL;
 
     /* Start the original */
-    printf (", \"original\": ");
-
-    format_part_json (ctx, node, TRUE);
+    sp->map_key (sp, "original");
+    format_part_sprinter (ctx, sp, node, TRUE, TRUE, FALSE);
 
     /* End */
-    printf ("}\n");
+    sp->end (sp);
     notmuch_message_destroy (message);
 
     return 0;
@@ -632,7 +690,8 @@ 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)
+                                 notmuch_bool_t reply_all,
+                                 unused (sprinter_t *sp))
 {
     GMimeMessage *reply;
     notmuch_messages_t *messages;
@@ -689,101 +748,95 @@ notmuch_reply_format_headers_only(void *ctx,
 enum {
     FORMAT_DEFAULT,
     FORMAT_JSON,
+    FORMAT_SEXP,
     FORMAT_HEADERS_ONLY,
 };
 
 int
-notmuch_reply_command (void *ctx, int argc, char *argv[])
+notmuch_reply_command (notmuch_config_t *config, int argc, char *argv[])
 {
-    notmuch_config_t *config;
     notmuch_database_t *notmuch;
     notmuch_query_t *query;
     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 };
+    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
+       }
+    };
     int format = FORMAT_DEFAULT;
     int reply_all = TRUE;
+    struct sprinter *sp = NULL;
 
     notmuch_opt_desc_t options[] = {
        { NOTMUCH_OPT_KEYWORD, &format, "format", 'f',
          (notmuch_keyword_t []){ { "default", FORMAT_DEFAULT },
                                  { "json", FORMAT_JSON },
+                                 { "sexp", FORMAT_SEXP },
                                  { "headers-only", FORMAT_HEADERS_ONLY },
                                  { 0, 0 } } },
+       { NOTMUCH_OPT_INT, &notmuch_format_version, "format-version", 0, 0 },
        { NOTMUCH_OPT_KEYWORD, &reply_all, "reply-to", 'r',
          (notmuch_keyword_t []){ { "all", TRUE },
                                  { "sender", FALSE },
                                  { 0, 0 } } },
-       { NOTMUCH_OPT_BOOLEAN, &params.decrypt, "decrypt", 'd', 0 },
+       { NOTMUCH_OPT_BOOLEAN, &params.crypto.decrypt, "decrypt", 'd', 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)
+    if (format == FORMAT_HEADERS_ONLY) {
        reply_format_func = notmuch_reply_format_headers_only;
-    else if (format == FORMAT_JSON)
-       reply_format_func = notmuch_reply_format_json;
-    else
+    } 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;
-
-    if (params.decrypt) {
-#ifdef GMIME_ATLEAST_26
-       /* TODO: GMimePasswordRequestFunc */
-       params.cryptoctx = 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");
-#endif
-       if (params.cryptoctx) {
-           g_mime_gpg_context_set_always_trust ((GMimeGpgContext*) params.cryptoctx, FALSE);
-       } else {
-           params.decrypt = FALSE;
-           fprintf (stderr, "Failed to construct gpg context.\n");
-       }
-#ifndef GMIME_ATLEAST_26
-       g_object_unref (session);
-#endif
     }
 
-    config = notmuch_config_open (ctx, NULL, NULL);
-    if (config == NULL)
-       return 1;
+    notmuch_exit_if_unsupported_format ();
 
-    query_string = query_string_from_args (ctx, argc-opt_index, argv+opt_index);
+    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;
     }
 
     if (notmuch_database_open (notmuch_config_get_database_path (config),
                               NOTMUCH_DATABASE_MODE_READ_ONLY, &notmuch))
-       return 1;
+       return EXIT_FAILURE;
 
     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 (ctx, config, query, &params, reply_all) != 0)
-       return 1;
+    if (reply_format_func (config, config, query, &params, reply_all, sp) != 0)
+       return EXIT_FAILURE;
 
+    notmuch_crypto_cleanup (&params.crypto);
     notmuch_query_destroy (query);
     notmuch_database_destroy (notmuch);
 
-    if (params.cryptoctx)
-       g_object_unref(params.cryptoctx);
-
-    return ret;
+    return EXIT_SUCCESS;
 }