cli: clean up exit status code returned by the cli commands
[notmuch] / notmuch-reply.c
1 /* notmuch - Not much of an email program, (just index and search)
2  *
3  * Copyright © 2009 Carl Worth
4  * Copyright © 2009 Keith Packard
5  *
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program.  If not, see http://www.gnu.org/licenses/ .
18  *
19  * Authors: Carl Worth <cworth@cworth.org>
20  *          Keith Packard <keithp@keithp.com>
21  */
22
23 #include "notmuch-client.h"
24 #include "sprinter.h"
25
26 static void
27 show_reply_headers (GMimeMessage *message)
28 {
29     GMimeStream *stream_stdout = NULL;
30
31     stream_stdout = g_mime_stream_file_new (stdout);
32     if (stream_stdout) {
33         g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
34         /* Output RFC 2822 formatted (and RFC 2047 encoded) headers. */
35         g_mime_object_write_to_stream (GMIME_OBJECT(message), stream_stdout);
36         g_object_unref(stream_stdout);
37     }
38 }
39
40 static void
41 format_part_reply (mime_node_t *node)
42 {
43     int i;
44
45     if (node->envelope_file) {
46         printf ("On %s, %s wrote:\n",
47                 notmuch_message_get_header (node->envelope_file, "date"),
48                 notmuch_message_get_header (node->envelope_file, "from"));
49     } else if (GMIME_IS_MESSAGE (node->part)) {
50         GMimeMessage *message = GMIME_MESSAGE (node->part);
51         InternetAddressList *recipients;
52         const char *recipients_string;
53
54         printf ("> From: %s\n", g_mime_message_get_sender (message));
55         recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_TO);
56         recipients_string = internet_address_list_to_string (recipients, 0);
57         if (recipients_string)
58             printf ("> To: %s\n",
59                     recipients_string);
60         recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_CC);
61         recipients_string = internet_address_list_to_string (recipients, 0);
62         if (recipients_string)
63             printf ("> Cc: %s\n",
64                     recipients_string);
65         printf ("> Subject: %s\n", g_mime_message_get_subject (message));
66         printf ("> Date: %s\n", g_mime_message_get_date_as_string (message));
67         printf (">\n");
68     } else if (GMIME_IS_PART (node->part)) {
69         GMimeContentType *content_type = g_mime_object_get_content_type (node->part);
70         GMimeContentDisposition *disposition = g_mime_object_get_content_disposition (node->part);
71
72         if (g_mime_content_type_is_type (content_type, "application", "pgp-encrypted") ||
73             g_mime_content_type_is_type (content_type, "application", "pgp-signature")) {
74             /* Ignore PGP/MIME cruft parts */
75         } else if (g_mime_content_type_is_type (content_type, "text", "*") &&
76                    !g_mime_content_type_is_type (content_type, "text", "html")) {
77             GMimeStream *stream_stdout = g_mime_stream_file_new (stdout);
78             g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
79             show_text_part_content (node->part, stream_stdout, NOTMUCH_SHOW_TEXT_PART_REPLY);
80             g_object_unref(stream_stdout);
81         } else if (disposition &&
82                    strcmp (disposition->disposition, GMIME_DISPOSITION_ATTACHMENT) == 0) {
83             const char *filename = g_mime_part_get_filename (GMIME_PART (node->part));
84             printf ("Attachment: %s (%s)\n", filename,
85                     g_mime_content_type_to_string (content_type));
86         } else {
87             printf ("Non-text part: %s\n",
88                     g_mime_content_type_to_string (content_type));
89         }
90     }
91
92     for (i = 0; i < node->nchildren; i++)
93         format_part_reply (mime_node_child (node, i));
94 }
95
96 typedef enum {
97     USER_ADDRESS_IN_STRING,
98     STRING_IN_USER_ADDRESS,
99     STRING_IS_USER_ADDRESS,
100 } address_match_t;
101
102 /* Match given string against given address according to mode. */
103 static notmuch_bool_t
104 match_address (const char *str, const char *address, address_match_t mode)
105 {
106     switch (mode) {
107     case USER_ADDRESS_IN_STRING:
108         return strcasestr (str, address) != NULL;
109     case STRING_IN_USER_ADDRESS:
110         return strcasestr (address, str) != NULL;
111     case STRING_IS_USER_ADDRESS:
112         return strcasecmp (address, str) == 0;
113     }
114
115     return FALSE;
116 }
117
118 /* Match given string against user's configured "primary" and "other"
119  * addresses according to mode. */
120 static const char *
121 address_match (const char *str, notmuch_config_t *config, address_match_t mode)
122 {
123     const char *primary;
124     const char **other;
125     size_t i, other_len;
126
127     if (!str || *str == '\0')
128         return NULL;
129
130     primary = notmuch_config_get_user_primary_email (config);
131     if (match_address (str, primary, mode))
132         return primary;
133
134     other = notmuch_config_get_user_other_email (config, &other_len);
135     for (i = 0; i < other_len; i++) {
136         if (match_address (str, other[i], mode))
137             return other[i];
138     }
139
140     return NULL;
141 }
142
143 /* Does the given string contain an address configured as one of the
144  * user's "primary" or "other" addresses. If so, return the matching
145  * address, NULL otherwise. */
146 static const char *
147 user_address_in_string (const char *str, notmuch_config_t *config)
148 {
149     return address_match (str, config, USER_ADDRESS_IN_STRING);
150 }
151
152 /* Do any of the addresses configured as one of the user's "primary"
153  * or "other" addresses contain the given string. If so, return the
154  * matching address, NULL otherwise. */
155 static const char *
156 string_in_user_address (const char *str, notmuch_config_t *config)
157 {
158     return address_match (str, config, STRING_IN_USER_ADDRESS);
159 }
160
161 /* Is the given address configured as one of the user's "primary" or
162  * "other" addresses. */
163 static notmuch_bool_t
164 address_is_users (const char *address, notmuch_config_t *config)
165 {
166     return address_match (address, config, STRING_IS_USER_ADDRESS) != NULL;
167 }
168
169 /* Scan addresses in 'list'.
170  *
171  * If 'message' is non-NULL, then for each address in 'list' that is
172  * not configured as one of the user's addresses in 'config', add that
173  * address to 'message' as an address of 'type'.
174  *
175  * If 'user_from' is non-NULL and *user_from is NULL, *user_from will
176  * be set to the first address encountered in 'list' that is the
177  * user's address.
178  *
179  * Return the number of addresses added to 'message'. (If 'message' is
180  * NULL, the function returns 0 by definition.)
181  */
182 static unsigned int
183 scan_address_list (InternetAddressList *list,
184                    notmuch_config_t *config,
185                    GMimeMessage *message,
186                    GMimeRecipientType type,
187                    const char **user_from)
188 {
189     InternetAddress *address;
190     int i;
191     unsigned int n = 0;
192
193     for (i = 0; i < internet_address_list_length (list); i++) {
194         address = internet_address_list_get_address (list, i);
195         if (INTERNET_ADDRESS_IS_GROUP (address)) {
196             InternetAddressGroup *group;
197             InternetAddressList *group_list;
198
199             group = INTERNET_ADDRESS_GROUP (address);
200             group_list = internet_address_group_get_members (group);
201             if (group_list == NULL)
202                 continue;
203
204             n += scan_address_list (group_list, config, message, type, user_from);
205         } else {
206             InternetAddressMailbox *mailbox;
207             const char *name;
208             const char *addr;
209
210             mailbox = INTERNET_ADDRESS_MAILBOX (address);
211
212             name = internet_address_get_name (address);
213             addr = internet_address_mailbox_get_addr (mailbox);
214
215             if (address_is_users (addr, config)) {
216                 if (user_from && *user_from == NULL)
217                     *user_from = addr;
218             } else if (message) {
219                 g_mime_message_add_recipient (message, type, name, addr);
220                 n++;
221             }
222         }
223     }
224
225     return n;
226 }
227
228 /* Scan addresses in 'recipients'.
229  *
230  * See the documentation of scan_address_list() above. This function
231  * does exactly the same, but converts 'recipients' to an
232  * InternetAddressList first.
233  */
234 static unsigned int
235 scan_address_string (const char *recipients,
236                      notmuch_config_t *config,
237                      GMimeMessage *message,
238                      GMimeRecipientType type,
239                      const char **user_from)
240 {
241     InternetAddressList *list;
242
243     if (recipients == NULL)
244         return 0;
245
246     list = internet_address_list_parse_string (recipients);
247     if (list == NULL)
248         return 0;
249
250     return scan_address_list (list, config, message, type, user_from);
251 }
252
253 /* Does the address in the Reply-To header of 'message' already appear
254  * in either the 'To' or 'Cc' header of the message?
255  */
256 static int
257 reply_to_header_is_redundant (notmuch_message_t *message)
258 {
259     const char *reply_to, *to, *cc, *addr;
260     InternetAddressList *list;
261     InternetAddress *address;
262     InternetAddressMailbox *mailbox;
263
264     reply_to = notmuch_message_get_header (message, "reply-to");
265     if (reply_to == NULL || *reply_to == '\0')
266         return 0;
267
268     list = internet_address_list_parse_string (reply_to);
269
270     if (internet_address_list_length (list) != 1)
271         return 0;
272
273     address = internet_address_list_get_address (list, 0);
274     if (INTERNET_ADDRESS_IS_GROUP (address))
275         return 0;
276
277     mailbox = INTERNET_ADDRESS_MAILBOX (address);
278     addr = internet_address_mailbox_get_addr (mailbox);
279
280     to = notmuch_message_get_header (message, "to");
281     cc = notmuch_message_get_header (message, "cc");
282
283     if ((to && strstr (to, addr) != 0) ||
284         (cc && strstr (cc, addr) != 0))
285     {
286         return 1;
287     }
288
289     return 0;
290 }
291
292 /* Augment the recipients of 'reply' from the "Reply-to:", "From:",
293  * "To:", "Cc:", and "Bcc:" headers of 'message'.
294  *
295  * If 'reply_all' is true, use sender and all recipients, otherwise
296  * scan the headers for the first that contains something other than
297  * the user's addresses and add the recipients from this header
298  * (typically this would be reply-to-sender, but also handles reply to
299  * user's own message in a sensible way).
300  *
301  * If any of the user's addresses were found in these headers, the
302  * first of these returned, otherwise NULL is returned.
303  */
304 static const char *
305 add_recipients_from_message (GMimeMessage *reply,
306                              notmuch_config_t *config,
307                              notmuch_message_t *message,
308                              notmuch_bool_t reply_all)
309 {
310     struct {
311         const char *header;
312         const char *fallback;
313         GMimeRecipientType recipient_type;
314     } reply_to_map[] = {
315         { "reply-to", "from", GMIME_RECIPIENT_TYPE_TO  },
316         { "to",         NULL, GMIME_RECIPIENT_TYPE_TO  },
317         { "cc",         NULL, GMIME_RECIPIENT_TYPE_CC  },
318         { "bcc",        NULL, GMIME_RECIPIENT_TYPE_BCC }
319     };
320     const char *from_addr = NULL;
321     unsigned int i;
322     unsigned int n = 0;
323
324     /* Some mailing lists munge the Reply-To header despite it being A Bad
325      * Thing, see http://www.unicom.com/pw/reply-to-harmful.html
326      *
327      * The munging is easy to detect, because it results in a
328      * redundant reply-to header, (with an address that already exists
329      * in either To or Cc). So in this case, we ignore the Reply-To
330      * field and use the From header. This ensures the original sender
331      * will get the reply even if not subscribed to the list. Note
332      * that the address in the Reply-To header will always appear in
333      * the reply.
334      */
335     if (reply_to_header_is_redundant (message)) {
336         reply_to_map[0].header = "from";
337         reply_to_map[0].fallback = NULL;
338     }
339
340     for (i = 0; i < ARRAY_SIZE (reply_to_map); i++) {
341         const char *recipients;
342
343         recipients = notmuch_message_get_header (message,
344                                                  reply_to_map[i].header);
345         if ((recipients == NULL || recipients[0] == '\0') && reply_to_map[i].fallback)
346             recipients = notmuch_message_get_header (message,
347                                                      reply_to_map[i].fallback);
348
349         n += scan_address_string (recipients, config, reply,
350                                   reply_to_map[i].recipient_type, &from_addr);
351
352         if (!reply_all && n) {
353             /* Stop adding new recipients in reply-to-sender mode if
354              * we have added some recipient(s) above.
355              *
356              * This also handles the case of user replying to his own
357              * message, where reply-to/from is not a recipient. In
358              * this case there may be more than one recipient even if
359              * not replying to all.
360              */
361             reply = NULL;
362
363             /* From address and some recipients are enough, bail out. */
364             if (from_addr)
365                 break;
366         }
367     }
368
369     return from_addr;
370 }
371
372 static const char *
373 guess_from_received_header (notmuch_config_t *config, notmuch_message_t *message)
374 {
375     const char *addr, *received, *by;
376     char *mta,*ptr,*token;
377     char *domain=NULL;
378     char *tld=NULL;
379     const char *delim=". \t";
380     size_t i;
381
382     const char *to_headers[] = {
383         "Envelope-to",
384         "X-Original-To",
385         "Delivered-To",
386     };
387
388     /* sadly, there is no standard way to find out to which email
389      * address a mail was delivered - what is in the headers depends
390      * on the MTAs used along the way. So we are trying a number of
391      * heuristics which hopefully will answer this question.
392
393      * We only got here if none of the users email addresses are in
394      * the To: or Cc: header. From here we try the following in order:
395      * 1) check for an Envelope-to: header
396      * 2) check for an X-Original-To: header
397      * 3) check for a Delivered-To: header
398      * 4) check for a (for <email@add.res>) clause in Received: headers
399      * 5) check for the domain part of known email addresses in the
400      *    'by' part of Received headers
401      * If none of these work, we give up and return NULL
402      */
403     for (i = 0; i < ARRAY_SIZE (to_headers); i++) {
404         const char *tohdr = notmuch_message_get_header (message, to_headers[i]);
405
406         /* Note: tohdr potentially contains a list of email addresses. */
407         addr = user_address_in_string (tohdr, config);
408         if (addr)
409             return addr;
410     }
411
412     /* We get the concatenated Received: headers and search from the
413      * front (last Received: header added) and try to extract from
414      * them indications to which email address this message was
415      * delivered.
416      * The Received: header is special in our get_header function
417      * and is always concatenated.
418      */
419     received = notmuch_message_get_header (message, "received");
420     if (received == NULL)
421         return NULL;
422
423     /* First we look for a " for <email@add.res>" in the received
424      * header
425      */
426     ptr = strstr (received, " for ");
427
428     /* Note: ptr potentially contains a list of email addresses. */
429     addr = user_address_in_string (ptr, config);
430     if (addr)
431         return addr;
432
433     /* Finally, we parse all the " by MTA ..." headers to guess the
434      * email address that this was originally delivered to.
435      * We extract just the MTA here by removing leading whitespace and
436      * assuming that the MTA name ends at the next whitespace.
437      * We test for *(by+4) to be non-'\0' to make sure there's
438      * something there at all - and then assume that the first
439      * whitespace delimited token that follows is the receiving
440      * system in this step of the receive chain
441      */
442     by = received;
443     while((by = strstr (by, " by ")) != NULL) {
444         by += 4;
445         if (*by == '\0')
446             break;
447         mta = xstrdup (by);
448         token = strtok(mta," \t");
449         if (token == NULL) {
450             free (mta);
451             break;
452         }
453         /* Now extract the last two components of the MTA host name
454          * as domain and tld.
455          */
456         domain = tld = NULL;
457         while ((ptr = strsep (&token, delim)) != NULL) {
458             if (*ptr == '\0')
459                 continue;
460             domain = tld;
461             tld = ptr;
462         }
463
464         if (domain) {
465             /* Recombine domain and tld and look for it among the configured
466              * email addresses.
467              * This time we have a known domain name and nothing else - so
468              * the test is the other way around: we check if this is a
469              * substring of one of the email addresses.
470              */
471             *(tld-1) = '.';
472
473             addr = string_in_user_address (domain, config);
474             if (addr) {
475                 free (mta);
476                 return addr;
477             }
478         }
479         free (mta);
480     }
481
482     return NULL;
483 }
484
485 static GMimeMessage *
486 create_reply_message(void *ctx,
487                      notmuch_config_t *config,
488                      notmuch_message_t *message,
489                      notmuch_bool_t reply_all)
490 {
491     const char *subject, *from_addr = NULL;
492     const char *in_reply_to, *orig_references, *references;
493
494     /* The 1 means we want headers in a "pretty" order. */
495     GMimeMessage *reply = g_mime_message_new (1);
496     if (reply == NULL) {
497         fprintf (stderr, "Out of memory\n");
498         return NULL;
499     }
500
501     subject = notmuch_message_get_header (message, "subject");
502     if (subject) {
503         if (strncasecmp (subject, "Re:", 3))
504             subject = talloc_asprintf (ctx, "Re: %s", subject);
505         g_mime_message_set_subject (reply, subject);
506     }
507
508     from_addr = add_recipients_from_message (reply, config,
509                                              message, reply_all);
510
511     if (from_addr == NULL)
512         from_addr = guess_from_received_header (config, message);
513
514     if (from_addr == NULL)
515         from_addr = notmuch_config_get_user_primary_email (config);
516
517     from_addr = talloc_asprintf (ctx, "%s <%s>",
518                                  notmuch_config_get_user_name (config),
519                                  from_addr);
520     g_mime_object_set_header (GMIME_OBJECT (reply),
521                               "From", from_addr);
522
523     in_reply_to = talloc_asprintf (ctx, "<%s>",
524                                    notmuch_message_get_message_id (message));
525
526     g_mime_object_set_header (GMIME_OBJECT (reply),
527                               "In-Reply-To", in_reply_to);
528
529     orig_references = notmuch_message_get_header (message, "references");
530     if (!orig_references)
531         /* Treat errors like missing References headers. */
532         orig_references = "";
533     references = talloc_asprintf (ctx, "%s%s%s",
534                                   *orig_references ? orig_references : "",
535                                   *orig_references ? " " : "",
536                                   in_reply_to);
537     g_mime_object_set_header (GMIME_OBJECT (reply),
538                               "References", references);
539
540     return reply;
541 }
542
543 static int
544 notmuch_reply_format_default(void *ctx,
545                              notmuch_config_t *config,
546                              notmuch_query_t *query,
547                              notmuch_show_params_t *params,
548                              notmuch_bool_t reply_all,
549                              unused (sprinter_t *sp))
550 {
551     GMimeMessage *reply;
552     notmuch_messages_t *messages;
553     notmuch_message_t *message;
554     mime_node_t *root;
555
556     for (messages = notmuch_query_search_messages (query);
557          notmuch_messages_valid (messages);
558          notmuch_messages_move_to_next (messages))
559     {
560         message = notmuch_messages_get (messages);
561
562         reply = create_reply_message (ctx, config, message, reply_all);
563
564         /* If reply creation failed, we're out of memory, so don't
565          * bother trying any more messages.
566          */
567         if (!reply) {
568             notmuch_message_destroy (message);
569             return 1;
570         }
571
572         show_reply_headers (reply);
573
574         g_object_unref (G_OBJECT (reply));
575         reply = NULL;
576
577         if (mime_node_open (ctx, message, &(params->crypto), &root) == NOTMUCH_STATUS_SUCCESS) {
578             format_part_reply (root);
579             talloc_free (root);
580         }
581
582         notmuch_message_destroy (message);
583     }
584     return 0;
585 }
586
587 static int
588 notmuch_reply_format_sprinter(void *ctx,
589                               notmuch_config_t *config,
590                               notmuch_query_t *query,
591                               notmuch_show_params_t *params,
592                               notmuch_bool_t reply_all,
593                               sprinter_t *sp)
594 {
595     GMimeMessage *reply;
596     notmuch_messages_t *messages;
597     notmuch_message_t *message;
598     mime_node_t *node;
599
600     if (notmuch_query_count_messages (query) != 1) {
601         fprintf (stderr, "Error: search term did not match precisely one message.\n");
602         return 1;
603     }
604
605     messages = notmuch_query_search_messages (query);
606     message = notmuch_messages_get (messages);
607     if (mime_node_open (ctx, message, &(params->crypto), &node) != NOTMUCH_STATUS_SUCCESS)
608         return 1;
609
610     reply = create_reply_message (ctx, config, message, reply_all);
611     if (!reply)
612         return 1;
613
614     sp->begin_map (sp);
615
616     /* The headers of the reply message we've created */
617     sp->map_key (sp, "reply-headers");
618     format_headers_sprinter (sp, reply, TRUE);
619     g_object_unref (G_OBJECT (reply));
620     reply = NULL;
621
622     /* Start the original */
623     sp->map_key (sp, "original");
624     format_part_sprinter (ctx, sp, node, TRUE, TRUE, FALSE);
625
626     /* End */
627     sp->end (sp);
628     notmuch_message_destroy (message);
629
630     return 0;
631 }
632
633 /* This format is currently tuned for a git send-email --notmuch hook */
634 static int
635 notmuch_reply_format_headers_only(void *ctx,
636                                   notmuch_config_t *config,
637                                   notmuch_query_t *query,
638                                   unused (notmuch_show_params_t *params),
639                                   notmuch_bool_t reply_all,
640                                   unused (sprinter_t *sp))
641 {
642     GMimeMessage *reply;
643     notmuch_messages_t *messages;
644     notmuch_message_t *message;
645     const char *in_reply_to, *orig_references, *references;
646     char *reply_headers;
647
648     for (messages = notmuch_query_search_messages (query);
649          notmuch_messages_valid (messages);
650          notmuch_messages_move_to_next (messages))
651     {
652         message = notmuch_messages_get (messages);
653
654         /* The 0 means we do not want headers in a "pretty" order. */
655         reply = g_mime_message_new (0);
656         if (reply == NULL) {
657             fprintf (stderr, "Out of memory\n");
658             return 1;
659         }
660
661         in_reply_to = talloc_asprintf (ctx, "<%s>",
662                              notmuch_message_get_message_id (message));
663
664         g_mime_object_set_header (GMIME_OBJECT (reply),
665                                   "In-Reply-To", in_reply_to);
666
667
668         orig_references = notmuch_message_get_header (message, "references");
669
670         /* We print In-Reply-To followed by References because git format-patch treats them
671          * specially.  Git does not interpret the other headers specially
672          */
673         references = talloc_asprintf (ctx, "%s%s%s",
674                                       orig_references ? orig_references : "",
675                                       orig_references ? " " : "",
676                                       in_reply_to);
677         g_mime_object_set_header (GMIME_OBJECT (reply),
678                                   "References", references);
679
680         (void)add_recipients_from_message (reply, config, message, reply_all);
681
682         reply_headers = g_mime_object_to_string (GMIME_OBJECT (reply));
683         printf ("%s", reply_headers);
684         free (reply_headers);
685
686         g_object_unref (G_OBJECT (reply));
687         reply = NULL;
688
689         notmuch_message_destroy (message);
690     }
691     return 0;
692 }
693
694 enum {
695     FORMAT_DEFAULT,
696     FORMAT_JSON,
697     FORMAT_SEXP,
698     FORMAT_HEADERS_ONLY,
699 };
700
701 int
702 notmuch_reply_command (notmuch_config_t *config, int argc, char *argv[])
703 {
704     notmuch_database_t *notmuch;
705     notmuch_query_t *query;
706     char *query_string;
707     int opt_index;
708     int (*reply_format_func) (void *ctx,
709                               notmuch_config_t *config,
710                               notmuch_query_t *query,
711                               notmuch_show_params_t *params,
712                               notmuch_bool_t reply_all,
713                               struct sprinter *sp);
714     notmuch_show_params_t params = {
715         .part = -1,
716         .crypto = {
717             .verify = FALSE,
718             .decrypt = FALSE
719         }
720     };
721     int format = FORMAT_DEFAULT;
722     int reply_all = TRUE;
723     struct sprinter *sp = NULL;
724
725     notmuch_opt_desc_t options[] = {
726         { NOTMUCH_OPT_KEYWORD, &format, "format", 'f',
727           (notmuch_keyword_t []){ { "default", FORMAT_DEFAULT },
728                                   { "json", FORMAT_JSON },
729                                   { "sexp", FORMAT_SEXP },
730                                   { "headers-only", FORMAT_HEADERS_ONLY },
731                                   { 0, 0 } } },
732         { NOTMUCH_OPT_INT, &notmuch_format_version, "format-version", 0, 0 },
733         { NOTMUCH_OPT_KEYWORD, &reply_all, "reply-to", 'r',
734           (notmuch_keyword_t []){ { "all", TRUE },
735                                   { "sender", FALSE },
736                                   { 0, 0 } } },
737         { NOTMUCH_OPT_BOOLEAN, &params.crypto.decrypt, "decrypt", 'd', 0 },
738         { 0, 0, 0, 0, 0 }
739     };
740
741     opt_index = parse_arguments (argc, argv, options, 1);
742     if (opt_index < 0)
743         return EXIT_FAILURE;
744
745     if (format == FORMAT_HEADERS_ONLY) {
746         reply_format_func = notmuch_reply_format_headers_only;
747     } else if (format == FORMAT_JSON) {
748         reply_format_func = notmuch_reply_format_sprinter;
749         sp = sprinter_json_create (config, stdout);
750     } else if (format == FORMAT_SEXP) {
751         reply_format_func = notmuch_reply_format_sprinter;
752         sp = sprinter_sexp_create (config, stdout);
753     } else {
754         reply_format_func = notmuch_reply_format_default;
755     }
756
757     notmuch_exit_if_unsupported_format ();
758
759     query_string = query_string_from_args (config, argc-opt_index, argv+opt_index);
760     if (query_string == NULL) {
761         fprintf (stderr, "Out of memory\n");
762         return EXIT_FAILURE;
763     }
764
765     if (*query_string == '\0') {
766         fprintf (stderr, "Error: notmuch reply requires at least one search term.\n");
767         return EXIT_FAILURE;
768     }
769
770     if (notmuch_database_open (notmuch_config_get_database_path (config),
771                                NOTMUCH_DATABASE_MODE_READ_ONLY, &notmuch))
772         return EXIT_FAILURE;
773
774     query = notmuch_query_create (notmuch, query_string);
775     if (query == NULL) {
776         fprintf (stderr, "Out of memory\n");
777         return EXIT_FAILURE;
778     }
779
780     if (reply_format_func (config, config, query, &params, reply_all, sp) != 0)
781         return EXIT_FAILURE;
782
783     notmuch_crypto_cleanup (&params.crypto);
784     notmuch_query_destroy (query);
785     notmuch_database_destroy (notmuch);
786
787     return EXIT_SUCCESS;
788 }