+ 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);
+
+ n += scan_address_string (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
+ * we have added some recipient(s) above.
+ *
+ * This also handles the case of user replying to his own
+ * message, where reply-to/from is not a recipient. In
+ * this case there may be more than one recipient even if
+ * not replying to all.
+ */
+ reply = NULL;
+
+ /* From address and some recipients are enough, bail out. */
+ if (from_addr)
+ break;
+ }
+ }
+
+ 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_in_received_for (notmuch_config_t *config, const char *received)
+{
+ const char *ptr;
+
+ ptr = strstr (received, " for ");
+ if (! ptr)
+ return NULL;
+
+ return user_address_in_string (ptr, config);
+}
+
+/*
+ * 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;
+ mta = xstrdup (by);
+ token = strtok(mta," \t");
+ if (token == NULL) {
+ free (mta);
+ break;
+ }
+ /*
+ * Now extract the last two components of the MTA host name as
+ * domain and tld.
+ */
+ domain = tld = NULL;
+ while ((ptr = strsep (&token, ". \t")) != NULL) {
+ if (*ptr == '\0')
+ continue;
+ domain = tld;
+ tld = ptr;
+ }
+
+ 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.
+ */
+ *(tld - 1) = '.';
+
+ addr = string_in_user_address (domain, config);
+ if (addr) {
+ free (mta);
+ return addr;
+ }
+ }
+ free (mta);
+ }
+
+ 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,
+ notmuch_message_t *message,
+ notmuch_bool_t reply_all)
+{
+ 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);
+ if (reply == NULL) {