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  * Copyright © 2009 Keith Packard
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see https://www.gnu.org/licenses/ .
  18  *
  19  * Authors: Carl Worth <cworth@cworth.org>
  20  *          Keith Packard <keithp@keithp.com>
  21  */
  22
  23 #include "notmuch-client.h"
  24
  25 /*
  26  * Notmuch subcommand hook.
  27  *
  28  * The return value will be used as notmuch exit status code,
  29  * preferably EXIT_SUCCESS or EXIT_FAILURE.
  30  *
  31  * Each subcommand should be passed either a config object, or an open
  32  * database
  33  */
  34 typedef int (*command_function_t) (notmuch_database_t *notmuch, int argc, char *argv[]);
  35
  36 typedef struct command {
  37     const char *name;
  38     command_function_t function;
  39     notmuch_command_mode_t mode;
  40     const char *summary;
  41 } command_t;
  42
  43 static int
  44 notmuch_help_command (notmuch_database_t *notmuch, int argc, char *argv[]);
  45
  46 static int
  47 notmuch_command (notmuch_database_t *notmuch, int argc, char *argv[]);
  48
  49 static int
  50 _help_for (const char *topic);
  51
  52 static void
  53 notmuch_exit_if_unmatched_db_uuid (notmuch_database_t *notmuch);
  54
  55 static bool print_version = false, print_help = false;
  56 static const char *notmuch_requested_db_uuid = NULL;
  57 static int query_syntax = NOTMUCH_QUERY_SYNTAX_XAPIAN;
  58
  59 const notmuch_opt_desc_t notmuch_shared_options [] = {
  60     { .opt_bool = &print_version, .name = "version" },
  61     { .opt_bool = &print_help, .name = "help" },
  62     { .opt_string = &notmuch_requested_db_uuid, .name = "uuid" },
  63     { .opt_keyword = &query_syntax, .name = "query", .keywords =
  64           (notmuch_keyword_t []){ { "infix", NOTMUCH_QUERY_SYNTAX_XAPIAN },
  65                                   { "sexp", NOTMUCH_QUERY_SYNTAX_SEXP },
  66                                   { 0, 0 } } },
  67
  68     { }
  69 };
  70
  71 notmuch_query_syntax_t
  72 shared_option_query_syntax ()
  73 {
  74     return query_syntax;
  75 }
  76
  77 /* any subcommand wanting to support these options should call
  78  * inherit notmuch_shared_options and call
  79  * notmuch_process_shared_options (notmuch, subcommand_name);
  80  * with notmuch = an open database, or NULL.
  81  */
  82 void
  83 notmuch_process_shared_options (notmuch_database_t *notmuch, const char *subcommand_name)
  84 {
  85     if (print_version) {
  86         printf ("notmuch " STRINGIFY (NOTMUCH_VERSION) "\n");
  87         exit (EXIT_SUCCESS);
  88     }
  89
  90     if (print_help) {
  91         int ret = _help_for (subcommand_name);
  92         exit (ret);
  93     }
  94
  95     if (notmuch) {
  96         notmuch_exit_if_unmatched_db_uuid (notmuch);
  97     } else {
  98         if (notmuch_requested_db_uuid)
  99             fprintf (stderr, "Warning: ignoring --uuid=%s\n",
 100                      notmuch_requested_db_uuid);
 101     }
 102 }
 103
 104 /* This is suitable for subcommands that do not actually open the
 105  * database.
 106  */
 107 int
 108 notmuch_minimal_options (const char *subcommand_name,
 109                          int argc, char **argv)
 110 {
 111     int opt_index;
 112
 113     notmuch_opt_desc_t options[] = {
 114         { .opt_inherit = notmuch_shared_options },
 115         { }
 116     };
 117
 118     opt_index = parse_arguments (argc, argv, options, 1);
 119
 120     if (opt_index < 0)
 121         return -1;
 122
 123     /* We can't use argv here as it is sometimes NULL */
 124     notmuch_process_shared_options (NULL, subcommand_name);
 125     return opt_index;
 126 }
 127
 128
 129 struct _notmuch_client_indexing_cli_choices indexing_cli_choices = { };
 130 const notmuch_opt_desc_t notmuch_shared_indexing_options [] = {
 131     { .opt_keyword = &indexing_cli_choices.decrypt_policy,
 132       .present = &indexing_cli_choices.decrypt_policy_set, .keywords =
 133           (notmuch_keyword_t []){ { "false", NOTMUCH_DECRYPT_FALSE },
 134                                   { "true", NOTMUCH_DECRYPT_TRUE },
 135                                   { "auto", NOTMUCH_DECRYPT_AUTO },
 136                                   { "nostash", NOTMUCH_DECRYPT_NOSTASH },
 137                                   { 0, 0 } },
 138       .name = "decrypt" },
 139     { }
 140 };
 141
 142
 143 notmuch_status_t
 144 notmuch_process_shared_indexing_options (notmuch_indexopts_t *opts)
 145 {
 146     if (opts == NULL)
 147         return NOTMUCH_STATUS_NULL_POINTER;
 148
 149     if (indexing_cli_choices.decrypt_policy_set) {
 150         notmuch_status_t status;
 151         status = notmuch_indexopts_set_decrypt_policy (opts,
 152                                                        indexing_cli_choices.decrypt_policy);
 153         if (status != NOTMUCH_STATUS_SUCCESS) {
 154             fprintf (stderr, "Error: Failed to set index decryption policy to %d. (%s)\n",
 155                      indexing_cli_choices.decrypt_policy, notmuch_status_to_string (status));
 156             return status;
 157         }
 158     }
 159     return NOTMUCH_STATUS_SUCCESS;
 160 }
 161
 162
 163 static const command_t commands[] = {
 164     { NULL, notmuch_command, NOTMUCH_COMMAND_CONFIG_CREATE | NOTMUCH_COMMAND_CONFIG_LOAD,
 165       "Notmuch main command." },
 166     { "setup", notmuch_setup_command, NOTMUCH_COMMAND_CONFIG_CREATE | NOTMUCH_COMMAND_CONFIG_LOAD,
 167       "Interactively set up notmuch for first use." },
 168     { "new", notmuch_new_command,
 169       NOTMUCH_COMMAND_DATABASE_EARLY | NOTMUCH_COMMAND_DATABASE_WRITE |
 170       NOTMUCH_COMMAND_DATABASE_CREATE,
 171       "Find and import new messages to the notmuch database." },
 172     { "insert", notmuch_insert_command, NOTMUCH_COMMAND_DATABASE_EARLY |
 173       NOTMUCH_COMMAND_DATABASE_WRITE,
 174       "Add a new message into the maildir and notmuch database." },
 175     { "search", notmuch_search_command, NOTMUCH_COMMAND_DATABASE_EARLY,
 176       "Search for messages matching the given search terms." },
 177     { "address", notmuch_address_command, NOTMUCH_COMMAND_DATABASE_EARLY,
 178       "Get addresses from messages matching the given search terms." },
 179     { "show", notmuch_show_command, NOTMUCH_COMMAND_DATABASE_EARLY,
 180       "Show all messages matching the search terms." },
 181     { "count", notmuch_count_command, NOTMUCH_COMMAND_DATABASE_EARLY,
 182       "Count messages matching the search terms." },
 183     { "reply", notmuch_reply_command, NOTMUCH_COMMAND_DATABASE_EARLY,
 184       "Construct a reply template for a set of messages." },
 185     { "tag", notmuch_tag_command, NOTMUCH_COMMAND_DATABASE_EARLY | NOTMUCH_COMMAND_DATABASE_WRITE,
 186       "Add/remove tags for all messages matching the search terms." },
 187     { "dump", notmuch_dump_command, NOTMUCH_COMMAND_DATABASE_EARLY | NOTMUCH_COMMAND_DATABASE_WRITE,
 188       "Create a plain-text dump of the tags for each message." },
 189     { "restore", notmuch_restore_command, NOTMUCH_COMMAND_DATABASE_EARLY |
 190       NOTMUCH_COMMAND_DATABASE_WRITE,
 191       "Restore the tags from the given dump file (see 'dump')." },
 192     { "compact", notmuch_compact_command, NOTMUCH_COMMAND_DATABASE_EARLY |
 193       NOTMUCH_COMMAND_DATABASE_WRITE,
 194       "Compact the notmuch database." },
 195     { "reindex", notmuch_reindex_command, NOTMUCH_COMMAND_DATABASE_EARLY |
 196       NOTMUCH_COMMAND_DATABASE_WRITE,
 197       "Re-index all messages matching the search terms." },
 198     { "config", notmuch_config_command, NOTMUCH_COMMAND_CONFIG_LOAD,
 199       "Get or set settings in the notmuch configuration file." },
 200 #if WITH_EMACS
 201     { "emacs-mua", NULL, 0,
 202       "send mail with notmuch and emacs." },
 203 #endif
 204     { "help", notmuch_help_command, NOTMUCH_COMMAND_CONFIG_CREATE, /* create but don't save config */
 205       "This message, or more detailed help for the named command." }
 206 };
 207
 208 typedef struct help_topic {
 209     const char *name;
 210     const char *summary;
 211 } help_topic_t;
 212
 213 static const help_topic_t help_topics[] = {
 214     { "hooks",
 215       "Hooks that will be run before or after certain commands." },
 216     { "properties",
 217       "Message property conventions and documentation." },
 218     { "search-terms",
 219       "Common infix search term syntax." },
 220     { "sexp-queries",
 221       "Common s-expression search term syntax." },
 222 };
 223
 224 static const command_t *
 225 find_command (const char *name)
 226 {
 227     size_t i;
 228
 229     for (i = 0; i < ARRAY_SIZE (commands); i++)
 230         if ((! name && ! commands[i].name) ||
 231             (name && commands[i].name && strcmp (name, commands[i].name) == 0))
 232             return &commands[i];
 233
 234     return NULL;
 235 }
 236
 237 int notmuch_format_version;
 238
 239 static void
 240 usage (FILE *out)
 241 {
 242     const command_t *command;
 243     const help_topic_t *topic;
 244     unsigned int i;
 245
 246     fprintf (out,
 247              "Usage: notmuch --help\n"
 248              "       notmuch --version\n"
 249              "       notmuch <command> [args...]\n");
 250     fprintf (out, "\n");
 251     fprintf (out, "The available commands are as follows:\n");
 252     fprintf (out, "\n");
 253
 254     for (i = 0; i < ARRAY_SIZE (commands); i++) {
 255         command = &commands[i];
 256
 257         if (command->name)
 258             fprintf (out, "  %-12s  %s\n", command->name, command->summary);
 259     }
 260
 261     fprintf (out, "\n");
 262     fprintf (out, "Additional help topics are as follows:\n");
 263     fprintf (out, "\n");
 264
 265     for (i = 0; i < ARRAY_SIZE (help_topics); i++) {
 266         topic = &help_topics[i];
 267         fprintf (out, "  %-12s  %s\n", topic->name, topic->summary);
 268     }
 269
 270     fprintf (out, "\n");
 271     fprintf (out,
 272              "Use \"notmuch help <command or topic>\" for more details "
 273              "on each command or topic.\n\n");
 274 }
 275
 276 void
 277 notmuch_exit_if_unsupported_format (void)
 278 {
 279     if (notmuch_format_version > NOTMUCH_FORMAT_CUR) {
 280         fprintf (stderr,
 281                  "\
 282 A caller requested output format version %d, but the installed notmuch\n\
 283 CLI only supports up to format version %d.  You may need to upgrade your\n\
 284 notmuch CLI.\n",
 285                  notmuch_format_version, NOTMUCH_FORMAT_CUR);
 286         exit (NOTMUCH_EXIT_FORMAT_TOO_NEW);
 287     } else if (notmuch_format_version < NOTMUCH_FORMAT_MIN) {
 288         fprintf (stderr,
 289                  "\
 290 A caller requested output format version %d, which is no longer supported\n\
 291 by the notmuch CLI (it requires at least version %d).  You may need to\n\
 292 upgrade your notmuch front-end.\n",
 293                  notmuch_format_version, NOTMUCH_FORMAT_MIN);
 294         exit (NOTMUCH_EXIT_FORMAT_TOO_OLD);
 295     } else if (notmuch_format_version < NOTMUCH_FORMAT_MIN_ACTIVE) {
 296         /* Warn about old version requests so compatibility issues are
 297          * less likely when we drop support for a deprecated format
 298          * versions. */
 299         fprintf (stderr,
 300                  "\
 301 A caller requested deprecated output format version %d, which may not\n\
 302 be supported in the future.\n", notmuch_format_version);
 303     }
 304 }
 305
 306 static void
 307 notmuch_exit_if_unmatched_db_uuid (notmuch_database_t *notmuch)
 308 {
 309     const char *uuid = NULL;
 310
 311     if (! notmuch_requested_db_uuid)
 312         return;
 313     IGNORE_RESULT (notmuch_database_get_revision (notmuch, &uuid));
 314
 315     if (strcmp (notmuch_requested_db_uuid, uuid) != 0) {
 316         fprintf (stderr, "Error: requested database revision %s does not match %s\n",
 317                  notmuch_requested_db_uuid, uuid);
 318         exit (1);
 319     }
 320 }
 321
 322 static void
 323 exec_man (const char *page)
 324 {
 325     if (execlp ("man", "man", page, (char *) NULL)) {
 326         perror ("exec man");
 327         exit (1);
 328     }
 329 }
 330
 331 static int
 332 _help_for (const char *topic_name)
 333 {
 334     char *page;
 335
 336     if (! topic_name) {
 337         printf ("The notmuch mail system.\n\n");
 338         usage (stdout);
 339         return EXIT_SUCCESS;
 340     }
 341
 342     if (strcmp (topic_name, "help") == 0) {
 343         printf ("The notmuch help system.\n\n"
 344                 "\tNotmuch uses the man command to display help. In case\n"
 345                 "\tof difficulties check that MANPATH includes the pages\n"
 346                 "\tinstalled by notmuch.\n\n"
 347                 "\tTry \"notmuch help\" for a list of topics.\n");
 348         return EXIT_SUCCESS;
 349     }
 350
 351     page = talloc_asprintf (NULL, "notmuch-%s", topic_name);
 352     exec_man (page);
 353
 354     return EXIT_FAILURE;
 355 }
 356
 357 static int
 358 notmuch_help_command (unused(notmuch_database_t *notmuch), int argc, char *argv[])
 359 {
 360     int opt_index;
 361
 362     opt_index = notmuch_minimal_options ("help", argc, argv);
 363     if (opt_index < 0)
 364         return EXIT_FAILURE;
 365
 366     /* skip at least subcommand argument */
 367     argc -= opt_index;
 368     argv += opt_index;
 369
 370     if (argc == 0) {
 371         return _help_for (NULL);
 372     }
 373
 374     return _help_for (argv[0]);
 375 }
 376
 377 /* Handle the case of "notmuch" being invoked with no command
 378  * argument. For now we just call notmuch_setup_command, but we plan
 379  * to be more clever about this in the future.
 380  */
 381 static int
 382 notmuch_command (notmuch_database_t *notmuch,
 383                  unused(int argc), unused(char **argv))
 384 {
 385
 386     const char *config_path;
 387
 388     /* If the user has not created a configuration file, then run
 389      * notmuch_setup_command which will give a nice welcome message,
 390      * and interactively guide the user through the configuration. */
 391     config_path = notmuch_config_path (notmuch);
 392     if (access (config_path, R_OK | F_OK) == -1) {
 393         if (errno != ENOENT) {
 394             fprintf (stderr, "Error: %s config file access failed: %s\n", config_path,
 395                      strerror (errno));
 396             return EXIT_FAILURE;
 397         } else {
 398             return notmuch_setup_command (notmuch, 0, NULL);
 399         }
 400     }
 401
 402     printf ("Notmuch is configured and appears to have a database. Excellent!\n\n"
 403             "At this point you can start exploring the functionality of notmuch by\n"
 404             "using commands such as:\n\n"
 405             "\tnotmuch search tag:inbox\n\n"
 406             "\tnotmuch search to:\"%s\"\n\n"
 407             "\tnotmuch search from:\"%s\"\n\n"
 408             "\tnotmuch search subject:\"my favorite things\"\n\n"
 409             "See \"notmuch help search\" for more details.\n\n"
 410             "You can also use \"notmuch show\" with any of the thread IDs resulting\n"
 411             "from a search. Finally, you may want to explore using a more sophisticated\n"
 412             "interface to notmuch such as the emacs interface implemented in notmuch.el\n"
 413             "or any other interface described at https://notmuchmail.org\n\n"
 414             "And don't forget to run \"notmuch new\" whenever new mail arrives.\n\n"
 415             "Have fun, and may your inbox never have much mail.\n\n",
 416             notmuch_config_get (notmuch, NOTMUCH_CONFIG_USER_NAME),
 417             notmuch_config_get (notmuch, NOTMUCH_CONFIG_PRIMARY_EMAIL));
 418
 419     return EXIT_SUCCESS;
 420 }
 421
 422 /*
 423  * Try to run subcommand in argv[0] as notmuch- prefixed external
 424  * command. argv must be NULL terminated (argv passed to main always
 425  * is).
 426  *
 427  * Does not return if the external command is found and
 428  * executed. Return true if external command is not found. Return
 429  * false on errors.
 430  */
 431 static bool
 432 try_external_command (const char *config_file_name, char *argv[])
 433 {
 434     char *old_argv0 = argv[0];
 435     bool ret = true;
 436
 437     if (config_file_name) {
 438         if (setenv ("NOTMUCH_CONFIG", config_file_name, 1)) {
 439             perror ("setenv");
 440             exit (1);
 441         }
 442     }
 443
 444     argv[0] = talloc_asprintf (NULL, "notmuch-%s", old_argv0);
 445
 446     /*
 447      * This will only return on errors. Not finding an external
 448      * command (ENOENT) is not an error from our perspective.
 449      */
 450     execvp (argv[0], argv);
 451     if (errno != ENOENT) {
 452         fprintf (stderr, "Error: Running external command '%s' failed: %s\n",
 453                  argv[0], strerror (errno));
 454         ret = false;
 455     }
 456
 457     talloc_free (argv[0]);
 458     argv[0] = old_argv0;
 459
 460     return ret;
 461 }
 462
 463 int
 464 main (int argc, char *argv[])
 465 {
 466     void *local;
 467     char *talloc_report;
 468     const char *command_name = NULL;
 469     const command_t *command;
 470     const char *config_file_name = NULL;
 471     notmuch_database_t *notmuch = NULL;
 472     int opt_index;
 473     int ret = EXIT_SUCCESS;
 474
 475     notmuch_opt_desc_t options[] = {
 476         { .opt_string = &config_file_name, .name = "config", .allow_empty = TRUE },
 477         { .opt_inherit = notmuch_shared_options },
 478         { }
 479     };
 480
 481     notmuch_client_init ();
 482
 483     local = talloc_new (NULL);
 484
 485     /* Globally default to the current output format version. */
 486     notmuch_format_version = NOTMUCH_FORMAT_CUR;
 487
 488     opt_index = parse_arguments (argc, argv, options, 1);
 489     if (opt_index < 0) {
 490         ret = EXIT_FAILURE;
 491         goto DONE;
 492     }
 493
 494     if (opt_index < argc)
 495         command_name = argv[opt_index];
 496
 497     notmuch_process_shared_options (NULL, command_name);
 498
 499     command = find_command (command_name);
 500     /* if command->function is NULL, try external command */
 501     if (! command || ! command->function) {
 502         /* This won't return if the external command is found. */
 503         if (try_external_command (config_file_name, argv + opt_index))
 504             fprintf (stderr, "Error: Unknown command '%s' (see \"notmuch help\")\n",
 505                      command_name);
 506         ret = EXIT_FAILURE;
 507         goto DONE;
 508     }
 509
 510     if (command->mode & NOTMUCH_COMMAND_DATABASE_EARLY) {
 511         char *status_string = NULL;
 512         notmuch_database_mode_t mode;
 513         notmuch_status_t status;
 514
 515         if (command->mode & NOTMUCH_COMMAND_DATABASE_WRITE ||
 516             command->mode & NOTMUCH_COMMAND_DATABASE_CREATE)
 517             mode = NOTMUCH_DATABASE_MODE_READ_WRITE;
 518         else
 519             mode = NOTMUCH_DATABASE_MODE_READ_ONLY;
 520
 521         if (command->mode & NOTMUCH_COMMAND_DATABASE_CREATE) {
 522             status = notmuch_database_create_with_config (NULL,
 523                                                           config_file_name,
 524                                                           NULL,
 525                                                           &notmuch,
 526                                                           &status_string);
 527             if (status && status != NOTMUCH_STATUS_DATABASE_EXISTS) {
 528                 if (status_string) {
 529                     fputs (status_string, stderr);
 530                     free (status_string);
 531                 }
 532
 533                 if (status == NOTMUCH_STATUS_NO_CONFIG)
 534                     fputs ("Try running 'notmuch setup' to create a configuration.\n", stderr);
 535
 536                 return EXIT_FAILURE;
 537             }
 538         }
 539
 540         if (notmuch == NULL) {
 541             status = notmuch_database_open_with_config (NULL,
 542                                                         mode,
 543                                                         config_file_name,
 544                                                         NULL,
 545                                                         &notmuch,
 546                                                         &status_string);
 547             if (status) {
 548                 if (status_string) {
 549                     fputs (status_string, stderr);
 550                     free (status_string);
 551                 }
 552
 553                 return EXIT_FAILURE;
 554             }
 555         }
 556     }
 557
 558     if (command->mode & NOTMUCH_COMMAND_CONFIG_LOAD) {
 559         char *status_string = NULL;
 560         notmuch_status_t status;
 561         status = notmuch_database_load_config (NULL,
 562                                                config_file_name,
 563                                                NULL,
 564                                                &notmuch,
 565                                                &status_string);
 566         switch (status) {
 567         case NOTMUCH_STATUS_NO_CONFIG:
 568             if (! (command->mode & NOTMUCH_COMMAND_CONFIG_CREATE)) {
 569                 fputs ("Try running 'notmuch setup' to create a configuration.\n", stderr);
 570                 goto DONE;
 571             }
 572             break;
 573         case NOTMUCH_STATUS_NO_DATABASE:
 574             if (! command_name) {
 575                 printf ("Notmuch is configured, but no database was found.\n");
 576                 printf ("You probably want to run \"notmuch new\" now to create a database.\n\n"
 577                         "Note that the first run of \"notmuch new\" can take a very long time\n"
 578                         "and that the resulting database will use roughly the same amount of\n"
 579                         "storage space as the email being indexed.\n\n");
 580                 status = NOTMUCH_STATUS_SUCCESS;
 581                 goto DONE;
 582             }
 583             break;
 584         case NOTMUCH_STATUS_SUCCESS:
 585             break;
 586         default:
 587             goto DONE;
 588         }
 589
 590     }
 591
 592     ret = (command->function)(notmuch, argc - opt_index, argv + opt_index);
 593
 594   DONE:
 595     talloc_report = getenv ("NOTMUCH_TALLOC_REPORT");
 596     if (talloc_report && strcmp (talloc_report, "") != 0) {
 597         /* this relies on the previous call to
 598          * talloc_enable_null_tracking
 599          */
 600
 601         FILE *report = fopen (talloc_report, "a");
 602         if (report) {
 603             talloc_report_full (NULL, report);
 604         } else {
 605             ret = 1;
 606             fprintf (stderr, "ERROR: unable to write talloc log. ");
 607             perror (talloc_report);
 608         }
 609     }
 610
 611     talloc_free (local);
 612
 613     return ret;
 614 }