]> git.cworth.org Git - notmuch/blob - notmuch-search.c
test: check for GNU parallel with --version options
[notmuch] / notmuch-search.c
1 /* notmuch - Not much of an email program, (just index and search)
2  *
3  * Copyright © 2009 Carl Worth
4  *
5  * This program is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation, either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see https://www.gnu.org/licenses/ .
17  *
18  * Author: Carl Worth <cworth@cworth.org>
19  */
20
21 #include "notmuch-client.h"
22 #include "sprinter.h"
23 #include "string-util.h"
24
25 typedef enum {
26     /* Search command */
27     OUTPUT_SUMMARY      = 1 << 0,
28     OUTPUT_THREADS      = 1 << 1,
29     OUTPUT_MESSAGES     = 1 << 2,
30     OUTPUT_FILES        = 1 << 3,
31     OUTPUT_TAGS         = 1 << 4,
32
33     /* Address command */
34     OUTPUT_SENDER       = 1 << 5,
35     OUTPUT_RECIPIENTS   = 1 << 6,
36     OUTPUT_COUNT        = 1 << 7,
37     OUTPUT_ADDRESS      = 1 << 8,
38 } output_t;
39
40 typedef enum {
41     DEDUP_NONE,
42     DEDUP_MAILBOX,
43     DEDUP_ADDRESS,
44 } dedup_t;
45
46 typedef enum {
47     NOTMUCH_FORMAT_JSON,
48     NOTMUCH_FORMAT_TEXT,
49     NOTMUCH_FORMAT_TEXT0,
50     NOTMUCH_FORMAT_SEXP
51 } format_sel_t;
52
53 typedef struct {
54     notmuch_database_t *notmuch;
55     void *talloc_ctx;
56     int format_sel;
57     sprinter_t *format;
58     int exclude;
59     notmuch_query_t *query;
60     int sort;
61     int output;
62     int offset;
63     int limit;
64     int dupe;
65     GHashTable *addresses;
66     int dedup;
67 } search_context_t;
68
69 typedef struct {
70     const char *name;
71     const char *addr;
72     int count;
73 } mailbox_t;
74
75 /* Return two stable query strings that identify exactly the matched
76  * and unmatched messages currently in thread.  If there are no
77  * matched or unmatched messages, the returned buffers will be
78  * NULL. */
79 static int
80 get_thread_query (notmuch_thread_t *thread,
81                   char **matched_out, char **unmatched_out)
82 {
83     notmuch_messages_t *messages;
84     char *escaped = NULL;
85     size_t escaped_len = 0;
86
87     *matched_out = *unmatched_out = NULL;
88
89     for (messages = notmuch_thread_get_messages (thread);
90          notmuch_messages_valid (messages);
91          notmuch_messages_move_to_next (messages)) {
92         notmuch_message_t *message = notmuch_messages_get (messages);
93         const char *mid = notmuch_message_get_message_id (message);
94         notmuch_bool_t is_set;
95         char **buf;
96
97         if (notmuch_message_get_flag_st (message, NOTMUCH_MESSAGE_FLAG_MATCH, &is_set))
98             return -1;
99         /* Determine which query buffer to extend */
100         buf = is_set ? matched_out : unmatched_out;
101         /* Add this message's id: query.  Since "id" is an exclusive
102          * prefix, it is implicitly 'or'd together, so we only need to
103          * join queries with a space. */
104         if (make_boolean_term (thread, "id", mid, &escaped, &escaped_len) < 0)
105             return -1;
106         if (*buf)
107             *buf = talloc_asprintf_append_buffer (*buf, " %s", escaped);
108         else
109             *buf = talloc_strdup (thread, escaped);
110         if (! *buf)
111             return -1;
112     }
113     talloc_free (escaped);
114     return 0;
115 }
116
117 static int
118 do_search_threads (search_context_t *ctx)
119 {
120     notmuch_thread_t *thread;
121     notmuch_threads_t *threads;
122     notmuch_tags_t *tags;
123     sprinter_t *format = ctx->format;
124     time_t date;
125     int i;
126     notmuch_status_t status;
127
128     if (ctx->offset < 0) {
129         unsigned count;
130         notmuch_status_t status;
131         status = notmuch_query_count_threads (ctx->query, &count);
132         if (print_status_query ("notmuch search", ctx->query, status))
133             return 1;
134
135         ctx->offset += count;
136         if (ctx->offset < 0)
137             ctx->offset = 0;
138     }
139
140     status = notmuch_query_search_threads (ctx->query, &threads);
141     if (print_status_query ("notmuch search", ctx->query, status))
142         return 1;
143
144     format->begin_list (format);
145
146     for (i = 0;
147          notmuch_threads_valid (threads) && (ctx->limit < 0 || i < ctx->offset + ctx->limit);
148          notmuch_threads_move_to_next (threads), i++) {
149         thread = notmuch_threads_get (threads);
150
151         if (i < ctx->offset) {
152             notmuch_thread_destroy (thread);
153             continue;
154         }
155
156         if (ctx->output == OUTPUT_THREADS) {
157             format->set_prefix (format, "thread");
158             format->string (format,
159                             notmuch_thread_get_thread_id (thread));
160             format->separator (format);
161         } else { /* output == OUTPUT_SUMMARY */
162             void *ctx_quote = talloc_new (thread);
163             const char *authors = notmuch_thread_get_authors (thread);
164             const char *subject = notmuch_thread_get_subject (thread);
165             const char *thread_id = notmuch_thread_get_thread_id (thread);
166             int matched = notmuch_thread_get_matched_messages (thread);
167             int files = notmuch_thread_get_total_files (thread);
168             int total = notmuch_thread_get_total_messages (thread);
169             const char *relative_date = NULL;
170             bool first_tag = true;
171
172             format->begin_map (format);
173
174             if (ctx->sort == NOTMUCH_SORT_OLDEST_FIRST)
175                 date = notmuch_thread_get_oldest_date (thread);
176             else
177                 date = notmuch_thread_get_newest_date (thread);
178
179             relative_date = notmuch_time_relative_date (ctx_quote, date);
180
181             if (format->is_text_printer) {
182                 /* Special case for the text formatter */
183                 printf ("thread:%s %12s ",
184                         thread_id,
185                         relative_date);
186                 if (total == files)
187                     printf ("[%d/%d] %s; %s (",
188                             matched,
189                             total,
190                             sanitize_string (ctx_quote, authors),
191                             sanitize_string (ctx_quote, subject));
192                 else
193                     printf ("[%d/%d(%d)] %s; %s (",
194                             matched,
195                             total,
196                             files,
197                             sanitize_string (ctx_quote, authors),
198                             sanitize_string (ctx_quote, subject));
199
200             } else { /* Structured Output */
201                 format->map_key (format, "thread");
202                 format->string (format, thread_id);
203                 format->map_key (format, "timestamp");
204                 format->integer (format, date);
205                 format->map_key (format, "date_relative");
206                 format->string (format, relative_date);
207                 format->map_key (format, "matched");
208                 format->integer (format, matched);
209                 format->map_key (format, "total");
210                 format->integer (format, total);
211                 format->map_key (format, "authors");
212                 format->string (format, authors);
213                 format->map_key (format, "subject");
214                 format->string (format, subject);
215                 if (notmuch_format_version >= 2) {
216                     char *matched_query, *unmatched_query;
217                     if (get_thread_query (thread, &matched_query,
218                                           &unmatched_query) < 0) {
219                         fprintf (stderr, "Out of memory\n");
220                         return 1;
221                     }
222                     format->map_key (format, "query");
223                     format->begin_list (format);
224                     if (matched_query)
225                         format->string (format, matched_query);
226                     else
227                         format->null (format);
228                     if (unmatched_query)
229                         format->string (format, unmatched_query);
230                     else
231                         format->null (format);
232                     format->end (format);
233                 }
234             }
235
236             talloc_free (ctx_quote);
237
238             format->map_key (format, "tags");
239             format->begin_list (format);
240
241             for (tags = notmuch_thread_get_tags (thread);
242                  notmuch_tags_valid (tags);
243                  notmuch_tags_move_to_next (tags)) {
244                 const char *tag = notmuch_tags_get (tags);
245
246                 if (format->is_text_printer) {
247                     /* Special case for the text formatter */
248                     if (first_tag)
249                         first_tag = false;
250                     else
251                         fputc (' ', stdout);
252                     fputs (tag, stdout);
253                 } else { /* Structured Output */
254                     format->string (format, tag);
255                 }
256             }
257
258             if (format->is_text_printer)
259                 printf (")");
260
261             format->end (format);
262             format->end (format);
263             format->separator (format);
264         }
265
266         notmuch_thread_destroy (thread);
267     }
268
269     format->end (format);
270
271     return 0;
272 }
273
274 static mailbox_t *
275 new_mailbox (void *ctx, const char *name, const char *addr)
276 {
277     mailbox_t *mailbox;
278
279     mailbox = talloc (ctx, mailbox_t);
280     if (! mailbox)
281         return NULL;
282
283     mailbox->name = talloc_strdup (mailbox, name);
284     mailbox->addr = talloc_strdup (mailbox, addr);
285     mailbox->count = 1;
286
287     return mailbox;
288 }
289
290 static int
291 mailbox_compare (const void *v1, const void *v2)
292 {
293     const mailbox_t *m1 = v1, *m2 = v2;
294     int ret;
295
296     ret = strcmp_null (m1->name, m2->name);
297     if (! ret)
298         ret = strcmp (m1->addr, m2->addr);
299
300     return ret;
301 }
302
303 /* Returns true iff name and addr is duplicate. If not, stores the
304  * name/addr pair in order to detect subsequent duplicates. */
305 static bool
306 is_duplicate (const search_context_t *ctx, const char *name, const char *addr)
307 {
308     char *key;
309     GList *list, *l;
310     mailbox_t *mailbox;
311
312     list = g_hash_table_lookup (ctx->addresses, addr);
313     if (list) {
314         mailbox_t find = {
315             .name = name,
316             .addr = addr,
317         };
318
319         l = g_list_find_custom (list, &find, mailbox_compare);
320         if (l) {
321             mailbox = l->data;
322             mailbox->count++;
323             return true;
324         }
325
326         mailbox = new_mailbox (ctx->format, name, addr);
327         if (! mailbox)
328             return false;
329
330         /*
331          * XXX: It would be more efficient to prepend to the list, but
332          * then we'd have to store the changed list head back to the
333          * hash table. This check is here just to avoid the compiler
334          * warning for unused result.
335          */
336         if (list != g_list_append (list, mailbox))
337             INTERNAL_ERROR ("appending to list changed list head\n");
338
339         return false;
340     }
341
342     key = talloc_strdup (ctx->format, addr);
343     if (! key)
344         return false;
345
346     mailbox = new_mailbox (ctx->format, name, addr);
347     if (! mailbox)
348         return false;
349
350     list = g_list_append (NULL, mailbox);
351     if (! list)
352         return false;
353
354     g_hash_table_insert (ctx->addresses, key, list);
355
356     return false;
357 }
358
359 static void
360 print_mailbox (const search_context_t *ctx, const mailbox_t *mailbox)
361 {
362     const char *name = mailbox->name;
363     const char *addr = mailbox->addr;
364     int count = mailbox->count;
365     sprinter_t *format = ctx->format;
366     InternetAddress *ia = internet_address_mailbox_new (name, addr);
367     char *name_addr;
368
369     /* name_addr has the name part quoted if necessary. Compare
370      * 'John Doe <john@doe.com>' vs. '"Doe, John" <john@doe.com>' */
371     name_addr = internet_address_to_string (ia, NULL, false);
372
373     if (format->is_text_printer) {
374         if (ctx->output & OUTPUT_COUNT) {
375             format->integer (format, count);
376             format->string (format, "\t");
377         }
378         if (ctx->output & OUTPUT_ADDRESS)
379             format->string (format, addr);
380         else
381             format->string (format, name_addr);
382         format->separator (format);
383     } else {
384         format->begin_map (format);
385         format->map_key (format, "name");
386         format->string (format, name);
387         format->map_key (format, "address");
388         format->string (format, addr);
389         format->map_key (format, "name-addr");
390         format->string (format, name_addr);
391         if (ctx->output & OUTPUT_COUNT) {
392             format->map_key (format, "count");
393             format->integer (format, count);
394         }
395         format->end (format);
396         format->separator (format);
397     }
398
399     g_object_unref (ia);
400     g_free (name_addr);
401 }
402
403 /* Print or prepare for printing addresses from InternetAddressList. */
404 static void
405 process_address_list (const search_context_t *ctx,
406                       InternetAddressList *list)
407 {
408     InternetAddress *address;
409     int i;
410
411     for (i = 0; i < internet_address_list_length (list); i++) {
412         address = internet_address_list_get_address (list, i);
413         if (INTERNET_ADDRESS_IS_GROUP (address)) {
414             InternetAddressGroup *group;
415             InternetAddressList *group_list;
416
417             group = INTERNET_ADDRESS_GROUP (address);
418             group_list = internet_address_group_get_members (group);
419             if (group_list == NULL)
420                 continue;
421
422             process_address_list (ctx, group_list);
423         } else {
424             InternetAddressMailbox *mailbox = INTERNET_ADDRESS_MAILBOX (address);
425             mailbox_t mbx = {
426                 .name = internet_address_get_name (address),
427                 .addr = internet_address_mailbox_get_addr (mailbox),
428             };
429
430             /* OUTPUT_COUNT only works with deduplication */
431             if (ctx->dedup != DEDUP_NONE &&
432                 is_duplicate (ctx, mbx.name, mbx.addr))
433                 continue;
434
435             /* OUTPUT_COUNT and DEDUP_ADDRESS require a full pass. */
436             if (ctx->output & OUTPUT_COUNT || ctx->dedup == DEDUP_ADDRESS)
437                 continue;
438
439             print_mailbox (ctx, &mbx);
440         }
441     }
442 }
443
444 /* Print or prepare for printing addresses from a message header. */
445 static void
446 process_address_header (const search_context_t *ctx, const char *value)
447 {
448     InternetAddressList *list;
449
450     if (value == NULL)
451         return;
452
453     list = internet_address_list_parse (NULL, value);
454     if (list == NULL)
455         return;
456
457     process_address_list (ctx, list);
458
459     g_object_unref (list);
460 }
461
462 /* Destructor for talloc-allocated GHashTable keys and values. */
463 static void
464 _talloc_free_for_g_hash (void *ptr)
465 {
466     talloc_free (ptr);
467 }
468
469 static void
470 _list_free_for_g_hash (void *ptr)
471 {
472     g_list_free_full (ptr, _talloc_free_for_g_hash);
473 }
474
475 /* Print the most common variant of a list of unique mailboxes, and
476  * conflate the counts. */
477 static void
478 print_popular (const search_context_t *ctx, GList *list)
479 {
480     GList *l;
481     mailbox_t *mailbox = NULL, *m;
482     int max = 0;
483     int total = 0;
484
485     for (l = list; l; l = l->next) {
486         m = l->data;
487         total += m->count;
488         if (m->count > max) {
489             mailbox = m;
490             max = m->count;
491         }
492     }
493
494     if (! mailbox)
495         INTERNAL_ERROR ("Empty list in address hash table\n");
496
497     /* The original count is no longer needed, so overwrite. */
498     mailbox->count = total;
499
500     print_mailbox (ctx, mailbox);
501 }
502
503 static void
504 print_list_value (void *mailbox, void *context)
505 {
506     print_mailbox (context, mailbox);
507 }
508
509 static void
510 print_hash_value (unused (void *key), void *list, void *context)
511 {
512     const search_context_t *ctx = context;
513
514     if (ctx->dedup == DEDUP_ADDRESS)
515         print_popular (ctx, list);
516     else
517         g_list_foreach (list, print_list_value, context);
518 }
519
520 static int
521 _count_filenames (notmuch_message_t *message)
522 {
523     notmuch_filenames_t *filenames;
524     int i = 0;
525
526     filenames = notmuch_message_get_filenames (message);
527
528     while (notmuch_filenames_valid (filenames)) {
529         notmuch_filenames_move_to_next (filenames);
530         i++;
531     }
532
533     notmuch_filenames_destroy (filenames);
534
535     return i;
536 }
537
538 static int
539 do_search_messages (search_context_t *ctx)
540 {
541     notmuch_message_t *message;
542     notmuch_messages_t *messages;
543     notmuch_filenames_t *filenames;
544     sprinter_t *format = ctx->format;
545     int i;
546     notmuch_status_t status;
547
548     if (ctx->offset < 0) {
549         unsigned count;
550         notmuch_status_t status;
551         status = notmuch_query_count_messages (ctx->query, &count);
552         if (print_status_query ("notmuch search", ctx->query, status))
553             return 1;
554
555         ctx->offset += count;
556         if (ctx->offset < 0)
557             ctx->offset = 0;
558     }
559
560     status = notmuch_query_search_messages (ctx->query, &messages);
561     if (print_status_query ("notmuch search", ctx->query, status))
562         return 1;
563
564     format->begin_list (format);
565
566     for (i = 0;
567          notmuch_messages_valid (messages) && (ctx->limit < 0 || i < ctx->offset + ctx->limit);
568          notmuch_messages_move_to_next (messages), i++) {
569         if (i < ctx->offset)
570             continue;
571
572         message = notmuch_messages_get (messages);
573
574         if (ctx->output == OUTPUT_FILES) {
575             int j;
576             filenames = notmuch_message_get_filenames (message);
577
578             for (j = 1;
579                  notmuch_filenames_valid (filenames);
580                  notmuch_filenames_move_to_next (filenames), j++) {
581                 if (ctx->dupe < 0 || ctx->dupe == j) {
582                     format->string (format, notmuch_filenames_get (filenames));
583                     format->separator (format);
584                 }
585             }
586
587             notmuch_filenames_destroy ( filenames );
588
589         } else if (ctx->output == OUTPUT_MESSAGES) {
590             /* special case 1 for speed */
591             if (ctx->dupe <= 1 || ctx->dupe <= _count_filenames (message)) {
592                 format->set_prefix (format, "id");
593                 format->string (format,
594                                 notmuch_message_get_message_id (message));
595                 format->separator (format);
596             }
597         } else {
598             if (ctx->output & OUTPUT_SENDER) {
599                 const char *addrs;
600
601                 addrs = notmuch_message_get_header (message, "from");
602                 process_address_header (ctx, addrs);
603             }
604
605             if (ctx->output & OUTPUT_RECIPIENTS) {
606                 const char *hdrs[] = { "to", "cc", "bcc" };
607                 const char *addrs;
608                 size_t j;
609
610                 for (j = 0; j < ARRAY_SIZE (hdrs); j++) {
611                     addrs = notmuch_message_get_header (message, hdrs[j]);
612                     process_address_header (ctx, addrs);
613                 }
614             }
615         }
616
617         notmuch_message_destroy (message);
618     }
619
620     if (ctx->addresses &&
621         (ctx->output & OUTPUT_COUNT || ctx->dedup == DEDUP_ADDRESS))
622         g_hash_table_foreach (ctx->addresses, print_hash_value, ctx);
623
624     notmuch_messages_destroy (messages);
625
626     format->end (format);
627
628     return 0;
629 }
630
631 static int
632 do_search_tags (const search_context_t *ctx)
633 {
634     notmuch_messages_t *messages = NULL;
635     notmuch_tags_t *tags;
636     const char *tag;
637     sprinter_t *format = ctx->format;
638     notmuch_query_t *query = ctx->query;
639     notmuch_database_t *notmuch = ctx->notmuch;
640
641     /* should the following only special case if no excluded terms
642      * specified? */
643
644     /* Special-case query of "*" for better performance. */
645     if (strcmp (notmuch_query_get_query_string (query), "*") == 0) {
646         tags = notmuch_database_get_all_tags (notmuch);
647     } else {
648         notmuch_status_t status;
649         status = notmuch_query_search_messages (query, &messages);
650         if (print_status_query ("notmuch search", query, status))
651             return 1;
652
653         tags = notmuch_messages_collect_tags (messages);
654     }
655     if (tags == NULL)
656         return 1;
657
658     format->begin_list (format);
659
660     for (;
661          notmuch_tags_valid (tags);
662          notmuch_tags_move_to_next (tags)) {
663         tag = notmuch_tags_get (tags);
664
665         format->string (format, tag);
666         format->separator (format);
667
668     }
669
670     notmuch_tags_destroy (tags);
671
672     if (messages)
673         notmuch_messages_destroy (messages);
674
675     format->end (format);
676
677     return 0;
678 }
679
680 static int
681 _notmuch_search_prepare (search_context_t *ctx, int argc, char *argv[])
682 {
683     char *query_str;
684
685     if (! ctx->talloc_ctx)
686         ctx->talloc_ctx = talloc_new (NULL);
687
688     switch (ctx->format_sel) {
689     case NOTMUCH_FORMAT_TEXT:
690         ctx->format = sprinter_text_create (ctx->talloc_ctx, stdout);
691         break;
692     case NOTMUCH_FORMAT_TEXT0:
693         if (ctx->output == OUTPUT_SUMMARY) {
694             fprintf (stderr, "Error: --format=text0 is not compatible with --output=summary.\n");
695             return EXIT_FAILURE;
696         }
697         ctx->format = sprinter_text0_create (ctx->talloc_ctx, stdout);
698         break;
699     case NOTMUCH_FORMAT_JSON:
700         ctx->format = sprinter_json_create (ctx->talloc_ctx, stdout);
701         break;
702     case NOTMUCH_FORMAT_SEXP:
703         ctx->format = sprinter_sexp_create (ctx->talloc_ctx, stdout);
704         break;
705     default:
706         /* this should never happen */
707         INTERNAL_ERROR ("no output format selected");
708     }
709
710     notmuch_exit_if_unsupported_format ();
711
712     notmuch_exit_if_unmatched_db_uuid (ctx->notmuch);
713
714     query_str = query_string_from_args (ctx->notmuch, argc, argv);
715     if (query_str == NULL) {
716         fprintf (stderr, "Out of memory.\n");
717         return EXIT_FAILURE;
718     }
719     if (*query_str == '\0') {
720         fprintf (stderr, "Error: notmuch search requires at least one search term.\n");
721         return EXIT_FAILURE;
722     }
723
724     ctx->query = notmuch_query_create (ctx->notmuch, query_str);
725     if (ctx->query == NULL) {
726         fprintf (stderr, "Out of memory\n");
727         return EXIT_FAILURE;
728     }
729
730     notmuch_query_set_sort (ctx->query, ctx->sort);
731
732     if (ctx->exclude == NOTMUCH_EXCLUDE_FLAG && ctx->output != OUTPUT_SUMMARY) {
733         /* If we are not doing summary output there is nowhere to
734          * print the excluded flag so fall back on including the
735          * excluded messages. */
736         fprintf (stderr, "Warning: this output format cannot flag excluded messages.\n");
737         ctx->exclude = NOTMUCH_EXCLUDE_FALSE;
738     }
739
740     if (ctx->exclude != NOTMUCH_EXCLUDE_FALSE) {
741         notmuch_config_values_t *exclude_tags;
742         notmuch_status_t status;
743
744         for (exclude_tags = notmuch_config_get_values (ctx->notmuch, NOTMUCH_CONFIG_EXCLUDE_TAGS);
745              notmuch_config_values_valid (exclude_tags);
746              notmuch_config_values_move_to_next (exclude_tags)) {
747
748             status = notmuch_query_add_tag_exclude (ctx->query,
749                                                     notmuch_config_values_get (exclude_tags));
750             if (status && status != NOTMUCH_STATUS_IGNORED) {
751                 print_status_query ("notmuch search", ctx->query, status);
752                 return EXIT_FAILURE;
753             }
754         }
755         notmuch_query_set_omit_excluded (ctx->query, ctx->exclude);
756     }
757
758     return 0;
759 }
760
761 static void
762 _notmuch_search_cleanup (search_context_t *ctx)
763 {
764     notmuch_query_destroy (ctx->query);
765     notmuch_database_destroy (ctx->notmuch);
766
767     talloc_free (ctx->format);
768 }
769
770 static search_context_t search_context = {
771     .format_sel = NOTMUCH_FORMAT_TEXT,
772     .exclude = NOTMUCH_EXCLUDE_TRUE,
773     .sort = NOTMUCH_SORT_NEWEST_FIRST,
774     .output = 0,
775     .offset = 0,
776     .limit = -1, /* unlimited */
777     .dupe = -1,
778     .dedup = DEDUP_MAILBOX,
779 };
780
781 static const notmuch_opt_desc_t common_options[] = {
782     { .opt_keyword = &search_context.sort, .name = "sort", .keywords =
783           (notmuch_keyword_t []){ { "oldest-first", NOTMUCH_SORT_OLDEST_FIRST },
784                                   { "newest-first", NOTMUCH_SORT_NEWEST_FIRST },
785                                   { 0, 0 } } },
786     { .opt_keyword = &search_context.format_sel, .name = "format", .keywords =
787           (notmuch_keyword_t []){ { "json", NOTMUCH_FORMAT_JSON },
788                                   { "sexp", NOTMUCH_FORMAT_SEXP },
789                                   { "text", NOTMUCH_FORMAT_TEXT },
790                                   { "text0", NOTMUCH_FORMAT_TEXT0 },
791                                   { 0, 0 } } },
792     { .opt_int = &notmuch_format_version, .name = "format-version" },
793     { }
794 };
795
796 int
797 notmuch_search_command (notmuch_database_t *notmuch, int argc, char *argv[])
798 {
799     search_context_t *ctx = &search_context;
800     int opt_index, ret;
801
802     notmuch_opt_desc_t options[] = {
803         { .opt_keyword = &ctx->output, .name = "output", .keywords =
804               (notmuch_keyword_t []){ { "summary", OUTPUT_SUMMARY },
805                                       { "threads", OUTPUT_THREADS },
806                                       { "messages", OUTPUT_MESSAGES },
807                                       { "files", OUTPUT_FILES },
808                                       { "tags", OUTPUT_TAGS },
809                                       { 0, 0 } } },
810         { .opt_keyword = &ctx->exclude, .name = "exclude", .keywords =
811               (notmuch_keyword_t []){ { "true", NOTMUCH_EXCLUDE_TRUE },
812                                       { "false", NOTMUCH_EXCLUDE_FALSE },
813                                       { "flag", NOTMUCH_EXCLUDE_FLAG },
814                                       { "all", NOTMUCH_EXCLUDE_ALL },
815                                       { 0, 0 } } },
816         { .opt_int = &ctx->offset, .name = "offset" },
817         { .opt_int = &ctx->limit, .name = "limit" },
818         { .opt_int = &ctx->dupe, .name = "duplicate" },
819         { .opt_inherit = common_options },
820         { .opt_inherit = notmuch_shared_options },
821         { }
822     };
823
824     ctx->notmuch = notmuch;
825     ctx->output = OUTPUT_SUMMARY;
826     opt_index = parse_arguments (argc, argv, options, 1);
827     if (opt_index < 0)
828         return EXIT_FAILURE;
829
830     notmuch_process_shared_options (argv[0]);
831
832     if (ctx->output != OUTPUT_FILES && ctx->output != OUTPUT_MESSAGES &&
833         ctx->dupe != -1) {
834         fprintf (stderr,
835                  "Error: --duplicate=N is only supported with --output=files and --output=messages.\n");
836         return EXIT_FAILURE;
837     }
838
839     if (_notmuch_search_prepare (ctx, argc - opt_index, argv + opt_index))
840         return EXIT_FAILURE;
841
842     switch (ctx->output) {
843     case OUTPUT_SUMMARY:
844     case OUTPUT_THREADS:
845         ret = do_search_threads (ctx);
846         break;
847     case OUTPUT_MESSAGES:
848     case OUTPUT_FILES:
849         ret = do_search_messages (ctx);
850         break;
851     case OUTPUT_TAGS:
852         ret = do_search_tags (ctx);
853         break;
854     default:
855         INTERNAL_ERROR ("Unexpected output");
856     }
857
858     _notmuch_search_cleanup (ctx);
859
860     return ret ? EXIT_FAILURE : EXIT_SUCCESS;
861 }
862
863 int
864 notmuch_address_command (notmuch_database_t *notmuch, int argc, char *argv[])
865 {
866     search_context_t *ctx = &search_context;
867     int opt_index, ret;
868
869     notmuch_opt_desc_t options[] = {
870         { .opt_flags = &ctx->output, .name = "output", .keywords =
871               (notmuch_keyword_t []){ { "sender", OUTPUT_SENDER },
872                                       { "recipients", OUTPUT_RECIPIENTS },
873                                       { "count", OUTPUT_COUNT },
874                                       { "address", OUTPUT_ADDRESS },
875                                       { 0, 0 } } },
876         { .opt_keyword = &ctx->exclude, .name = "exclude", .keywords =
877               (notmuch_keyword_t []){ { "true", NOTMUCH_EXCLUDE_TRUE },
878                                       { "false", NOTMUCH_EXCLUDE_FALSE },
879                                       { 0, 0 } } },
880         { .opt_keyword = &ctx->dedup, .name = "deduplicate", .keywords =
881               (notmuch_keyword_t []){ { "no", DEDUP_NONE },
882                                       { "mailbox", DEDUP_MAILBOX },
883                                       { "address", DEDUP_ADDRESS },
884                                       { 0, 0 } } },
885         { .opt_inherit = common_options },
886         { .opt_inherit = notmuch_shared_options },
887         { }
888     };
889
890     ctx->notmuch = notmuch;
891
892     opt_index = parse_arguments (argc, argv, options, 1);
893     if (opt_index < 0)
894         return EXIT_FAILURE;
895
896     notmuch_process_shared_options (argv[0]);
897
898     if (! (ctx->output & (OUTPUT_SENDER | OUTPUT_RECIPIENTS)))
899         ctx->output |= OUTPUT_SENDER;
900
901     if (ctx->output & OUTPUT_COUNT && ctx->dedup == DEDUP_NONE) {
902         fprintf (stderr, "--output=count is not applicable with --deduplicate=no\n");
903         return EXIT_FAILURE;
904     }
905
906     if (_notmuch_search_prepare (ctx, argc - opt_index, argv + opt_index))
907         return EXIT_FAILURE;
908
909     ctx->addresses = g_hash_table_new_full (strcase_hash, strcase_equal,
910                                             _talloc_free_for_g_hash,
911                                             _list_free_for_g_hash);
912
913     /* The order is not guaranteed if a full pass is required, so go
914      * for fastest. */
915     if (ctx->output & OUTPUT_COUNT || ctx->dedup == DEDUP_ADDRESS)
916         notmuch_query_set_sort (ctx->query, NOTMUCH_SORT_UNSORTED);
917
918     ret = do_search_messages (ctx);
919
920     g_hash_table_unref (ctx->addresses);
921
922
923     _notmuch_search_cleanup (ctx);
924
925     return ret ? EXIT_FAILURE : EXIT_SUCCESS;
926 }