+ return 0;
+}
+
+/* Augment the recipients of 'reply' from the "Reply-to:", "From:",
+ * "To:", "Cc:", and "Bcc:" headers of 'message'.
+ *
+ * If 'reply_all' is true, use sender and all recipients, otherwise
+ * scan the headers for the first that contains something other than
+ * the user's addresses and add the recipients from this header
+ * (typically this would be reply-to-sender, but also handles reply to
+ * user's own message in a sensible way).
+ *
+ * If any of the user's addresses were found in these headers, the
+ * first of these returned, otherwise NULL is returned.
+ */
+static const char *
+add_recipients_from_message (GMimeMessage *reply,
+ notmuch_config_t *config,
+ notmuch_message_t *message,
+ notmuch_bool_t reply_all)
+{
+ struct {
+ const char *header;
+ const char *fallback;
+ 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 }
+ };
+ 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;
+
+ 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;