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