Unbreak the "notmuch setup" command.
[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 "notmuch.h"
27
28 /* This is separate from notmuch-private.h because we're trying to
29  * keep notmuch.c from looking into any internals, (which helps us
30  * develop notmuch.h into a plausible library interface).
31  */
32 #include "xutil.h"
33
34 #include <stddef.h>
35 #include <string.h>
36 #include <sys/stat.h>
37 #include <sys/time.h>
38 #include <unistd.h>
39 #include <dirent.h>
40 #include <errno.h>
41
42 #include <talloc.h>
43
44 #define unused(x) x __attribute__ ((unused))
45
46 /* There's no point in continuing when we've detected that we've done
47  * something wrong internally (as opposed to the user passing in a
48  * bogus value).
49  *
50  * Note that __location__ comes from talloc.h.
51  */
52 #define INTERNAL_ERROR(format, ...)                     \
53     do {                                                \
54         fprintf(stderr,                                 \
55                 "Internal error: " format " (%s)\n",    \
56                 ##__VA_ARGS__, __location__);           \
57         exit (1);                                       \
58     } while (0)
59
60 #define ARRAY_SIZE(arr) (sizeof (arr) / sizeof (arr[0]))
61
62 typedef int (*command_function_t) (int argc, char *argv[]);
63
64 typedef struct command {
65     const char *name;
66     command_function_t function;
67     const char *usage;
68 } command_t;
69
70 typedef void (*add_files_callback_t) (notmuch_message_t *message);
71
72 typedef struct {
73     int ignore_read_only_directories;
74     int saw_read_only_directory;
75
76     int total_files;
77     int processed_files;
78     int added_messages;
79     struct timeval tv_start;
80
81     add_files_callback_t callback;
82 } add_files_state_t;
83
84 static void
85 chomp_newline (char *str)
86 {
87     if (str && str[strlen(str)-1] == '\n')
88         str[strlen(str)-1] = '\0';
89 }
90
91 /* Compute the number of seconds elapsed from start to end. */
92 static double
93 tv_elapsed (struct timeval start, struct timeval end)
94 {
95     return ((end.tv_sec - start.tv_sec) +
96             (end.tv_usec - start.tv_usec) / 1e6);
97 }
98
99 static void
100 print_formatted_seconds (double seconds)
101 {
102     int hours;
103     int minutes;
104
105     if (seconds < 1) {
106         printf ("almost no time");
107         return;
108     }
109
110     if (seconds > 3600) {
111         hours = (int) seconds / 3600;
112         printf ("%dh ", hours);
113         seconds -= hours * 3600;
114     }
115
116     if (seconds > 60) {
117         minutes = (int) seconds / 60;
118         printf ("%dm ", minutes);
119         seconds -= minutes * 60;
120     }
121
122     printf ("%ds", (int) seconds);
123 }
124
125 static void
126 add_files_print_progress (add_files_state_t *state)
127 {
128     struct timeval tv_now;
129     double elapsed_overall, rate_overall;
130
131     gettimeofday (&tv_now, NULL);
132
133     elapsed_overall = tv_elapsed (state->tv_start, tv_now);
134     rate_overall = (state->processed_files) / elapsed_overall;
135
136     printf ("Processed %d", state->processed_files);
137
138     if (state->total_files) {
139         printf (" of %d files (", state->total_files);
140         print_formatted_seconds ((state->total_files - state->processed_files) /
141                                  rate_overall);
142         printf (" remaining).      \r");
143     } else {
144         printf (" files (%d files/sec.)    \r", (int) rate_overall);
145     }
146
147     fflush (stdout);
148 }
149
150 /* Examine 'path' recursively as follows:
151  *
152  *   o Ask the filesystem for the mtime of 'path' (path_mtime)
153  *
154  *   o Ask the database for its timestamp of 'path' (path_dbtime)
155  *
156  *   o If 'path_mtime' > 'path_dbtime'
157  *
158  *       o For each regular file in 'path' with mtime newer than the
159  *         'path_dbtime' call add_message to add the file to the
160  *         database.
161  *
162  *       o For each sub-directory of path, recursively call into this
163  *         same function.
164  *
165  *   o Tell the database to update its time of 'path' to 'path_mtime'
166  *
167  * The 'struct stat *st' must point to a structure that has already
168  * been initialized for 'path' by calling stat().
169  */
170 static notmuch_status_t
171 add_files_recursive (notmuch_database_t *notmuch,
172                      const char *path,
173                      struct stat *st,
174                      add_files_state_t *state)
175 {
176     DIR *dir = NULL;
177     struct dirent *e, *entry = NULL;
178     int entry_length;
179     int err;
180     char *next = NULL;
181     time_t path_mtime, path_dbtime;
182     notmuch_status_t status, ret = NOTMUCH_STATUS_SUCCESS;
183     notmuch_message_t *message, **closure;
184
185     /* If we're told to, we bail out on encountering a read-only
186      * directory, (with this being a clear clue from the user to
187      * Notmuch that new mail won't be arriving there and we need not
188      * look. */
189     if (state->ignore_read_only_directories &&
190         (st->st_mode & S_IWUSR) == 0)
191     {
192         state->saw_read_only_directory = TRUE;
193         goto DONE;
194     }
195
196     path_mtime = st->st_mtime;
197
198     path_dbtime = notmuch_database_get_timestamp (notmuch, path);
199
200     dir = opendir (path);
201     if (dir == NULL) {
202         fprintf (stderr, "Error opening directory %s: %s\n",
203                  path, strerror (errno));
204         ret = NOTMUCH_STATUS_FILE_ERROR;
205         goto DONE;
206     }
207
208     entry_length = offsetof (struct dirent, d_name) +
209         pathconf (path, _PC_NAME_MAX) + 1;
210     entry = malloc (entry_length);
211
212     while (1) {
213         err = readdir_r (dir, entry, &e);
214         if (err) {
215             fprintf (stderr, "Error reading directory: %s\n",
216                      strerror (errno));
217             ret = NOTMUCH_STATUS_FILE_ERROR;
218             goto DONE;
219         }
220
221         if (e == NULL)
222             break;
223
224         /* If this directory hasn't been modified since the last
225          * add_files, then we only need to look further for
226          * sub-directories. */
227         if (path_mtime <= path_dbtime && entry->d_type != DT_DIR)
228             continue;
229
230         /* Ignore special directories to avoid infinite recursion.
231          * Also ignore the .notmuch directory.
232          */
233         /* XXX: Eventually we'll want more sophistication to let the
234          * user specify files to be ignored. */
235         if (strcmp (entry->d_name, ".") == 0 ||
236             strcmp (entry->d_name, "..") == 0 ||
237             strcmp (entry->d_name, ".notmuch") ==0)
238         {
239             continue;
240         }
241
242         next = talloc_asprintf (notmuch, "%s/%s", path, entry->d_name);
243
244         if (stat (next, st)) {
245             fprintf (stderr, "Error reading %s: %s\n",
246                      next, strerror (errno));
247             ret = NOTMUCH_STATUS_FILE_ERROR;
248             continue;
249         }
250
251         if (S_ISREG (st->st_mode)) {
252             /* If the file hasn't been modified since the last
253              * add_files, then we need not look at it. */
254             if (st->st_mtime > path_dbtime) {
255                 state->processed_files++;
256
257                 if (state->callback)
258                     closure = &message;
259                 else
260                     closure = NULL;
261
262                 status = notmuch_database_add_message (notmuch, next, closure);
263                 switch (status) {
264                     /* success */
265                     case NOTMUCH_STATUS_SUCCESS:
266                         state->added_messages++;
267                         if (state->callback) {
268                             (state->callback) (message);
269                             notmuch_message_destroy (message);
270                         }
271                         break;
272                     /* Non-fatal issues (go on to next file) */
273                     case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
274                         /* Stay silent on this one. */
275                         break;
276                     case NOTMUCH_STATUS_FILE_NOT_EMAIL:
277                         fprintf (stderr, "Note: Ignoring non-mail file: %s\n",
278                                  next);
279                         break;
280                     /* Fatal issues. Don't process anymore. */
281                     case NOTMUCH_STATUS_XAPIAN_EXCEPTION:
282                     case NOTMUCH_STATUS_OUT_OF_MEMORY:
283                         fprintf (stderr, "Error: %s. Halting processing.\n",
284                                  notmuch_status_to_string (status));
285                         ret = status;
286                         goto DONE;
287                     default:
288                     case NOTMUCH_STATUS_FILE_ERROR:
289                     case NOTMUCH_STATUS_NULL_POINTER:
290                     case NOTMUCH_STATUS_TAG_TOO_LONG:
291                     case NOTMUCH_STATUS_LAST_STATUS:
292                         INTERNAL_ERROR ("add_message returned unexpected value: %d",  status);
293                         goto DONE;
294                 }
295                 if (state->processed_files % 1000 == 0)
296                     add_files_print_progress (state);
297             }
298         } else if (S_ISDIR (st->st_mode)) {
299             status = add_files_recursive (notmuch, next, st, state);
300             if (status && ret == NOTMUCH_STATUS_SUCCESS)
301                 ret = status;
302         }
303
304         talloc_free (next);
305         next = NULL;
306     }
307
308     status = notmuch_database_set_timestamp (notmuch, path, path_mtime);
309     if (status && ret == NOTMUCH_STATUS_SUCCESS)
310         ret = status;
311
312   DONE:
313     if (next)
314         talloc_free (next);
315     if (entry)
316         free (entry);
317     if (dir)
318         closedir (dir);
319
320     return ret;
321 }
322
323 /* This is the top-level entry point for add_files. It does a couple
324  * of error checks, and then calls into the recursive function,
325  * (avoiding the repeating of these error checks at every
326  * level---which would be useless becaues we already do a stat() at
327  * the level above). */
328 static notmuch_status_t
329 add_files (notmuch_database_t *notmuch,
330            const char *path,
331            add_files_state_t *state)
332 {
333     struct stat st;
334
335     if (stat (path, &st)) {
336         fprintf (stderr, "Error reading directory %s: %s\n",
337                  path, strerror (errno));
338         return NOTMUCH_STATUS_FILE_ERROR;
339     }
340
341     if (! S_ISDIR (st.st_mode)) {
342         fprintf (stderr, "Error: %s is not a directory.\n", path);
343         return NOTMUCH_STATUS_FILE_ERROR;
344     }
345
346     return add_files_recursive (notmuch, path, &st, state);
347 }
348
349 /* Recursively count all regular files in path and all sub-direcotries
350  * of path.  The result is added to *count (which should be
351  * initialized to zero by the top-level caller before calling
352  * count_files). */
353 static void
354 count_files (const char *path, int *count)
355 {
356     DIR *dir;
357     struct dirent *e, *entry = NULL;
358     int entry_length;
359     int err;
360     char *next;
361     struct stat st;
362
363     dir = opendir (path);
364
365     if (dir == NULL) {
366         fprintf (stderr, "Warning: failed to open directory %s: %s\n",
367                  path, strerror (errno));
368         goto DONE;
369     }
370
371     entry_length = offsetof (struct dirent, d_name) +
372         pathconf (path, _PC_NAME_MAX) + 1;
373     entry = malloc (entry_length);
374
375     while (1) {
376         err = readdir_r (dir, entry, &e);
377         if (err) {
378             fprintf (stderr, "Error reading directory: %s\n",
379                      strerror (errno));
380             free (entry);
381             goto DONE;
382         }
383
384         if (e == NULL)
385             break;
386
387         /* Ignore special directories to avoid infinite recursion.
388          * Also ignore the .notmuch directory.
389          */
390         /* XXX: Eventually we'll want more sophistication to let the
391          * user specify files to be ignored. */
392         if (strcmp (entry->d_name, ".") == 0 ||
393             strcmp (entry->d_name, "..") == 0 ||
394             strcmp (entry->d_name, ".notmuch") == 0)
395         {
396             continue;
397         }
398
399         if (asprintf (&next, "%s/%s", path, entry->d_name) == -1) {
400             next = NULL;
401             fprintf (stderr, "Error descending from %s to %s: Out of memory\n",
402                      path, entry->d_name);
403             continue;
404         }
405
406         stat (next, &st);
407
408         if (S_ISREG (st.st_mode)) {
409             *count = *count + 1;
410             if (*count % 1000 == 0) {
411                 printf ("Found %d files so far.\r", *count);
412                 fflush (stdout);
413             }
414         } else if (S_ISDIR (st.st_mode)) {
415             count_files (next, count);
416         }
417
418         free (next);
419     }
420
421   DONE:
422     if (entry)
423         free (entry);
424
425     closedir (dir);
426 }
427
428 static int
429 setup_command (unused (int argc), unused (char *argv[]))
430 {
431     notmuch_database_t *notmuch = NULL;
432     char *default_path, *mail_directory = NULL;
433     size_t line_size;
434     int count;
435     add_files_state_t add_files_state;
436     double elapsed;
437     struct timeval tv_now;
438     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
439
440     printf ("Welcome to notmuch!\n\n");
441
442     printf ("The goal of notmuch is to help you manage and search your collection of\n"
443             "email, and to efficiently keep up with the flow of email as it comes in.\n\n");
444
445     printf ("Notmuch needs to know the top-level directory of your email archive,\n"
446             "(where you already have mail stored and where messages will be delivered\n"
447             "in the future). This directory can contain any number of sub-directories\n"
448             "and primarily just files with indvidual email messages (eg. maildir or mh\n"
449             "archives are perfect). If there are other, non-email files (such as\n"
450             "indexes maintained by other email programs) then notmuch will do its\n"
451             "best to detect those and ignore them.\n\n");
452
453     printf ("Mail storage that uses mbox format, (where one mbox file contains many\n"
454             "messages), will not work with notmuch. If that's how your mail is currently\n"
455             "stored, we recommend you first convert it to maildir format with a utility\n"
456             "such as mb2md. In that case, press Control-C now and run notmuch again\n"
457             "once the conversion is complete.\n\n");
458
459
460     default_path = notmuch_database_default_path ();
461     printf ("Top-level mail directory [%s]: ", default_path);
462     fflush (stdout);
463
464     getline (&mail_directory, &line_size, stdin);
465     chomp_newline (mail_directory);
466
467     printf ("\n");
468
469     if (mail_directory == NULL || strlen (mail_directory) == 0) {
470         if (mail_directory)
471             free (mail_directory);
472         mail_directory = default_path;
473     } else {
474         /* XXX: Instead of telling the user to use an environment
475          * variable here, we should really be writing out a configuration
476          * file and loading that on the next run. */
477         if (strcmp (mail_directory, default_path)) {
478             printf ("Note: Since you are not using the default path, you will want to set\n"
479                     "the NOTMUCH_BASE environment variable to %s so that\n"
480                     "future calls to notmuch commands will know where to find your mail.\n",
481                     mail_directory);
482             printf ("For example, if you are using bash for your shell, add:\n\n");
483             printf ("\texport NOTMUCH_BASE=%s\n\n", mail_directory);
484             printf ("to your ~/.bashrc file.\n\n");
485         }
486         free (default_path);
487     }
488
489     notmuch = notmuch_database_create (mail_directory);
490     if (notmuch == NULL) {
491         fprintf (stderr, "Failed to create new notmuch database at %s\n",
492                  mail_directory);
493         ret = NOTMUCH_STATUS_FILE_ERROR;
494         goto DONE;
495     }
496
497     printf ("OK. Let's take a look at the mail we can find in the directory\n");
498     printf ("%s ...\n", mail_directory);
499
500     count = 0;
501     count_files (mail_directory, &count);
502
503     printf ("Found %d total files. That's not much mail.\n\n", count);
504
505     printf ("Next, we'll inspect the messages and create a database of threads:\n");
506
507     add_files_state.ignore_read_only_directories = FALSE;
508     add_files_state.saw_read_only_directory = FALSE;
509     add_files_state.total_files = count;
510     add_files_state.processed_files = 0;
511     add_files_state.added_messages = 0;
512     add_files_state.callback = NULL;
513     gettimeofday (&add_files_state.tv_start, NULL);
514
515     ret = add_files (notmuch, mail_directory, &add_files_state);
516
517     gettimeofday (&tv_now, NULL);
518     elapsed = tv_elapsed (add_files_state.tv_start,
519                           tv_now);
520     printf ("Processed %d %s in ", add_files_state.processed_files,
521             add_files_state.processed_files == 1 ?
522             "file" : "total files");
523     print_formatted_seconds (elapsed);
524     if (elapsed > 1) {
525         printf (" (%d files/sec.).                 \n",
526                 (int) (add_files_state.processed_files / elapsed));
527     } else {
528         printf (".                    \n");
529     }
530     if (add_files_state.added_messages) {
531         printf ("Added %d %s to the database.\n\n",
532                 add_files_state.added_messages,
533                 add_files_state.added_messages == 1 ?
534                 "message" : "unique messages");
535     }
536
537     printf ("When new mail is delivered to %s in the future,\n"
538             "run \"notmuch new\" to add it to the database.\n\n",
539             mail_directory);
540
541     if (ret) {
542         printf ("Note: At least one error was encountered: %s\n",
543                 notmuch_status_to_string (ret));
544     }
545
546   DONE:
547     if (mail_directory)
548         free (mail_directory);
549     if (notmuch)
550         notmuch_database_close (notmuch);
551
552     return ret;
553 }
554
555 static void
556 tag_inbox_and_unread (notmuch_message_t *message)
557 {
558     notmuch_message_add_tag (message, "inbox");
559     notmuch_message_add_tag (message, "unread");
560 }
561
562 static int
563 new_command (unused (int argc), unused (char *argv[]))
564 {
565     notmuch_database_t *notmuch;
566     const char *mail_directory;
567     add_files_state_t add_files_state;
568     double elapsed;
569     struct timeval tv_now;
570     int ret = 0;
571
572     notmuch = notmuch_database_open (NULL);
573     if (notmuch == NULL) {
574         ret = 1;
575         goto DONE;
576     }
577
578     mail_directory = notmuch_database_get_path (notmuch);
579
580     add_files_state.ignore_read_only_directories = TRUE;
581     add_files_state.saw_read_only_directory = FALSE;
582     add_files_state.total_files = 0;
583     add_files_state.processed_files = 0;
584     add_files_state.added_messages = 0;
585     add_files_state.callback = tag_inbox_and_unread;
586     gettimeofday (&add_files_state.tv_start, NULL);
587
588     ret = add_files (notmuch, mail_directory, &add_files_state);
589
590     gettimeofday (&tv_now, NULL);
591     elapsed = tv_elapsed (add_files_state.tv_start,
592                           tv_now);
593     if (add_files_state.processed_files) {
594         printf ("Processed %d %s in ", add_files_state.processed_files,
595                 add_files_state.processed_files == 1 ?
596                 "file" : "total files");
597         print_formatted_seconds (elapsed);
598         if (elapsed > 1) {
599             printf (" (%d files/sec.).                 \n",
600                     (int) (add_files_state.processed_files / elapsed));
601         } else {
602             printf (".                    \n");
603         }
604     }
605     if (add_files_state.added_messages) {
606         printf ("Added %d new %s to the database (not much, really).\n",
607                 add_files_state.added_messages,
608                 add_files_state.added_messages == 1 ?
609                 "message" : "messages");
610     } else {
611         printf ("No new mail---and that's not much.\n");
612     }
613
614     if (elapsed > 1 && ! add_files_state.saw_read_only_directory) {
615         printf ("\nTip: If you have any sub-directories that are archives (that is,\n"
616                 "they will never receive new mail), marking these directores as\n"
617                 "read-only (chmod u-w /path/to/dir) will make \"notmuch new\"\n"
618                 "much more efficient (it won't even look in those directories).\n");
619     }
620
621     if (ret) {
622         printf ("\nNote: At least one error was encountered: %s\n",
623                 notmuch_status_to_string (ret));
624     }
625
626   DONE:
627     if (notmuch)
628         notmuch_database_close (notmuch);
629
630     return ret;
631 }
632
633 static int
634 search_command (int argc, char *argv[])
635 {
636     void *local = talloc_new (NULL);
637     notmuch_database_t *notmuch = NULL;
638     notmuch_query_t *query;
639     notmuch_thread_results_t *results;
640     notmuch_thread_t *thread;
641     notmuch_tags_t *tags;
642     char *query_str;
643     int i;
644     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
645
646     notmuch = notmuch_database_open (NULL);
647     if (notmuch == NULL) {
648         ret = 1;
649         goto DONE;
650     }
651
652     /* XXX: Should add xtalloc wrappers here and use them. */
653     query_str = talloc_strdup (local, "");
654
655     for (i = 0; i < argc; i++) {
656         if (i != 0)
657             query_str = talloc_asprintf_append (query_str, " ");
658
659         query_str = talloc_asprintf_append (query_str, "%s", argv[i]);
660     }
661
662     query = notmuch_query_create (notmuch, query_str);
663     if (query == NULL) {
664         fprintf (stderr, "Out of memory\n");
665         ret = 1;
666         goto DONE;
667     }
668
669     for (results = notmuch_query_search_threads (query);
670          notmuch_thread_results_has_more (results);
671          notmuch_thread_results_advance (results))
672     {
673         int first = 1;
674
675         thread = notmuch_thread_results_get (results);
676
677         printf ("%s %s",
678                 notmuch_thread_get_thread_id (thread),
679                 notmuch_thread_get_subject (thread));
680
681         printf (" (");
682         for (tags = notmuch_thread_get_tags (thread);
683              notmuch_tags_has_more (tags);
684              notmuch_tags_advance (tags))
685         {
686             if (! first)
687                 printf (" ");
688             printf ("%s", notmuch_tags_get (tags));
689             first = 0;
690         }
691         printf (")\n");
692
693         notmuch_thread_destroy (thread);
694     }
695
696     notmuch_query_destroy (query);
697
698   DONE:
699     if (notmuch)
700         notmuch_database_close (notmuch);
701     talloc_free (local);
702
703     return ret;
704 }
705
706 static int
707 show_command (unused (int argc), unused (char *argv[]))
708 {
709     fprintf (stderr, "Error: show is not implemented yet.\n");
710     return 1;
711 }
712
713 static int
714 dump_command (int argc, char *argv[])
715 {
716     FILE *output = NULL;
717     notmuch_database_t *notmuch = NULL;
718     notmuch_query_t *query;
719     notmuch_message_results_t *results;
720     notmuch_message_t *message;
721     notmuch_tags_t *tags;
722     int ret = 0;
723
724     if (argc) {
725         output = fopen (argv[0], "w");
726         if (output == NULL) {
727             fprintf (stderr, "Error opening %s for writing: %s\n",
728                      argv[0], strerror (errno));
729             ret = 1;
730             goto DONE;
731         }
732     } else {
733         output = stdout;
734     }
735
736     notmuch = notmuch_database_open (NULL);
737     if (notmuch == NULL) {
738         ret = 1;
739         goto DONE;
740     }
741
742     query = notmuch_query_create (notmuch, "");
743     if (query == NULL) {
744         fprintf (stderr, "Out of memory\n");
745         ret = 1;
746         goto DONE;
747     }
748
749     notmuch_query_set_sort (query, NOTMUCH_SORT_MESSAGE_ID);
750
751     for (results = notmuch_query_search_messages (query);
752          notmuch_message_results_has_more (results);
753          notmuch_message_results_advance (results))
754     {
755         int first = 1;
756         message = notmuch_message_results_get (results);
757
758         fprintf (output,
759                  "%s (", notmuch_message_get_message_id (message));
760
761         for (tags = notmuch_message_get_tags (message);
762              notmuch_tags_has_more (tags);
763              notmuch_tags_advance (tags))
764         {
765             if (! first)
766                 fprintf (output, " ");
767
768             fprintf (output, "%s", notmuch_tags_get (tags));
769
770             first = 0;
771         }
772
773         fprintf (output, ")\n");
774
775         notmuch_message_destroy (message);
776     }
777
778     notmuch_query_destroy (query);
779
780   DONE:
781     if (notmuch)
782         notmuch_database_close (notmuch);
783     if (output && output != stdout)
784         fclose (output);
785
786     return ret;
787 }
788
789 static int
790 restore_command (int argc, char *argv[])
791 {
792     FILE *input = NULL;
793     notmuch_database_t *notmuch = NULL;
794     char *line = NULL;
795     size_t line_size;
796     ssize_t line_len;
797     regex_t regex;
798     int rerr;
799     int ret = 0;
800
801     if (argc) {
802         input = fopen (argv[0], "r");
803         if (input == NULL) {
804             fprintf (stderr, "Error opening %s for reading: %s\n",
805                      argv[0], strerror (errno));
806             ret = 1;
807             goto DONE;
808         }
809     } else {
810         printf ("No filename given. Reading dump from stdin.\n");
811         input = stdin;
812     }
813
814     notmuch = notmuch_database_open (NULL);
815     if (notmuch == NULL) {
816         ret = 1;
817         goto DONE;
818     }
819
820     /* Dump output is one line per message. We match a sequence of
821      * non-space characters for the message-id, then one or more
822      * spaces, then a list of space-separated tags as a sequence of
823      * characters within literal '(' and ')'. */
824     xregcomp (&regex,
825               "^([^ ]+) \\(([^)]*)\\)$",
826               REG_EXTENDED);
827
828     while ((line_len = getline (&line, &line_size, input)) != -1) {
829         regmatch_t match[3];
830         char *message_id, *tags, *tag, *next;
831         notmuch_message_t *message;
832         notmuch_status_t status;
833
834         chomp_newline (line);
835
836         rerr = xregexec (&regex, line, 3, match, 0);
837         if (rerr == REG_NOMATCH)
838         {
839             fprintf (stderr, "Warning: Ignoring invalid input line: %s\n",
840                      line);
841             continue;
842         }
843
844         message_id = xstrndup (line + match[1].rm_so,
845                                match[1].rm_eo - match[1].rm_so);
846         tags = xstrndup (line + match[2].rm_so,
847                          match[2].rm_eo - match[2].rm_so);
848
849         if (strlen (tags)) {
850
851             message = notmuch_database_find_message (notmuch, message_id);
852             if (message == NULL) {
853                 fprintf (stderr, "Warning: Cannot apply tags to missing message: %s (",
854                          message_id);
855             }
856
857             next = tags;
858             while (next) {
859                 tag = strsep (&next, " ");
860                 if (*tag == '\0')
861                     continue;
862                 if (message) {
863                     status = notmuch_message_add_tag (message, tag);
864                     if (status) {
865                         fprintf (stderr,
866                                  "Error applying tag %s to message %s:\n",
867                                  tag, message_id);
868                         fprintf (stderr, "%s\n",
869                                  notmuch_status_to_string (status));
870                     }
871                 } else {
872                     fprintf (stderr, "%s%s",
873                              tag == tags ? "" : " ", tag);
874                 }
875             }
876
877             if (message)
878                 notmuch_message_destroy (message);
879             else
880                 fprintf (stderr, ")\n");
881         }
882         free (message_id);
883         free (tags);
884     }
885
886     regfree (&regex);
887
888   DONE:
889     if (line)
890         free (line);
891     if (notmuch)
892         notmuch_database_close (notmuch);
893     if (input && input != stdin)
894         fclose (input);
895
896     return ret;
897 }
898
899 command_t commands[] = {
900     { "setup", setup_command,
901       "Interactively setup notmuch for first use.\n\n"
902       "\t\tInvoking notmuch with no command argument will run setup if\n"
903       "\t\tthe setup command has not previously been completed." },
904     { "new", new_command,
905       "Find and import any new messages.\n\n"
906       "\t\tScans all sub-directories of the database, adding new messages\n"
907       "\t\tthat are found. Each new message will be tagges as both\n"
908       "\t\t\"inbox\" and \"unread\".\n"
909       "\n"
910       "\t\tNote: \"notmuch new\" will skip any read-only directories,\n"
911       "\t\tso you can use that to mark tdirectories that will not\n"
912       "\t\treceive any new mail (and make \"notmuch new\" faster)." },
913     { "search", search_command,
914       "<search-term> [...]\n\n"
915       "\t\tSearch for threads matching the given search terms.\n"
916       "\t\tOnce we actually implement search we'll document the\n"
917       "\t\tsyntax here." },
918     { "show", show_command,
919       "<thread-id>\n\n"
920       "\t\tShow the thread with the given thread ID (see 'search')." },
921     { "dump", dump_command,
922       "[<filename>]\n\n"
923       "\t\tCreate a plain-text dump of the tags for each message\n"
924       "\t\twriting to the given filename, if any, or to stdout.\n"
925       "\t\tThese tags are the only data in the notmuch database\n"
926       "\t\tthat can't be recreated from the messages themselves.\n"
927       "\t\tThe output of notmuch dump is therefore the only\n"
928       "\t\tcritical thing to backup (and much more friendly to\n"
929       "\t\tincremental backup than the native database files." },
930     { "restore", restore_command,
931       "<filename>\n\n"
932       "\t\tRestore the tags from the given dump file (see 'dump')." }
933 };
934
935 static void
936 usage (void)
937 {
938     command_t *command;
939     unsigned int i;
940
941     fprintf (stderr, "Usage: notmuch <command> [args...]\n");
942     fprintf (stderr, "\n");
943     fprintf (stderr, "Where <command> and [args...] are as follows:\n");
944     fprintf (stderr, "\n");
945
946     for (i = 0; i < ARRAY_SIZE (commands); i++) {
947         command = &commands[i];
948
949         fprintf (stderr, "\t%s\t%s\n\n", command->name, command->usage);
950     }
951 }
952     
953 int
954 main (int argc, char *argv[])
955 {
956     command_t *command;
957     unsigned int i;
958
959     if (argc == 1)
960         return setup_command (0, NULL);
961
962     for (i = 0; i < ARRAY_SIZE (commands); i++) {
963         command = &commands[i];
964
965         if (strcmp (argv[1], command->name) == 0)
966             return (command->function) (argc - 2, &argv[2]);
967     }
968
969     /* Don't complain about "help" being an unknown command when we're
970        about to provide exactly what's wanted anyway. */
971     if (strcmp (argv[1], "help") == 0 ||
972         strcmp (argv[1], "--help") == 0)
973     {
974         fprintf (stderr, "The notmuch mail system.\n\n");
975         usage ();
976         return 0;
977     } else {
978         fprintf (stderr, "Error: Unknown command '%s'\n\n", argv[1]);
979         usage ();
980         return 1;
981     }
982 }