git.notmuchmail.org Git - notmuch/blob - notmuch-config.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 #include "notmuch-client.h"
  22
  23 #include <pwd.h>
  24 #include <netdb.h>
  25 #include <assert.h>
  26
  27 static const char toplevel_config_comment[] =
  28     " .notmuch-config - Configuration file for the notmuch mail system\n"
  29     "\n"
  30     " For more information about notmuch, see http://notmuchmail.org";
  31
  32 static const char database_config_comment[] =
  33     " Database configuration\n"
  34     "\n"
  35     " The only value supported here is 'path' which should be the top-level\n"
  36     " directory where your mail currently exists and to where mail will be\n"
  37     " delivered in the future. Files should be individual email messages.\n"
  38     " Notmuch will store its database within a sub-directory of the path\n"
  39     " configured here named \".notmuch\".\n";
  40
  41 static const char new_config_comment[] =
  42     " Configuration for \"notmuch new\"\n"
  43     "\n"
  44     " The following options are supported here:\n"
  45     "\n"
  46     "\ttags     A list (separated by ';') of the tags that will be\n"
  47     "\t added to all messages incorporated by \"notmuch new\".\n"
  48     "\n"
  49     "\tignore   A list (separated by ';') of file and directory names\n"
  50     "\t that will not be searched for messages by \"notmuch new\".\n"
  51     "\n"
  52     "\t NOTE: *Every* file/directory that goes by one of those\n"
  53     "\t names will be ignored, independent of its depth/location\n"
  54     "\t in the mail store.\n";
  55
  56 static const char user_config_comment[] =
  57     " User configuration\n"
  58     "\n"
  59     " Here is where you can let notmuch know how you would like to be\n"
  60     " addressed. Valid settings are\n"
  61     "\n"
  62     "\tname             Your full name.\n"
  63     "\tprimary_email    Your primary email address.\n"
  64     "\tother_email      A list (separated by ';') of other email addresses\n"
  65     "\t         at which you receive email.\n"
  66     "\n"
  67     " Notmuch will use the various email addresses configured here when\n"
  68     " formatting replies. It will avoid including your own addresses in the\n"
  69     " recipient list of replies, and will set the From address based on the\n"
  70     " address to which the original email was addressed.\n";
  71
  72 static const char maildir_config_comment[] =
  73     " Maildir compatibility configuration\n"
  74     "\n"
  75     " The following option is supported here:\n"
  76     "\n"
  77     "\tsynchronize_flags      Valid values are true and false.\n"
  78     "\n"
  79     "\tIf true, then the following maildir flags (in message filenames)\n"
  80     "\twill be synchronized with the corresponding notmuch tags:\n"
  81     "\n"
  82     "\t\tFlag   Tag\n"
  83     "\t\t----   -------\n"
  84     "\t\tD      draft\n"
  85     "\t\tF      flagged\n"
  86     "\t\tP      passed\n"
  87     "\t\tR      replied\n"
  88     "\t\tS      unread (added when 'S' flag is not present)\n"
  89     "\n"
  90     "\tThe \"notmuch new\" command will notice flag changes in filenames\n"
  91     "\tand update tags, while the \"notmuch tag\" and \"notmuch restore\"\n"
  92     "\tcommands will notice tag changes and update flags in filenames\n";
  93
  94 static const char search_config_comment[] =
  95     " Search configuration\n"
  96     "\n"
  97     " The following option is supported here:\n"
  98     "\n"
  99     "\texclude_tags\n"
 100     "\t\tA ;-separated list of tags that will be excluded from\n"
 101     "\t\tsearch results by default.  Using an excluded tag in a\n"
 102     "\t\tquery will override that exclusion.\n";
 103
 104 struct _notmuch_config {
 105     char *filename;
 106     GKeyFile *key_file;
 107     notmuch_bool_t is_new;
 108
 109     char *database_path;
 110     char *user_name;
 111     char *user_primary_email;
 112     const char **user_other_email;
 113     size_t user_other_email_length;
 114     const char **new_tags;
 115     size_t new_tags_length;
 116     const char **new_ignore;
 117     size_t new_ignore_length;
 118     notmuch_bool_t maildir_synchronize_flags;
 119     const char **search_exclude_tags;
 120     size_t search_exclude_tags_length;
 121 };
 122
 123 static int
 124 notmuch_config_destructor (notmuch_config_t *config)
 125 {
 126     if (config->key_file)
 127         g_key_file_free (config->key_file);
 128
 129     return 0;
 130 }
 131
 132 static char *
 133 get_name_from_passwd_file (void *ctx)
 134 {
 135     long pw_buf_size;
 136     char *pw_buf;
 137     struct passwd passwd, *ignored;
 138     char *name;
 139     int e;
 140
 141     pw_buf_size = sysconf(_SC_GETPW_R_SIZE_MAX);
 142     if (pw_buf_size == -1) pw_buf_size = 64;
 143     pw_buf = talloc_size (ctx, pw_buf_size);
 144
 145     while ((e = getpwuid_r (getuid (), &passwd, pw_buf,
 146                             pw_buf_size, &ignored)) == ERANGE) {
 147         pw_buf_size = pw_buf_size * 2;
 148         pw_buf = talloc_zero_size(ctx, pw_buf_size);
 149     }
 150
 151     if (e == 0) {
 152         char *comma = strchr (passwd.pw_gecos, ',');
 153         if (comma)
 154             name = talloc_strndup (ctx, passwd.pw_gecos,
 155                                    comma - passwd.pw_gecos);
 156         else
 157             name = talloc_strdup (ctx, passwd.pw_gecos);
 158     } else {
 159         name = talloc_strdup (ctx, "");
 160     }
 161
 162     talloc_free (pw_buf);
 163
 164     return name;
 165 }
 166
 167 static char *
 168 get_username_from_passwd_file (void *ctx)
 169 {
 170     long pw_buf_size;
 171     char *pw_buf;
 172     struct passwd passwd, *ignored;
 173     char *name;
 174     int e;
 175
 176     pw_buf_size = sysconf(_SC_GETPW_R_SIZE_MAX);
 177     if (pw_buf_size == -1) pw_buf_size = 64;
 178     pw_buf = talloc_zero_size (ctx, pw_buf_size);
 179
 180     while ((e = getpwuid_r (getuid (), &passwd, pw_buf,
 181                             pw_buf_size, &ignored)) == ERANGE) {
 182         pw_buf_size = pw_buf_size * 2;
 183         pw_buf = talloc_zero_size(ctx, pw_buf_size);
 184     }
 185
 186     if (e == 0)
 187         name = talloc_strdup (ctx, passwd.pw_name);
 188     else
 189         name = talloc_strdup (ctx, "");
 190
 191     talloc_free (pw_buf);
 192
 193     return name;
 194 }
 195
 196 /* Open the named notmuch configuration file. If the filename is NULL,
 197  * the value of the environment variable $NOTMUCH_CONFIG will be used.
 198  * If $NOTMUCH_CONFIG is unset, the default configuration file
 199  * ($HOME/.notmuch-config) will be used.
 200  *
 201  * If any error occurs, (out of memory, or a permission-denied error,
 202  * etc.), this function will print a message to stderr and return
 203  * NULL.
 204  *
 205  * FILE NOT FOUND: When the specified configuration file (whether from
 206  * 'filename' or the $NOTMUCH_CONFIG environment variable) does not
 207  * exist, the behavior of this function depends on the 'is_new_ret'
 208  * variable.
 209  *
 210  *      If is_new_ret is NULL, then a "file not found" message will be
 211  *      printed to stderr and NULL will be returned.
 212
 213  *      If is_new_ret is non-NULL then a default configuration will be
 214  *      returned and *is_new_ret will be set to 1 on return so that
 215  *      the caller can recognize this case.
 216  *
 217  *      These default configuration settings are determined as
 218  *      follows:
 219  *
 220  *              database_path:          $HOME/mail
 221  *
 222  *              user_name:              From /etc/passwd
 223  *
 224  *              user_primary_mail:      $EMAIL variable if set, otherwise
 225  *                                      constructed from the username and
 226  *                                      hostname of the current machine.
 227  *
 228  *              user_other_email:       Not set.
 229  *
 230  *      The default configuration also contains comments to guide the
 231  *      user in editing the file directly.
 232  */
 233 notmuch_config_t *
 234 notmuch_config_open (void *ctx,
 235                      const char *filename,
 236                      notmuch_bool_t create_new)
 237 {
 238     GError *error = NULL;
 239     size_t tmp;
 240     char *notmuch_config_env = NULL;
 241     int file_had_database_group;
 242     int file_had_new_group;
 243     int file_had_user_group;
 244     int file_had_maildir_group;
 245     int file_had_search_group;
 246
 247     notmuch_config_t *config = talloc (ctx, notmuch_config_t);
 248     if (config == NULL) {
 249         fprintf (stderr, "Out of memory.\n");
 250         return NULL;
 251     }
 252
 253     talloc_set_destructor (config, notmuch_config_destructor);
 254
 255     if (filename) {
 256         config->filename = talloc_strdup (config, filename);
 257     } else if ((notmuch_config_env = getenv ("NOTMUCH_CONFIG"))) {
 258         config->filename = talloc_strdup (config, notmuch_config_env);
 259     } else {
 260         config->filename = talloc_asprintf (config, "%s/.notmuch-config",
 261                                             getenv ("HOME"));
 262     }
 263
 264     config->key_file = g_key_file_new ();
 265
 266     config->is_new = FALSE;
 267     config->database_path = NULL;
 268     config->user_name = NULL;
 269     config->user_primary_email = NULL;
 270     config->user_other_email = NULL;
 271     config->user_other_email_length = 0;
 272     config->new_tags = NULL;
 273     config->new_tags_length = 0;
 274     config->new_ignore = NULL;
 275     config->new_ignore_length = 0;
 276     config->maildir_synchronize_flags = TRUE;
 277     config->search_exclude_tags = NULL;
 278     config->search_exclude_tags_length = 0;
 279
 280     if (! g_key_file_load_from_file (config->key_file,
 281                                      config->filename,
 282                                      G_KEY_FILE_KEEP_COMMENTS,
 283                                      &error))
 284     {
 285         /* If create_new is true, then the caller is prepared for a
 286          * default configuration file in the case of FILE NOT
 287          * FOUND. Otherwise, any read failure is an error.
 288          */
 289         if (create_new &&
 290             error->domain == G_FILE_ERROR &&
 291             error->code == G_FILE_ERROR_NOENT)
 292         {
 293             g_error_free (error);
 294             config->is_new = TRUE;
 295         }
 296         else
 297         {
 298             fprintf (stderr, "Error reading configuration file %s: %s\n",
 299                      config->filename, error->message);
 300             talloc_free (config);
 301             g_error_free (error);
 302             return NULL;
 303         }
 304     }
 305
 306     /* Whenever we know of configuration sections that don't appear in
 307      * the configuration file, we add some comments to help the user
 308      * understand what can be done.
 309      *
 310      * It would be convenient to just add those comments now, but
 311      * apparently g_key_file will clear any comments when keys are
 312      * added later that create the groups. So we have to check for the
 313      * groups now, but add the comments only after setting all of our
 314      * values.
 315      */
 316     file_had_database_group = g_key_file_has_group (config->key_file,
 317                                                     "database");
 318     file_had_new_group = g_key_file_has_group (config->key_file, "new");
 319     file_had_user_group = g_key_file_has_group (config->key_file, "user");
 320     file_had_maildir_group = g_key_file_has_group (config->key_file, "maildir");
 321     file_had_search_group = g_key_file_has_group (config->key_file, "search");
 322
 323
 324     if (notmuch_config_get_database_path (config) == NULL) {
 325         char *path = talloc_asprintf (config, "%s/mail",
 326                                       getenv ("HOME"));
 327         notmuch_config_set_database_path (config, path);
 328         talloc_free (path);
 329     }
 330
 331     if (notmuch_config_get_user_name (config) == NULL) {
 332         char *name = get_name_from_passwd_file (config);
 333         notmuch_config_set_user_name (config, name);
 334         talloc_free (name);
 335     }
 336
 337     if (notmuch_config_get_user_primary_email (config) == NULL) {
 338         char *email = getenv ("EMAIL");
 339         if (email) {
 340             notmuch_config_set_user_primary_email (config, email);
 341         } else {
 342             char hostname[256];
 343             struct hostent *hostent;
 344             const char *domainname;
 345
 346             char *username = get_username_from_passwd_file (config);
 347
 348             gethostname (hostname, 256);
 349             hostname[255] = '\0';
 350
 351             hostent = gethostbyname (hostname);
 352             if (hostent && (domainname = strchr (hostent->h_name, '.')))
 353                 domainname += 1;
 354             else
 355                 domainname = "(none)";
 356
 357             email = talloc_asprintf (config, "%s@%s.%s",
 358                                      username, hostname, domainname);
 359
 360             notmuch_config_set_user_primary_email (config, email);
 361
 362             talloc_free (username);
 363             talloc_free (email);
 364         }
 365     }
 366
 367     if (notmuch_config_get_new_tags (config, &tmp) == NULL) {
 368         const char *tags[] = { "unread", "inbox" };
 369         notmuch_config_set_new_tags (config, tags, 2);
 370     }
 371
 372     if (notmuch_config_get_new_ignore (config, &tmp) == NULL) {
 373         notmuch_config_set_new_ignore (config, NULL, 0);
 374     }
 375
 376     if (notmuch_config_get_search_exclude_tags (config, &tmp) == NULL) {
 377         if (config->is_new) {
 378             const char *tags[] = { "deleted", "spam" };
 379             notmuch_config_set_search_exclude_tags (config, tags, 2);
 380         } else {
 381             notmuch_config_set_search_exclude_tags (config, NULL, 0);
 382         }
 383     }
 384
 385     error = NULL;
 386     config->maildir_synchronize_flags =
 387         g_key_file_get_boolean (config->key_file,
 388                                 "maildir", "synchronize_flags", &error);
 389     if (error) {
 390         notmuch_config_set_maildir_synchronize_flags (config, TRUE);
 391         g_error_free (error);
 392     }
 393
 394     /* Whenever we know of configuration sections that don't appear in
 395      * the configuration file, we add some comments to help the user
 396      * understand what can be done. */
 397     if (config->is_new)
 398         g_key_file_set_comment (config->key_file, NULL, NULL,
 399                                 toplevel_config_comment, NULL);
 400
 401     if (! file_had_database_group)
 402         g_key_file_set_comment (config->key_file, "database", NULL,
 403                                 database_config_comment, NULL);
 404
 405     if (! file_had_new_group)
 406         g_key_file_set_comment (config->key_file, "new", NULL,
 407                                 new_config_comment, NULL);
 408
 409     if (! file_had_user_group)
 410         g_key_file_set_comment (config->key_file, "user", NULL,
 411                                 user_config_comment, NULL);
 412
 413     if (! file_had_maildir_group)
 414         g_key_file_set_comment (config->key_file, "maildir", NULL,
 415                                 maildir_config_comment, NULL);
 416
 417     if (! file_had_search_group)
 418         g_key_file_set_comment (config->key_file, "search", NULL,
 419                                 search_config_comment, NULL);
 420
 421     return config;
 422 }
 423
 424 /* Close the given notmuch_config_t object, freeing all resources.
 425  *
 426  * Note: Any changes made to the configuration are *not* saved by this
 427  * function. To save changes, call notmuch_config_save before
 428  * notmuch_config_close.
 429 */
 430 void
 431 notmuch_config_close (notmuch_config_t *config)
 432 {
 433     talloc_free (config);
 434 }
 435
 436 /* Save any changes made to the notmuch configuration.
 437  *
 438  * Any comments originally in the file will be preserved.
 439  *
 440  * Returns 0 if successful, and 1 in case of any error, (after
 441  * printing a description of the error to stderr).
 442  */
 443 int
 444 notmuch_config_save (notmuch_config_t *config)
 445 {
 446     size_t length;
 447     char *data;
 448     GError *error = NULL;
 449
 450     data = g_key_file_to_data (config->key_file, &length, NULL);
 451     if (data == NULL) {
 452         fprintf (stderr, "Out of memory.\n");
 453         return 1;
 454     }
 455
 456     if (! g_file_set_contents (config->filename, data, length, &error)) {
 457         fprintf (stderr, "Error saving configuration to %s: %s\n",
 458                  config->filename, error->message);
 459         g_error_free (error);
 460         g_free (data);
 461         return 1;
 462     }
 463
 464     g_free (data);
 465     return 0;
 466 }
 467
 468 notmuch_bool_t
 469 notmuch_config_is_new (notmuch_config_t *config)
 470 {
 471     return config->is_new;
 472 }
 473
 474
 475 static const char **
 476 _config_get_list (notmuch_config_t *config,
 477                   const char *section, const char *key,
 478                   const char ***outlist, size_t *list_length, size_t *ret_length)
 479 {
 480     assert(outlist);
 481
 482     if (*outlist == NULL) {
 483
 484         char **inlist = g_key_file_get_string_list (config->key_file,
 485                                              section, key, list_length, NULL);
 486         if (inlist) {
 487             unsigned int i;
 488
 489             *outlist = talloc_size (config, sizeof (char *) * (*list_length + 1));
 490
 491             for (i = 0; i < *list_length; i++)
 492                 (*outlist)[i] = talloc_strdup (*outlist, inlist[i]);
 493
 494             (*outlist)[i] = NULL;
 495
 496             g_strfreev (inlist);
 497         }
 498     }
 499
 500     if (ret_length)
 501         *ret_length = *list_length;
 502
 503     return *outlist;
 504 }
 505
 506 static void
 507 _config_set_list (notmuch_config_t *config,
 508                   const char *group, const char *name,
 509                   const char *list[],
 510                   size_t length, const char ***config_var )
 511 {
 512     g_key_file_set_string_list (config->key_file, group, name, list, length);
 513     talloc_free (*config_var);
 514     *config_var = NULL;
 515 }
 516
 517 const char *
 518 notmuch_config_get_database_path (notmuch_config_t *config)
 519 {
 520     char *path;
 521
 522     if (config->database_path == NULL) {
 523         path = g_key_file_get_string (config->key_file,
 524                                       "database", "path", NULL);
 525         if (path) {
 526             config->database_path = talloc_strdup (config, path);
 527             free (path);
 528         }
 529     }
 530
 531     return config->database_path;
 532 }
 533
 534 void
 535 notmuch_config_set_database_path (notmuch_config_t *config,
 536                                   const char *database_path)
 537 {
 538     g_key_file_set_string (config->key_file,
 539                            "database", "path", database_path);
 540
 541     talloc_free (config->database_path);
 542     config->database_path = NULL;
 543 }
 544
 545 const char *
 546 notmuch_config_get_user_name (notmuch_config_t *config)
 547 {
 548     char *name;
 549
 550     if (config->user_name == NULL) {
 551         name = g_key_file_get_string (config->key_file,
 552                                       "user", "name", NULL);
 553         if (name) {
 554             config->user_name = talloc_strdup (config, name);
 555             free (name);
 556         }
 557     }
 558
 559     return config->user_name;
 560 }
 561
 562 void
 563 notmuch_config_set_user_name (notmuch_config_t *config,
 564                               const char *user_name)
 565 {
 566     g_key_file_set_string (config->key_file,
 567                            "user", "name", user_name);
 568
 569     talloc_free (config->user_name);
 570     config->user_name = NULL;
 571 }
 572
 573 const char *
 574 notmuch_config_get_user_primary_email (notmuch_config_t *config)
 575 {
 576     char *email;
 577
 578     if (config->user_primary_email == NULL) {
 579         email = g_key_file_get_string (config->key_file,
 580                                        "user", "primary_email", NULL);
 581         if (email) {
 582             config->user_primary_email = talloc_strdup (config, email);
 583             free (email);
 584         }
 585     }
 586
 587     return config->user_primary_email;
 588 }
 589
 590 void
 591 notmuch_config_set_user_primary_email (notmuch_config_t *config,
 592                                        const char *primary_email)
 593 {
 594     g_key_file_set_string (config->key_file,
 595                            "user", "primary_email", primary_email);
 596
 597     talloc_free (config->user_primary_email);
 598     config->user_primary_email = NULL;
 599 }
 600
 601 const char **
 602 notmuch_config_get_user_other_email (notmuch_config_t *config,   size_t *length)
 603 {
 604     return _config_get_list (config, "user", "other_email",
 605                              &(config->user_other_email),
 606                              &(config->user_other_email_length), length);
 607 }
 608
 609 const char **
 610 notmuch_config_get_new_tags (notmuch_config_t *config,   size_t *length)
 611 {
 612     return _config_get_list (config, "new", "tags",
 613                              &(config->new_tags),
 614                              &(config->new_tags_length), length);
 615 }
 616
 617 const char **
 618 notmuch_config_get_new_ignore (notmuch_config_t *config, size_t *length)
 619 {
 620     return _config_get_list (config, "new", "ignore",
 621                              &(config->new_ignore),
 622                              &(config->new_ignore_length), length);
 623 }
 624
 625 void
 626 notmuch_config_set_user_other_email (notmuch_config_t *config,
 627                                      const char *list[],
 628                                      size_t length)
 629 {
 630     _config_set_list (config, "user", "other_email", list, length,
 631                      &(config->user_other_email));
 632 }
 633
 634 void
 635 notmuch_config_set_new_tags (notmuch_config_t *config,
 636                                      const char *list[],
 637                                      size_t length)
 638 {
 639     _config_set_list (config, "new", "tags", list, length,
 640                      &(config->new_tags));
 641 }
 642
 643 void
 644 notmuch_config_set_new_ignore (notmuch_config_t *config,
 645                                const char *list[],
 646                                size_t length)
 647 {
 648     _config_set_list (config, "new", "ignore", list, length,
 649                      &(config->new_ignore));
 650 }
 651
 652 const char **
 653 notmuch_config_get_search_exclude_tags (notmuch_config_t *config, size_t *length)
 654 {
 655     return _config_get_list (config, "search", "exclude_tags",
 656                              &(config->search_exclude_tags),
 657                              &(config->search_exclude_tags_length), length);
 658 }
 659
 660 void
 661 notmuch_config_set_search_exclude_tags (notmuch_config_t *config,
 662                                       const char *list[],
 663                                       size_t length)
 664 {
 665     _config_set_list (config, "search", "exclude_tags", list, length,
 666                       &(config->search_exclude_tags));
 667 }
 668
 669 /* Given a configuration item of the form <group>.<key> return the
 670  * component group and key. If any error occurs, print a message on
 671  * stderr and return 1. Otherwise, return 0.
 672  *
 673  * Note: This function modifies the original 'item' string.
 674  */
 675 static int
 676 _item_split (char *item, char **group, char **key)
 677 {
 678     char *period;
 679
 680     *group = item;
 681
 682     period = index (item, '.');
 683     if (period == NULL || *(period+1) == '\0') {
 684         fprintf (stderr,
 685                  "Invalid configuration name: %s\n"
 686                  "(Should be of the form <section>.<item>)\n", item);
 687         return 1;
 688     }
 689
 690     *period = '\0';
 691     *key = period + 1;
 692
 693     return 0;
 694 }
 695
 696 static int
 697 notmuch_config_command_get (notmuch_config_t *config, char *item)
 698 {
 699     if (strcmp(item, "database.path") == 0) {
 700         printf ("%s\n", notmuch_config_get_database_path (config));
 701     } else if (strcmp(item, "user.name") == 0) {
 702         printf ("%s\n", notmuch_config_get_user_name (config));
 703     } else if (strcmp(item, "user.primary_email") == 0) {
 704         printf ("%s\n", notmuch_config_get_user_primary_email (config));
 705     } else if (strcmp(item, "user.other_email") == 0) {
 706         const char **other_email;
 707         size_t i, length;
 708
 709         other_email = notmuch_config_get_user_other_email (config, &length);
 710         for (i = 0; i < length; i++)
 711             printf ("%s\n", other_email[i]);
 712     } else if (strcmp(item, "new.tags") == 0) {
 713         const char **tags;
 714         size_t i, length;
 715
 716         tags = notmuch_config_get_new_tags (config, &length);
 717         for (i = 0; i < length; i++)
 718             printf ("%s\n", tags[i]);
 719     } else {
 720         char **value;
 721         size_t i, length;
 722         char *group, *key;
 723
 724         if (_item_split (item, &group, &key))
 725             return 1;
 726
 727         value = g_key_file_get_string_list (config->key_file,
 728                                             group, key,
 729                                             &length, NULL);
 730         if (value == NULL) {
 731             fprintf (stderr, "Unknown configuration item: %s.%s\n",
 732                      group, key);
 733             return 1;
 734         }
 735
 736         for (i = 0; i < length; i++)
 737             printf ("%s\n", value[i]);
 738
 739         g_strfreev (value);
 740     }
 741
 742     return 0;
 743 }
 744
 745 static int
 746 notmuch_config_command_set (notmuch_config_t *config, char *item, int argc, char *argv[])
 747 {
 748     char *group, *key;
 749
 750     if (_item_split (item, &group, &key))
 751         return 1;
 752
 753     /* With only the name of an item, we clear it from the
 754      * configuration file.
 755      *
 756      * With a single value, we set it as a string.
 757      *
 758      * With multiple values, we set them as a string list.
 759      */
 760     switch (argc) {
 761     case 0:
 762         g_key_file_remove_key (config->key_file, group, key, NULL);
 763         break;
 764     case 1:
 765         g_key_file_set_string (config->key_file, group, key, argv[0]);
 766         break;
 767     default:
 768         g_key_file_set_string_list (config->key_file, group, key,
 769                                     (const gchar **) argv, argc);
 770         break;
 771     }
 772
 773     return notmuch_config_save (config);
 774 }
 775
 776 static int
 777 notmuch_config_command_list (notmuch_config_t *config)
 778 {
 779     char **groups;
 780     size_t g, groups_length;
 781
 782     groups = g_key_file_get_groups (config->key_file, &groups_length);
 783     if (groups == NULL)
 784         return 1;
 785
 786     for (g = 0; g < groups_length; g++) {
 787         char **keys;
 788         size_t k, keys_length;
 789
 790         keys = g_key_file_get_keys (config->key_file,
 791                                     groups[g], &keys_length, NULL);
 792         if (keys == NULL)
 793             continue;
 794
 795         for (k = 0; k < keys_length; k++) {
 796             char *value;
 797
 798             value = g_key_file_get_string (config->key_file,
 799                                            groups[g], keys[k], NULL);
 800             if (value != NULL) {
 801                 printf ("%s.%s=%s\n", groups[g], keys[k], value);
 802                 free (value);
 803             }
 804         }
 805
 806         g_strfreev (keys);
 807     }
 808
 809     g_strfreev (groups);
 810
 811     return 0;
 812 }
 813
 814 int
 815 notmuch_config_command (notmuch_config_t *config, int argc, char *argv[])
 816 {
 817     argc--; argv++; /* skip subcommand argument */
 818
 819     if (argc < 1) {
 820         fprintf (stderr, "Error: notmuch config requires at least one argument.\n");
 821         return 1;
 822     }
 823
 824     if (strcmp (argv[0], "get") == 0) {
 825         if (argc != 2) {
 826             fprintf (stderr, "Error: notmuch config get requires exactly "
 827                      "one argument.\n");
 828             return 1;
 829         }
 830         return notmuch_config_command_get (config, argv[1]);
 831     } else if (strcmp (argv[0], "set") == 0) {
 832         if (argc < 2) {
 833             fprintf (stderr, "Error: notmuch config set requires at least "
 834                      "one argument.\n");
 835             return 1;
 836         }
 837         return notmuch_config_command_set (config, argv[1], argc - 2, argv + 2);
 838     } else if (strcmp (argv[0], "list") == 0) {
 839         return notmuch_config_command_list (config);
 840     }
 841
 842     fprintf (stderr, "Unrecognized argument for notmuch config: %s\n",
 843              argv[0]);
 844     return 1;
 845 }
 846
 847 notmuch_bool_t
 848 notmuch_config_get_maildir_synchronize_flags (notmuch_config_t *config)
 849 {
 850     return config->maildir_synchronize_flags;
 851 }
 852
 853 void
 854 notmuch_config_set_maildir_synchronize_flags (notmuch_config_t *config,
 855                                               notmuch_bool_t synchronize_flags)
 856 {
 857     g_key_file_set_boolean (config->key_file,
 858                             "maildir", "synchronize_flags", synchronize_flags);
 859     config->maildir_synchronize_flags = synchronize_flags;
 860 }