notmuch show: Don't print non-text MIME parts.
[notmuch] / notmuch.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 http://www.gnu.org/licenses/ .
17  *
18  * Author: Carl Worth <cworth@cworth.org>
19  */
20
21 #ifndef _GNU_SOURCE
22 #define _GNU_SOURCE /* for getline */
23 #endif
24 #include <stdio.h>
25
26 #include <gmime/gmime.h>
27
28 #include "notmuch.h"
29
30 /* This is separate from notmuch-private.h because we're trying to
31  * keep notmuch.c from looking into any internals, (which helps us
32  * develop notmuch.h into a plausible library interface).
33  */
34 #include "xutil.h"
35
36 #include <stddef.h>
37 #include <string.h>
38 #include <sys/stat.h>
39 #include <sys/time.h>
40 #include <unistd.h>
41 #include <dirent.h>
42 #include <errno.h>
43 #include <signal.h>
44
45 #include <talloc.h>
46
47 #define unused(x) x __attribute__ ((unused))
48
49 /* There's no point in continuing when we've detected that we've done
50  * something wrong internally (as opposed to the user passing in a
51  * bogus value).
52  *
53  * Note that __location__ comes from talloc.h.
54  */
55 #define INTERNAL_ERROR(format, ...)                     \
56     do {                                                \
57         fprintf(stderr,                                 \
58                 "Internal error: " format " (%s)\n",    \
59                 ##__VA_ARGS__, __location__);           \
60         exit (1);                                       \
61     } while (0)
62
63 #define ARRAY_SIZE(arr) (sizeof (arr) / sizeof (arr[0]))
64
65 typedef int (*command_function_t) (void *ctx, int argc, char *argv[]);
66
67 typedef struct command {
68     const char *name;
69     command_function_t function;
70     const char *summary;
71     const char *documentation;
72 } command_t;
73
74 typedef void (*add_files_callback_t) (notmuch_message_t *message);
75
76 typedef struct {
77     int ignore_read_only_directories;
78     int saw_read_only_directory;
79
80     int total_files;
81     int processed_files;
82     int added_messages;
83     struct timeval tv_start;
84
85     add_files_callback_t callback;
86 } add_files_state_t;
87
88 static void
89 chomp_newline (char *str)
90 {
91     if (str && str[strlen(str)-1] == '\n')
92         str[strlen(str)-1] = '\0';
93 }
94
95 /* Compute the number of seconds elapsed from start to end. */
96 static double
97 tv_elapsed (struct timeval start, struct timeval end)
98 {
99     return ((end.tv_sec - start.tv_sec) +
100             (end.tv_usec - start.tv_usec) / 1e6);
101 }
102
103 static void
104 print_formatted_seconds (double seconds)
105 {
106     int hours;
107     int minutes;
108
109     if (seconds < 1) {
110         printf ("almost no time");
111         return;
112     }
113
114     if (seconds > 3600) {
115         hours = (int) seconds / 3600;
116         printf ("%dh ", hours);
117         seconds -= hours * 3600;
118     }
119
120     if (seconds > 60) {
121         minutes = (int) seconds / 60;
122         printf ("%dm ", minutes);
123         seconds -= minutes * 60;
124     }
125
126     printf ("%ds", (int) seconds);
127 }
128
129 static volatile sig_atomic_t do_add_files_print_progress = 0;
130
131 static void
132 handle_sigalrm (unused (int signal))
133 {
134     do_add_files_print_progress = 1;
135 }
136
137 static void
138 add_files_print_progress (add_files_state_t *state)
139 {
140     struct timeval tv_now;
141     double elapsed_overall, rate_overall;
142
143     gettimeofday (&tv_now, NULL);
144
145     elapsed_overall = tv_elapsed (state->tv_start, tv_now);
146     rate_overall = (state->processed_files) / elapsed_overall;
147
148     printf ("Processed %d", state->processed_files);
149
150     if (state->total_files) {
151         printf (" of %d files (", state->total_files);
152         print_formatted_seconds ((state->total_files - state->processed_files) /
153                                  rate_overall);
154         printf (" remaining).      \r");
155     } else {
156         printf (" files (%d files/sec.)    \r", (int) rate_overall);
157     }
158
159     fflush (stdout);
160 }
161
162 /* Examine 'path' recursively as follows:
163  *
164  *   o Ask the filesystem for the mtime of 'path' (path_mtime)
165  *
166  *   o Ask the database for its timestamp of 'path' (path_dbtime)
167  *
168  *   o If 'path_mtime' > 'path_dbtime'
169  *
170  *       o For each regular file in 'path' with mtime newer than the
171  *         'path_dbtime' call add_message to add the file to the
172  *         database.
173  *
174  *       o For each sub-directory of path, recursively call into this
175  *         same function.
176  *
177  *   o Tell the database to update its time of 'path' to 'path_mtime'
178  *
179  * The 'struct stat *st' must point to a structure that has already
180  * been initialized for 'path' by calling stat().
181  */
182 static notmuch_status_t
183 add_files_recursive (notmuch_database_t *notmuch,
184                      const char *path,
185                      struct stat *st,
186                      add_files_state_t *state)
187 {
188     DIR *dir = NULL;
189     struct dirent *e, *entry = NULL;
190     int entry_length;
191     int err;
192     char *next = NULL;
193     time_t path_mtime, path_dbtime;
194     notmuch_status_t status, ret = NOTMUCH_STATUS_SUCCESS;
195     notmuch_message_t *message = NULL, **closure;
196
197     /* If we're told to, we bail out on encountering a read-only
198      * directory, (with this being a clear clue from the user to
199      * Notmuch that new mail won't be arriving there and we need not
200      * look. */
201     if (state->ignore_read_only_directories &&
202         (st->st_mode & S_IWUSR) == 0)
203     {
204         state->saw_read_only_directory = TRUE;
205         goto DONE;
206     }
207
208     path_mtime = st->st_mtime;
209
210     path_dbtime = notmuch_database_get_timestamp (notmuch, path);
211
212     dir = opendir (path);
213     if (dir == NULL) {
214         fprintf (stderr, "Error opening directory %s: %s\n",
215                  path, strerror (errno));
216         ret = NOTMUCH_STATUS_FILE_ERROR;
217         goto DONE;
218     }
219
220     entry_length = offsetof (struct dirent, d_name) +
221         pathconf (path, _PC_NAME_MAX) + 1;
222     entry = malloc (entry_length);
223
224     while (1) {
225         err = readdir_r (dir, entry, &e);
226         if (err) {
227             fprintf (stderr, "Error reading directory: %s\n",
228                      strerror (errno));
229             ret = NOTMUCH_STATUS_FILE_ERROR;
230             goto DONE;
231         }
232
233         if (e == NULL)
234             break;
235
236         /* If this directory hasn't been modified since the last
237          * add_files, then we only need to look further for
238          * sub-directories. */
239         if (path_mtime <= path_dbtime && entry->d_type != DT_DIR)
240             continue;
241
242         /* Ignore special directories to avoid infinite recursion.
243          * Also ignore the .notmuch directory.
244          */
245         /* XXX: Eventually we'll want more sophistication to let the
246          * user specify files to be ignored. */
247         if (strcmp (entry->d_name, ".") == 0 ||
248             strcmp (entry->d_name, "..") == 0 ||
249             strcmp (entry->d_name, ".notmuch") ==0)
250         {
251             continue;
252         }
253
254         next = talloc_asprintf (notmuch, "%s/%s", path, entry->d_name);
255
256         if (stat (next, st)) {
257             fprintf (stderr, "Error reading %s: %s\n",
258                      next, strerror (errno));
259             ret = NOTMUCH_STATUS_FILE_ERROR;
260             continue;
261         }
262
263         if (S_ISREG (st->st_mode)) {
264             /* If the file hasn't been modified since the last
265              * add_files, then we need not look at it. */
266             if (st->st_mtime > path_dbtime) {
267                 state->processed_files++;
268
269                 if (state->callback)
270                     closure = &message;
271                 else
272                     closure = NULL;
273
274                 status = notmuch_database_add_message (notmuch, next, closure);
275                 switch (status) {
276                     /* success */
277                     case NOTMUCH_STATUS_SUCCESS:
278                         state->added_messages++;
279                         if (state->callback)
280                             (state->callback) (message);
281                         break;
282                     /* Non-fatal issues (go on to next file) */
283                     case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
284                         /* Stay silent on this one. */
285                         break;
286                     case NOTMUCH_STATUS_FILE_NOT_EMAIL:
287                         fprintf (stderr, "Note: Ignoring non-mail file: %s\n",
288                                  next);
289                         break;
290                     /* Fatal issues. Don't process anymore. */
291                     case NOTMUCH_STATUS_XAPIAN_EXCEPTION:
292                     case NOTMUCH_STATUS_OUT_OF_MEMORY:
293                         fprintf (stderr, "Error: %s. Halting processing.\n",
294                                  notmuch_status_to_string (status));
295                         ret = status;
296                         goto DONE;
297                     default:
298                     case NOTMUCH_STATUS_FILE_ERROR:
299                     case NOTMUCH_STATUS_NULL_POINTER:
300                     case NOTMUCH_STATUS_TAG_TOO_LONG:
301                     case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW:
302                     case NOTMUCH_STATUS_LAST_STATUS:
303                         INTERNAL_ERROR ("add_message returned unexpected value: %d",  status);
304                         goto DONE;
305                 }
306
307                 if (message) {
308                     notmuch_message_destroy (message);
309                     message = NULL;
310                 }
311
312                 if (do_add_files_print_progress) {
313                     do_add_files_print_progress = 0;
314                     add_files_print_progress (state);
315                 }
316             }
317         } else if (S_ISDIR (st->st_mode)) {
318             status = add_files_recursive (notmuch, next, st, state);
319             if (status && ret == NOTMUCH_STATUS_SUCCESS)
320                 ret = status;
321         }
322
323         talloc_free (next);
324         next = NULL;
325     }
326
327     status = notmuch_database_set_timestamp (notmuch, path, path_mtime);
328     if (status && ret == NOTMUCH_STATUS_SUCCESS)
329         ret = status;
330
331   DONE:
332     if (next)
333         talloc_free (next);
334     if (entry)
335         free (entry);
336     if (dir)
337         closedir (dir);
338
339     return ret;
340 }
341
342 /* This is the top-level entry point for add_files. It does a couple
343  * of error checks, sets up the progress-printing timer and then calls
344  * into the recursive function. */
345 static notmuch_status_t
346 add_files (notmuch_database_t *notmuch,
347            const char *path,
348            add_files_state_t *state)
349 {
350     struct stat st;
351     notmuch_status_t status;
352     struct sigaction action;
353     struct itimerval timerval;
354
355     if (stat (path, &st)) {
356         fprintf (stderr, "Error reading directory %s: %s\n",
357                  path, strerror (errno));
358         return NOTMUCH_STATUS_FILE_ERROR;
359     }
360
361     if (! S_ISDIR (st.st_mode)) {
362         fprintf (stderr, "Error: %s is not a directory.\n", path);
363         return NOTMUCH_STATUS_FILE_ERROR;
364     }
365
366     /* Setup our handler for SIGALRM */
367     memset (&action, 0, sizeof (struct sigaction));
368     action.sa_handler = handle_sigalrm;
369     sigemptyset (&action.sa_mask);
370     action.sa_flags = SA_RESTART;
371     sigaction (SIGALRM, &action, NULL);
372
373     /* Then start a timer to send SIGALRM once per second. */
374     timerval.it_interval.tv_sec = 1;
375     timerval.it_interval.tv_usec = 0;
376     timerval.it_value.tv_sec = 1;
377     timerval.it_value.tv_usec = 0;
378     setitimer (ITIMER_REAL, &timerval, NULL);
379
380     status = add_files_recursive (notmuch, path, &st, state);
381
382     /* Now stop the timer. */
383     timerval.it_interval.tv_sec = 0;
384     timerval.it_interval.tv_usec = 0;
385     timerval.it_value.tv_sec = 0;
386     timerval.it_value.tv_usec = 0;
387     setitimer (ITIMER_REAL, &timerval, NULL);
388
389     /* And disable the signal handler. */
390     action.sa_handler = SIG_IGN;
391     sigaction (SIGALRM, &action, NULL);
392
393     return status;
394 }
395
396 /* Recursively count all regular files in path and all sub-direcotries
397  * of path.  The result is added to *count (which should be
398  * initialized to zero by the top-level caller before calling
399  * count_files). */
400 static void
401 count_files (const char *path, int *count)
402 {
403     DIR *dir;
404     struct dirent *e, *entry = NULL;
405     int entry_length;
406     int err;
407     char *next;
408     struct stat st;
409
410     dir = opendir (path);
411
412     if (dir == NULL) {
413         fprintf (stderr, "Warning: failed to open directory %s: %s\n",
414                  path, strerror (errno));
415         goto DONE;
416     }
417
418     entry_length = offsetof (struct dirent, d_name) +
419         pathconf (path, _PC_NAME_MAX) + 1;
420     entry = malloc (entry_length);
421
422     while (1) {
423         err = readdir_r (dir, entry, &e);
424         if (err) {
425             fprintf (stderr, "Error reading directory: %s\n",
426                      strerror (errno));
427             free (entry);
428             goto DONE;
429         }
430
431         if (e == NULL)
432             break;
433
434         /* Ignore special directories to avoid infinite recursion.
435          * Also ignore the .notmuch directory.
436          */
437         /* XXX: Eventually we'll want more sophistication to let the
438          * user specify files to be ignored. */
439         if (strcmp (entry->d_name, ".") == 0 ||
440             strcmp (entry->d_name, "..") == 0 ||
441             strcmp (entry->d_name, ".notmuch") == 0)
442         {
443             continue;
444         }
445
446         if (asprintf (&next, "%s/%s", path, entry->d_name) == -1) {
447             next = NULL;
448             fprintf (stderr, "Error descending from %s to %s: Out of memory\n",
449                      path, entry->d_name);
450             continue;
451         }
452
453         stat (next, &st);
454
455         if (S_ISREG (st.st_mode)) {
456             *count = *count + 1;
457             if (*count % 1000 == 0) {
458                 printf ("Found %d files so far.\r", *count);
459                 fflush (stdout);
460             }
461         } else if (S_ISDIR (st.st_mode)) {
462             count_files (next, count);
463         }
464
465         free (next);
466     }
467
468   DONE:
469     if (entry)
470         free (entry);
471
472     closedir (dir);
473 }
474
475 static int
476 setup_command (unused (void *ctx), unused (int argc), unused (char *argv[]))
477 {
478     notmuch_database_t *notmuch = NULL;
479     char *default_path, *mail_directory = NULL;
480     size_t line_size;
481     int count;
482     add_files_state_t add_files_state;
483     double elapsed;
484     struct timeval tv_now;
485     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
486
487     printf ("Welcome to notmuch!\n\n");
488
489     printf ("The goal of notmuch is to help you manage and search your collection of\n"
490             "email, and to efficiently keep up with the flow of email as it comes in.\n\n");
491
492     printf ("Notmuch needs to know the top-level directory of your email archive,\n"
493             "(where you already have mail stored and where messages will be delivered\n"
494             "in the future). This directory can contain any number of sub-directories\n"
495             "and primarily just files with indvidual email messages (eg. maildir or mh\n"
496             "archives are perfect). If there are other, non-email files (such as\n"
497             "indexes maintained by other email programs) then notmuch will do its\n"
498             "best to detect those and ignore them.\n\n");
499
500     printf ("Mail storage that uses mbox format, (where one mbox file contains many\n"
501             "messages), will not work with notmuch. If that's how your mail is currently\n"
502             "stored, we recommend you first convert it to maildir format with a utility\n"
503             "such as mb2md. In that case, press Control-C now and run notmuch again\n"
504             "once the conversion is complete.\n\n");
505
506
507     default_path = notmuch_database_default_path ();
508     printf ("Top-level mail directory [%s]: ", default_path);
509     fflush (stdout);
510
511     getline (&mail_directory, &line_size, stdin);
512     chomp_newline (mail_directory);
513
514     printf ("\n");
515
516     if (mail_directory == NULL || strlen (mail_directory) == 0) {
517         if (mail_directory)
518             free (mail_directory);
519         mail_directory = default_path;
520     } else {
521         /* XXX: Instead of telling the user to use an environment
522          * variable here, we should really be writing out a configuration
523          * file and loading that on the next run. */
524         if (strcmp (mail_directory, default_path)) {
525             printf ("Note: Since you are not using the default path, you will want to set\n"
526                     "the NOTMUCH_BASE environment variable to %s so that\n"
527                     "future calls to notmuch commands will know where to find your mail.\n",
528                     mail_directory);
529             printf ("For example, if you are using bash for your shell, add:\n\n");
530             printf ("\texport NOTMUCH_BASE=%s\n\n", mail_directory);
531             printf ("to your ~/.bashrc file.\n\n");
532         }
533         free (default_path);
534     }
535
536     /* Coerce th directory into an absolute directory name. */
537     if (*mail_directory != '/') {
538         char *cwd, *absolute_mail_directory;
539
540         cwd = getcwd (NULL, 0);
541         if (cwd == NULL) {
542             fprintf (stderr, "Out of memory.\n");
543             exit (1);
544         }
545
546         if (asprintf (&absolute_mail_directory, "%s/%s",
547                       cwd, mail_directory) < 0)
548         {
549             fprintf (stderr, "Out of memory.\n");
550             exit (1);
551         }
552
553         free (cwd);
554         free (mail_directory);
555         mail_directory = absolute_mail_directory;
556
557         printf ("Abs: %s\n", mail_directory);
558     }
559
560     notmuch = notmuch_database_create (mail_directory);
561     if (notmuch == NULL) {
562         fprintf (stderr, "Failed to create new notmuch database at %s\n",
563                  mail_directory);
564         ret = NOTMUCH_STATUS_FILE_ERROR;
565         goto DONE;
566     }
567
568     printf ("OK. Let's take a look at the mail we can find in the directory\n");
569     printf ("%s ...\n", mail_directory);
570
571     count = 0;
572     count_files (mail_directory, &count);
573
574     printf ("Found %d total files. That's not much mail.\n\n", count);
575
576     printf ("Next, we'll inspect the messages and create a database of threads:\n");
577
578     add_files_state.ignore_read_only_directories = FALSE;
579     add_files_state.saw_read_only_directory = FALSE;
580     add_files_state.total_files = count;
581     add_files_state.processed_files = 0;
582     add_files_state.added_messages = 0;
583     add_files_state.callback = NULL;
584     gettimeofday (&add_files_state.tv_start, NULL);
585
586     ret = add_files (notmuch, mail_directory, &add_files_state);
587
588     gettimeofday (&tv_now, NULL);
589     elapsed = tv_elapsed (add_files_state.tv_start,
590                           tv_now);
591     printf ("Processed %d %s in ", add_files_state.processed_files,
592             add_files_state.processed_files == 1 ?
593             "file" : "total files");
594     print_formatted_seconds (elapsed);
595     if (elapsed > 1) {
596         printf (" (%d files/sec.).                 \n",
597                 (int) (add_files_state.processed_files / elapsed));
598     } else {
599         printf (".                    \n");
600     }
601     if (add_files_state.added_messages) {
602         printf ("Added %d %s to the database.\n\n",
603                 add_files_state.added_messages,
604                 add_files_state.added_messages == 1 ?
605                 "message" : "unique messages");
606     }
607
608     printf ("When new mail is delivered to %s in the future,\n"
609             "run \"notmuch new\" to add it to the database.\n\n",
610             mail_directory);
611
612     if (ret) {
613         printf ("Note: At least one error was encountered: %s\n",
614                 notmuch_status_to_string (ret));
615     }
616
617   DONE:
618     if (mail_directory)
619         free (mail_directory);
620     if (notmuch)
621         notmuch_database_close (notmuch);
622
623     return ret;
624 }
625
626 static void
627 tag_inbox_and_unread (notmuch_message_t *message)
628 {
629     notmuch_message_add_tag (message, "inbox");
630     notmuch_message_add_tag (message, "unread");
631 }
632
633 static int
634 new_command (unused (void *ctx), unused (int argc), unused (char *argv[]))
635 {
636     notmuch_database_t *notmuch;
637     const char *mail_directory;
638     add_files_state_t add_files_state;
639     double elapsed;
640     struct timeval tv_now;
641     int ret = 0;
642
643     notmuch = notmuch_database_open (NULL);
644     if (notmuch == NULL) {
645         ret = 1;
646         goto DONE;
647     }
648
649     mail_directory = notmuch_database_get_path (notmuch);
650
651     add_files_state.ignore_read_only_directories = TRUE;
652     add_files_state.saw_read_only_directory = FALSE;
653     add_files_state.total_files = 0;
654     add_files_state.processed_files = 0;
655     add_files_state.added_messages = 0;
656     add_files_state.callback = tag_inbox_and_unread;
657     gettimeofday (&add_files_state.tv_start, NULL);
658
659     ret = add_files (notmuch, mail_directory, &add_files_state);
660
661     gettimeofday (&tv_now, NULL);
662     elapsed = tv_elapsed (add_files_state.tv_start,
663                           tv_now);
664     if (add_files_state.processed_files) {
665         printf ("Processed %d %s in ", add_files_state.processed_files,
666                 add_files_state.processed_files == 1 ?
667                 "file" : "total files");
668         print_formatted_seconds (elapsed);
669         if (elapsed > 1) {
670             printf (" (%d files/sec.).                 \n",
671                     (int) (add_files_state.processed_files / elapsed));
672         } else {
673             printf (".                    \n");
674         }
675     }
676     if (add_files_state.added_messages) {
677         printf ("Added %d new %s to the database (not much, really).\n",
678                 add_files_state.added_messages,
679                 add_files_state.added_messages == 1 ?
680                 "message" : "messages");
681     } else {
682         printf ("No new mail---and that's not much.\n");
683     }
684
685     if (elapsed > 1 && ! add_files_state.saw_read_only_directory) {
686         printf ("\nTip: If you have any sub-directories that are archives (that is,\n"
687                 "they will never receive new mail), marking these directores as\n"
688                 "read-only (chmod u-w /path/to/dir) will make \"notmuch new\"\n"
689                 "much more efficient (it won't even look in those directories).\n");
690     }
691
692     if (ret) {
693         printf ("\nNote: At least one error was encountered: %s\n",
694                 notmuch_status_to_string (ret));
695     }
696
697   DONE:
698     if (notmuch)
699         notmuch_database_close (notmuch);
700
701     return ret;
702 }
703
704 /* Construct a single query string from the passed arguments, using
705  * 'ctx' as the talloc owner for all allocations.
706  *
707  * Currently, the arguments are just connected with space characters,
708  * but we might do more processing in the future, (such as inserting
709  * any AND operators needed to work around Xapian QueryParser bugs).
710  *
711  * This function returns NULL in case of insufficient memory.
712  */
713 static char *
714 query_string_from_args (void *ctx, int argc, char *argv[])
715 {
716     char *query_string;
717     int i;
718
719     query_string = talloc_strdup (ctx, "");
720     if (query_string == NULL)
721         return NULL;
722
723     for (i = 0; i < argc; i++) {
724         if (i != 0) {
725             query_string = talloc_strdup_append (query_string, " ");
726             if (query_string == NULL)
727                 return NULL;
728         }
729
730         query_string = talloc_strdup_append (query_string, argv[i]);
731         if (query_string == NULL)
732             return NULL;
733     }
734
735     return query_string;
736 }
737
738 /* Format a nice representation of 'time' relative to the current time.
739  *
740  * Examples include:
741  *
742  *      5 minutes ago   (For times less than 60 minutes ago)
743  *      12:30           (For times >60 minutes but still today)
744  *      Yesterday
745  *      Monday          (Before yesterday but fewer than 7 days ago)
746  *      Oct. 12         (Between 7 and 180 days ago (about 6 months))
747  *      2008-06-30      (More than 180 days ago)
748  */
749 #define MINUTE (60)
750 #define HOUR (60 * MINUTE)
751 #define DAY (24 * HOUR)
752 #define RELATIVE_DATE_MAX 20
753 static const char *
754 _format_relative_date (void *ctx, time_t then)
755 {
756     struct tm tm_now, tm_then;
757     time_t now = time(NULL);
758     time_t delta;
759     char *result;
760
761     localtime_r (&now, &tm_now);
762     localtime_r (&then, &tm_then);
763
764     result = talloc_zero_size (ctx, RELATIVE_DATE_MAX);
765     if (result == NULL)
766         return "when?";
767
768     if (then > now)
769         return "the future";
770
771     delta = now - then;
772
773     if (delta > 180 * DAY) {
774         strftime (result, RELATIVE_DATE_MAX,
775                   "%F", &tm_then); /* 2008-06-30 */
776         return result;
777     }
778
779     if (delta < 3600) {
780         snprintf (result, RELATIVE_DATE_MAX,
781                   "%d minutes ago", (int) (delta / 60));
782         return result;
783     }
784
785     if (delta <= 7 * DAY) {
786         if (tm_then.tm_wday == tm_now.tm_wday &&
787             delta < DAY)
788         {
789             strftime (result, RELATIVE_DATE_MAX,
790                       "%R", &tm_then); /* 12:30 */
791             return result;
792         } else if ((tm_now.tm_wday + 7 - tm_then.tm_wday) % 7 == 1) {
793             return "Yesterday";
794         } else {
795             if (tm_then.tm_wday != tm_now.tm_wday) {
796                 strftime (result, RELATIVE_DATE_MAX,
797                           "%A", &tm_then); /* Monday */
798                 return result;
799             }
800         }
801     }
802
803     strftime (result, RELATIVE_DATE_MAX,
804               "%b %d", &tm_then); /* Oct. 12 */
805     return result;
806 }
807 #undef MINUTE
808 #undef HOUR
809 #undef DAY
810
811 static int
812 search_command (void *ctx, int argc, char *argv[])
813 {
814     void *local = talloc_new (ctx);
815     notmuch_database_t *notmuch = NULL;
816     notmuch_query_t *query;
817     notmuch_threads_t *threads;
818     notmuch_thread_t *thread;
819     notmuch_tags_t *tags;
820     char *query_str;
821     const char *relative_date;
822     time_t date;
823     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
824
825     notmuch = notmuch_database_open (NULL);
826     if (notmuch == NULL) {
827         ret = 1;
828         goto DONE;
829     }
830
831     query_str = query_string_from_args (local, argc, argv);
832
833     query = notmuch_query_create (notmuch, query_str);
834     if (query == NULL) {
835         fprintf (stderr, "Out of memory\n");
836         ret = 1;
837         goto DONE;
838     }
839
840     for (threads = notmuch_query_search_threads (query);
841          notmuch_threads_has_more (threads);
842          notmuch_threads_advance (threads))
843     {
844         int first = 1;
845
846         thread = notmuch_threads_get (threads);
847
848         date = notmuch_thread_get_oldest_date (thread);
849         relative_date = _format_relative_date (local, date);
850
851         printf ("%s (%s) %s",
852                 notmuch_thread_get_thread_id (thread),
853                 relative_date,
854                 notmuch_thread_get_subject (thread));
855
856         printf (" (");
857         for (tags = notmuch_thread_get_tags (thread);
858              notmuch_tags_has_more (tags);
859              notmuch_tags_advance (tags))
860         {
861             if (! first)
862                 printf (" ");
863             printf ("%s", notmuch_tags_get (tags));
864             first = 0;
865         }
866         printf (")\n");
867
868         notmuch_thread_destroy (thread);
869     }
870
871     notmuch_query_destroy (query);
872
873   DONE:
874     if (notmuch)
875         notmuch_database_close (notmuch);
876     talloc_free (local);
877
878     return ret;
879 }
880
881 /* Get a nice, single-line summary of message. */
882 static const char *
883 _get_one_line_summary (void *ctx, notmuch_message_t *message)
884 {
885     const char *from;
886     time_t date;
887     const char *relative_date;
888     const char *subject;
889
890     from = notmuch_message_get_header (message, "from");
891
892     date = notmuch_message_get_date (message);
893     relative_date = _format_relative_date (ctx, date);
894
895     subject = notmuch_message_get_header (message, "subject");
896
897     return talloc_asprintf (ctx, "%s (%s) %s",
898                             from, relative_date, subject);
899 }
900
901 static void
902 show_message_part (GMimeObject *part, int *part_count)
903 {
904     GMimeStream *stream;
905     GMimeDataWrapper *wrapper;
906     GMimeContentDisposition *disposition;
907     GMimeContentType *content_type;
908
909     *part_count = *part_count + 1;
910
911     if (GMIME_IS_MULTIPART (part)) {
912         GMimeMultipart *multipart = GMIME_MULTIPART (part);
913         int i;
914
915         for (i = 0; i < g_mime_multipart_get_count (multipart); i++) {
916             if (GMIME_IS_MULTIPART_SIGNED (multipart)) {
917                 /* Don't index the signature. */
918                 if (i == 1)
919                     continue;
920                 if (i > 1)
921                     fprintf (stderr, "Warning: Unexpected extra parts of mutlipart/signed. Continuing.\n");
922             }
923             show_message_part (g_mime_multipart_get_part (multipart, i),
924                                part_count);
925         }
926         return;
927     }
928
929     if (GMIME_IS_MESSAGE_PART (part)) {
930         GMimeMessage *mime_message;
931
932         mime_message = g_mime_message_part_get_message (GMIME_MESSAGE_PART (part));
933
934         show_message_part (g_mime_message_get_mime_part (mime_message),
935                            part_count);
936
937         return;
938     }
939
940     if (! (GMIME_IS_PART (part))) {
941         fprintf (stderr, "Warning: Not displaying unknown mime part: %s.\n",
942                  g_type_name (G_OBJECT_TYPE (part)));
943         return;
944     }
945
946     disposition = g_mime_object_get_content_disposition (part);
947     if (disposition &&
948         strcmp (disposition->disposition, GMIME_DISPOSITION_ATTACHMENT) == 0)
949     {
950         const char *filename = g_mime_part_get_filename (GMIME_PART (part));
951         content_type = g_mime_object_get_content_type (GMIME_OBJECT (part));
952
953         printf ("%%attachment{ ID: %d, Content-type: %s, ",
954                 *part_count,
955                 g_mime_content_type_to_string (content_type));
956         printf ("Filename: %s ", filename);
957         printf ("%%attachment}\n");
958
959         return;
960     }
961
962     content_type = g_mime_object_get_content_type (GMIME_OBJECT (part));
963
964     printf ("%%part{ ID: %d, Content-type: %s\n",
965             *part_count,
966             g_mime_content_type_to_string (content_type));
967
968     if (g_mime_content_type_is_type (content_type, "text", "*") &&
969         !g_mime_content_type_is_type (content_type, "text", "html"))
970     {
971         stream = g_mime_stream_file_new (stdout);
972         g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream), FALSE);
973
974         wrapper = g_mime_part_get_content_object (GMIME_PART (part));
975         if (wrapper)
976             g_mime_data_wrapper_write_to_stream (wrapper, stream);
977     }
978
979     printf ("%%part}\n");
980
981     g_object_unref (stream);
982 }
983
984 static notmuch_status_t
985 show_message_body (const char *filename)
986 {
987     GMimeStream *stream = NULL;
988     GMimeParser *parser = NULL;
989     GMimeMessage *mime_message = NULL;
990     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
991     static int initialized = 0;
992     FILE *file = NULL;
993     int part_count = 0;
994
995     if (! initialized) {
996         g_mime_init (0);
997         initialized = 1;
998     }
999
1000     file = fopen (filename, "r");
1001     if (! file) {
1002         fprintf (stderr, "Error opening %s: %s\n", filename, strerror (errno));
1003         ret = NOTMUCH_STATUS_FILE_ERROR;
1004         goto DONE;
1005     }
1006
1007     stream = g_mime_stream_file_new (file);
1008     g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream), FALSE);
1009
1010     parser = g_mime_parser_new_with_stream (stream);
1011
1012     mime_message = g_mime_parser_construct_message (parser);
1013
1014     show_message_part (g_mime_message_get_mime_part (mime_message),
1015                        &part_count);
1016
1017   DONE:
1018     if (mime_message)
1019         g_object_unref (mime_message);
1020
1021     if (parser)
1022         g_object_unref (parser);
1023
1024     if (stream)
1025         g_object_unref (stream);
1026
1027     if (file)
1028         fclose (file);
1029
1030     return ret;
1031 }
1032
1033 static int
1034 show_command (void *ctx, unused (int argc), unused (char *argv[]))
1035 {
1036     void *local = talloc_new (ctx);
1037     char *query_string;
1038     notmuch_database_t *notmuch = NULL;
1039     notmuch_query_t *query = NULL;
1040     notmuch_messages_t *messages;
1041     notmuch_message_t *message;
1042     int ret = 0;
1043
1044     const char *headers[] = {
1045         "Subject", "From", "To", "Cc", "Bcc", "Date"
1046     };
1047     const char *name, *value;
1048     unsigned int i;
1049
1050     if (argc != 1) {
1051         fprintf (stderr, "Error: \"notmuch show\" requires exactly one thread-ID argument.\n");
1052         ret = 1;
1053         goto DONE;
1054     }
1055
1056     notmuch = notmuch_database_open (NULL);
1057     if (notmuch == NULL) {
1058         ret = 1;
1059         goto DONE;
1060     }
1061
1062     query_string = talloc_asprintf (local, "thread:%s", argv[0]);
1063     if (query_string == NULL) {
1064         fprintf (stderr, "Out of memory\n");
1065         ret = 1;
1066         goto DONE;
1067     }
1068
1069     query = notmuch_query_create (notmuch, query_string);
1070     if (query == NULL) {
1071         fprintf (stderr, "Out of memory\n");
1072         ret = 1;
1073         goto DONE;
1074     }
1075
1076     for (messages = notmuch_query_search_messages (query);
1077          notmuch_messages_has_more (messages);
1078          notmuch_messages_advance (messages))
1079     {
1080         message = notmuch_messages_get (messages);
1081
1082         printf ("%%message{\n");
1083
1084         printf ("%%header{\n");
1085
1086         printf ("%s\n", _get_one_line_summary (local, message));
1087
1088         for (i = 0; i < ARRAY_SIZE (headers); i++) {
1089             name = headers[i];
1090             value = notmuch_message_get_header (message, name);
1091             if (value)
1092                 printf ("%s: %s\n", name, value);
1093         }
1094
1095         printf ("%%header}\n");
1096
1097         show_message_body (notmuch_message_get_filename (message));
1098
1099         printf ("%%message}\n");
1100
1101         notmuch_message_destroy (message);
1102     }
1103
1104   DONE:
1105     if (local)
1106         talloc_free (local);
1107
1108     if (query)
1109         notmuch_query_destroy (query);
1110
1111     if (notmuch)
1112         notmuch_database_close (notmuch);
1113
1114     return ret;
1115 }
1116
1117 static int
1118 tag_command (void *ctx, unused (int argc), unused (char *argv[]))
1119 {
1120     void *local;
1121     int *add_tags, *remove_tags;
1122     int add_tags_count = 0;
1123     int remove_tags_count = 0;
1124     char *query_string;
1125     notmuch_database_t *notmuch = NULL;
1126     notmuch_query_t *query;
1127     notmuch_messages_t *messages;
1128     notmuch_message_t *message;
1129     int ret = 0;
1130     int i;
1131
1132     local = talloc_new (ctx);
1133     if (local == NULL) {
1134         ret = 1;
1135         goto DONE;
1136     }
1137
1138     add_tags = talloc_size (local, argc * sizeof (int));
1139     if (add_tags == NULL) {
1140         ret = 1;
1141         goto DONE;
1142     }
1143
1144     remove_tags = talloc_size (local, argc * sizeof (int));
1145     if (remove_tags == NULL) {
1146         ret = 1;
1147         goto DONE;
1148     }
1149
1150     for (i = 0; i < argc; i++) {
1151         if (strcmp (argv[i], "--") == 0) {
1152             i++;
1153             break;
1154         }
1155         if (argv[i][0] == '+') {
1156             add_tags[add_tags_count++] = i;
1157         } else if (argv[i][0] == '-') {
1158             remove_tags[remove_tags_count++] = i;
1159         } else {
1160             break;
1161         }
1162     }
1163
1164     if (add_tags_count == 0 && remove_tags_count == 0) {
1165         fprintf (stderr, "Error: 'notmuch tag' requires at least one tag to add or remove.\n");
1166         ret = 1;
1167         goto DONE;
1168     }
1169
1170     if (i == argc) {
1171         fprintf (stderr, "Error: 'notmuch tag' requires at least one search term.\n");
1172         ret = 1;
1173         goto DONE;
1174     }
1175
1176     notmuch = notmuch_database_open (NULL);
1177     if (notmuch == NULL) {
1178         ret = 1;
1179         goto DONE;
1180     }
1181
1182     query_string = query_string_from_args (local, argc - i, &argv[i]);
1183
1184     query = notmuch_query_create (notmuch, query_string);
1185     if (query == NULL) {
1186         fprintf (stderr, "Out of memory.\n");
1187         ret = 1;
1188         goto DONE;
1189     }
1190
1191     for (messages = notmuch_query_search_messages (query);
1192          notmuch_messages_has_more (messages);
1193          notmuch_messages_advance (messages))
1194     {
1195         message = notmuch_messages_get (messages);
1196
1197         notmuch_message_freeze (message);
1198
1199         for (i = 0; i < remove_tags_count; i++)
1200             notmuch_message_remove_tag (message,
1201                                         argv[remove_tags[i]] + 1);
1202
1203         for (i = 0; i < add_tags_count; i++)
1204             notmuch_message_add_tag (message, argv[add_tags[i]] + 1);
1205
1206         notmuch_message_thaw (message);
1207
1208         notmuch_message_destroy (message);
1209     }
1210
1211     notmuch_query_destroy (query);
1212
1213   DONE:
1214     if (notmuch)
1215         notmuch_database_close (notmuch);
1216
1217     talloc_free (local);
1218
1219     return ret;
1220 }
1221
1222 static int
1223 dump_command (unused (void *ctx), int argc, char *argv[])
1224 {
1225     FILE *output = NULL;
1226     notmuch_database_t *notmuch = NULL;
1227     notmuch_query_t *query;
1228     notmuch_messages_t *messages;
1229     notmuch_message_t *message;
1230     notmuch_tags_t *tags;
1231     int ret = 0;
1232
1233     if (argc) {
1234         output = fopen (argv[0], "w");
1235         if (output == NULL) {
1236             fprintf (stderr, "Error opening %s for writing: %s\n",
1237                      argv[0], strerror (errno));
1238             ret = 1;
1239             goto DONE;
1240         }
1241     } else {
1242         output = stdout;
1243     }
1244
1245     notmuch = notmuch_database_open (NULL);
1246     if (notmuch == NULL) {
1247         ret = 1;
1248         goto DONE;
1249     }
1250
1251     query = notmuch_query_create (notmuch, "");
1252     if (query == NULL) {
1253         fprintf (stderr, "Out of memory\n");
1254         ret = 1;
1255         goto DONE;
1256     }
1257
1258     notmuch_query_set_sort (query, NOTMUCH_SORT_MESSAGE_ID);
1259
1260     for (messages = notmuch_query_search_messages (query);
1261          notmuch_messages_has_more (messages);
1262          notmuch_messages_advance (messages))
1263     {
1264         int first = 1;
1265         message = notmuch_messages_get (messages);
1266
1267         fprintf (output,
1268                  "%s (", notmuch_message_get_message_id (message));
1269
1270         for (tags = notmuch_message_get_tags (message);
1271              notmuch_tags_has_more (tags);
1272              notmuch_tags_advance (tags))
1273         {
1274             if (! first)
1275                 fprintf (output, " ");
1276
1277             fprintf (output, "%s", notmuch_tags_get (tags));
1278
1279             first = 0;
1280         }
1281
1282         fprintf (output, ")\n");
1283
1284         notmuch_message_destroy (message);
1285     }
1286
1287     notmuch_query_destroy (query);
1288
1289   DONE:
1290     if (notmuch)
1291         notmuch_database_close (notmuch);
1292     if (output && output != stdout)
1293         fclose (output);
1294
1295     return ret;
1296 }
1297
1298 static int
1299 restore_command (unused (void *ctx), int argc, char *argv[])
1300 {
1301     FILE *input = NULL;
1302     notmuch_database_t *notmuch = NULL;
1303     char *line = NULL;
1304     size_t line_size;
1305     ssize_t line_len;
1306     regex_t regex;
1307     int rerr;
1308     int ret = 0;
1309
1310     if (argc) {
1311         input = fopen (argv[0], "r");
1312         if (input == NULL) {
1313             fprintf (stderr, "Error opening %s for reading: %s\n",
1314                      argv[0], strerror (errno));
1315             ret = 1;
1316             goto DONE;
1317         }
1318     } else {
1319         printf ("No filename given. Reading dump from stdin.\n");
1320         input = stdin;
1321     }
1322
1323     notmuch = notmuch_database_open (NULL);
1324     if (notmuch == NULL) {
1325         ret = 1;
1326         goto DONE;
1327     }
1328
1329     /* Dump output is one line per message. We match a sequence of
1330      * non-space characters for the message-id, then one or more
1331      * spaces, then a list of space-separated tags as a sequence of
1332      * characters within literal '(' and ')'. */
1333     xregcomp (&regex,
1334               "^([^ ]+) \\(([^)]*)\\)$",
1335               REG_EXTENDED);
1336
1337     while ((line_len = getline (&line, &line_size, input)) != -1) {
1338         regmatch_t match[3];
1339         char *message_id, *tags, *tag, *next;
1340         notmuch_message_t *message;
1341         notmuch_status_t status;
1342
1343         chomp_newline (line);
1344
1345         rerr = xregexec (&regex, line, 3, match, 0);
1346         if (rerr == REG_NOMATCH)
1347         {
1348             fprintf (stderr, "Warning: Ignoring invalid input line: %s\n",
1349                      line);
1350             continue;
1351         }
1352
1353         message_id = xstrndup (line + match[1].rm_so,
1354                                match[1].rm_eo - match[1].rm_so);
1355         tags = xstrndup (line + match[2].rm_so,
1356                          match[2].rm_eo - match[2].rm_so);
1357
1358         if (strlen (tags)) {
1359
1360             message = notmuch_database_find_message (notmuch, message_id);
1361             if (message == NULL) {
1362                 fprintf (stderr, "Warning: Cannot apply tags to missing message: %s\n",
1363                          message_id);
1364                 goto NEXT_LINE;
1365             }
1366
1367             notmuch_message_freeze (message);
1368
1369             notmuch_message_remove_all_tags (message);
1370
1371             next = tags;
1372             while (next) {
1373                 tag = strsep (&next, " ");
1374                 if (*tag == '\0')
1375                     continue;
1376                 status = notmuch_message_add_tag (message, tag);
1377                 if (status) {
1378                     fprintf (stderr,
1379                              "Error applying tag %s to message %s:\n",
1380                              tag, message_id);
1381                     fprintf (stderr, "%s\n",
1382                              notmuch_status_to_string (status));
1383                 }
1384             }
1385
1386             notmuch_message_thaw (message);
1387             notmuch_message_destroy (message);
1388         }
1389       NEXT_LINE:
1390         free (message_id);
1391         free (tags);
1392     }
1393
1394     regfree (&regex);
1395
1396   DONE:
1397     if (line)
1398         free (line);
1399     if (notmuch)
1400         notmuch_database_close (notmuch);
1401     if (input && input != stdin)
1402         fclose (input);
1403
1404     return ret;
1405 }
1406
1407 static int
1408 help_command (void *ctx, int argc, char *argv[]);
1409
1410 command_t commands[] = {
1411     { "setup", setup_command,
1412       "Interactively setup notmuch for first use.",
1413       "\t\tThe setup command is the first command you will run in order\n"
1414       "\t\tto start using notmuch. It will prompt you for the directory\n"
1415       "\t\tcontaining your email archives, and will then proceed to build\n"
1416       "\t\ta database to allow fast searching of that mail.\n\n"
1417       "\t\tInvoking notmuch with no command argument will run setup if\n"
1418       "\t\tthe setup command has not previously been completed." },
1419     { "new", new_command,
1420       "Find and import any new messages.",
1421       "\t\tScans all sub-directories of the database, adding new messages\n"
1422       "\t\tthat are found. Each new message will be tagged as both\n"
1423       "\t\t\"inbox\" and \"unread\".\n"
1424       "\n"
1425       "\t\tNote: \"notmuch new\" will skip any read-only directories,\n"
1426       "\t\tso you can use that to mark directories that will not\n"
1427       "\t\treceive any new mail (and make \"notmuch new\" faster)." },
1428     { "search", search_command,
1429       "<search-term> [...]\n\n"
1430       "\t\tSearch for threads matching the given search terms.",
1431       "\t\tNote that the individual mail messages will be matched\n"
1432       "\t\tagainst the search terms, but the results will be the\n"
1433       "\t\tthreads containing the matched messages.\n\n"
1434       "\t\tCurrently, the supported search terms are as follows, (where\n"
1435       "\t\t<brackets> indicate user-supplied values):\n\n"
1436       "\t\t\ttag:<tag>\n"
1437       "\t\t\tid:<message-id>\n"
1438       "\t\t\tthread:<thread-id>\n\n"
1439       "\t\tValid tag values include \"inbox\" and \"unread\" by default\n"
1440       "\t\tfor new messages added by \"notmuch new\" as well as any other\n"
1441       "\t\ttag values added manually with \"notmuch tag\".\n\n"
1442       "\t\tMessage ID values are the literal contents of the Message-ID:\n"
1443       "\t\theader of email messages, but without the '<','>' delimiters.\n\n"
1444       "\t\tThread ID values are generated internally by notmuch but can\n"
1445       "\t\tbe seen in the output of \"notmuch search\" for example.\n\n"
1446       "\t\tIn addition to individual terms, multiple terms can be\n"
1447       "\t\tcombined with Boolean operators (\"and\", \"or\", \"not\", etc.).\n"
1448       "\t\tEach term in the query will be implicitly connected by a\n"
1449       "\t\tlogical AND if no explicit operator is provided, (except\n"
1450       "\t\tthat terms with a common prefix will be implicitly combined\n"
1451       "\t\twith OR until we get Xapian defect #402 fixed).\n\n"
1452       "\t\tParentheses can also be used to control the combination of\n"
1453       "\t\tthe Boolean operators, but will have to be protected from\n"
1454       "\t\tinterpretation by the shell, (such as by putting quotation\n"
1455       "\t\tmarks around any parenthesized expression)." },
1456     { "show", show_command,
1457       "<thread-id>\n\n"
1458       "\t\tShow the thread with the given thread ID (see 'search').",
1459       "\t\tThread ID values are given as the first column in the\n"
1460       "\t\toutput of the \"notmuch search\" command. These are the\n"
1461       "\t\trandom-looking strings of 32 characters." },
1462     { "tag", tag_command,
1463       "+<tag>|-<tag> [...] [--] <search-term> [...]\n\n"
1464       "\t\tAdd/remove tags for all messages matching the search terms.",
1465       "\t\tThe search terms are handled exactly as in 'search' so one\n"
1466       "\t\tcan use that command first to see what will be modified.\n\n"
1467       "\t\tTags prefixed by '+' are added while those prefixed by '-' are\n"
1468       "\t\tremoved. For each message, tag removal is before tag addition.\n\n"
1469       "\t\tThe beginning of <search-terms> is recognized by the first\n"
1470       "\t\targument that begins with neither '+' nor '-'. Support for\n"
1471       "\t\tan initial search term beginning with '+' or '-' is provided\n"
1472       "\t\tby allowing the user to specify a \"--\" argument to separate\n"
1473       "\t\tthe tags from the search terms.\n\n"
1474       "\t\tNote: If you run \"notmuch new\" between reading a thread with\n"
1475       "\t\t\"notmuch show\" and removing the \"inbox\" tag for that thread\n"
1476       "\t\twith \"notmuch tag\" then you create the possibility of moving\n"
1477       "\t\tsome messages from that thread out of your inbox without ever\n"
1478       "\t\treading them. The easiest way to avoid this problem is to not\n"
1479       "\t\trun \"notmuch new\" between reading and removing tags." },
1480     { "dump", dump_command,
1481       "[<filename>]\n\n"
1482       "\t\tCreate a plain-text dump of the tags for each message.",
1483       "\t\tOutput is to the given filename, if any, or to stdout.\n"
1484       "\t\tThese tags are the only data in the notmuch database\n"
1485       "\t\tthat can't be recreated from the messages themselves.\n"
1486       "\t\tThe output of notmuch dump is therefore the only\n"
1487       "\t\tcritical thing to backup (and much more friendly to\n"
1488       "\t\tincremental backup than the native database files.)" },
1489     { "restore", restore_command,
1490       "<filename>\n\n"
1491       "\t\tRestore the tags from the given dump file (see 'dump').",
1492       "\t\tNote: The dump file format is specifically chosen to be\n"
1493       "\t\tcompatible with the format of files produced by sup-dump.\n"
1494       "\t\tSo if you've previously been using sup for mail, then the\n"
1495       "\t\t\"notmuch restore\" command provides you a way to import\n"
1496       "\t\tall of your tags (or labels as sup calls them)." },
1497     { "help", help_command,
1498       "[<command>]\n\n"
1499       "\t\tThis message, or more detailed help for the named command.",
1500       "\t\tExcept in this case, where there's not much more detailed\n"
1501       "\t\thelp available." }
1502 };
1503
1504 static void
1505 usage (void)
1506 {
1507     command_t *command;
1508     unsigned int i;
1509
1510     fprintf (stderr, "Usage: notmuch <command> [args...]\n");
1511     fprintf (stderr, "\n");
1512     fprintf (stderr, "Where <command> and [args...] are as follows:\n");
1513     fprintf (stderr, "\n");
1514
1515     for (i = 0; i < ARRAY_SIZE (commands); i++) {
1516         command = &commands[i];
1517
1518         fprintf (stderr, "\t%s\t%s\n\n", command->name, command->summary);
1519     }
1520
1521     fprintf (stderr, "Use \"notmuch help <command>\" for more details on each command.\n\n");
1522 }
1523
1524 static int
1525 help_command (unused (void *ctx), int argc, char *argv[])
1526 {
1527     command_t *command;
1528     unsigned int i;
1529
1530     if (argc == 0) {
1531         fprintf (stderr, "The notmuch mail system.\n\n");
1532         usage ();
1533         return 0;
1534     }
1535
1536     for (i = 0; i < ARRAY_SIZE (commands); i++) {
1537         command = &commands[i];
1538
1539         if (strcmp (argv[0], command->name) == 0) {
1540             fprintf (stderr, "Help for \"notmuch %s\":\n\n", argv[0]);
1541             fprintf (stderr, "\t%s\t%s\n\n%s\n\n", command->name,
1542                      command->summary, command->documentation);
1543             return 0;
1544         }
1545     }
1546
1547     fprintf (stderr,
1548              "\nSorry, %s is not a known command. There's not much I can do to help.\n\n",
1549              argv[0]);
1550     return 1;
1551 }
1552     
1553 int
1554 main (int argc, char *argv[])
1555 {
1556     void *local = talloc_new (NULL);
1557     command_t *command;
1558     unsigned int i;
1559
1560     if (argc == 1)
1561         return setup_command (local, 0, NULL);
1562
1563     for (i = 0; i < ARRAY_SIZE (commands); i++) {
1564         command = &commands[i];
1565
1566         if (strcmp (argv[1], command->name) == 0)
1567             return (command->function) (local, argc - 2, &argv[2]);
1568     }
1569
1570     /* Don't complain about "help" being an unknown command when we're
1571        about to provide exactly what's wanted anyway. */
1572     fprintf (stderr, "Error: Unknown command '%s' (see \"notmuch help\")\n",
1573              argv[1]);
1574
1575     talloc_free (local);
1576
1577     return 1;
1578 }