1 /* notmuch - Not much of an email program, (just index and search)
3 * Copyright © 2009 Carl Worth
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.
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.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see https://www.gnu.org/licenses/ .
18 * Author: Carl Worth <cworth@cworth.org>
21 #include "notmuch-client.h"
27 #include "unicode-util.h"
29 static const char toplevel_config_comment[] =
30 " .notmuch-config - Configuration file for the notmuch mail system\n"
32 " For more information about notmuch, see https://notmuchmail.org";
34 static const char database_config_comment[] =
35 " Database configuration\n"
37 " The only value supported here is 'path' which should be the top-level\n"
38 " directory where your mail currently exists and to where mail will be\n"
39 " delivered in the future. Files should be individual email messages.\n"
40 " Notmuch will store its database within a sub-directory of the path\n"
41 " configured here named \".notmuch\".\n";
43 static const char new_config_comment[] =
44 " Configuration for \"notmuch new\"\n"
46 " The following options are supported here:\n"
48 "\ttags A list (separated by ';') of the tags that will be\n"
49 "\t added to all messages incorporated by \"notmuch new\".\n"
51 "\tignore A list (separated by ';') of file and directory names\n"
52 "\t that will not be searched for messages by \"notmuch new\".\n"
54 "\t NOTE: *Every* file/directory that goes by one of those\n"
55 "\t names will be ignored, independent of its depth/location\n"
56 "\t in the mail store.\n";
58 static const char user_config_comment[] =
59 " User configuration\n"
61 " Here is where you can let notmuch know how you would like to be\n"
62 " addressed. Valid settings are\n"
64 "\tname Your full name.\n"
65 "\tprimary_email Your primary email address.\n"
66 "\tother_email A list (separated by ';') of other email addresses\n"
67 "\t at which you receive email.\n"
69 " Notmuch will use the various email addresses configured here when\n"
70 " formatting replies. It will avoid including your own addresses in the\n"
71 " recipient list of replies, and will set the From address based on the\n"
72 " address to which the original email was addressed.\n";
74 static const char maildir_config_comment[] =
75 " Maildir compatibility configuration\n"
77 " The following option is supported here:\n"
79 "\tsynchronize_flags Valid values are true and false.\n"
81 "\tIf true, then the following maildir flags (in message filenames)\n"
82 "\twill be synchronized with the corresponding notmuch tags:\n"
90 "\t\tS unread (added when 'S' flag is not present)\n"
92 "\tThe \"notmuch new\" command will notice flag changes in filenames\n"
93 "\tand update tags, while the \"notmuch tag\" and \"notmuch restore\"\n"
94 "\tcommands will notice tag changes and update flags in filenames\n";
96 static const char search_config_comment[] =
97 " Search configuration\n"
99 " The following option is supported here:\n"
102 "\t\tA ;-separated list of tags that will be excluded from\n"
103 "\t\tsearch results by default. Using an excluded tag in a\n"
104 "\t\tquery will override that exclusion.\n";
106 static const char crypto_config_comment[] =
107 " Cryptography related configuration\n"
109 " The following old option is now ignored:\n"
112 "\t\tThis option was used by older builds of notmuch to choose\n"
113 "\t\tthe version of gpg to use.\n"
114 "\t\tSetting $PATH is a better approach.\n";
116 struct _notmuch_config {
123 char *user_primary_email;
124 const char **user_other_email;
125 size_t user_other_email_length;
126 const char **new_tags;
127 size_t new_tags_length;
128 const char **new_ignore;
129 size_t new_ignore_length;
130 bool maildir_synchronize_flags;
131 const char **search_exclude_tags;
132 size_t search_exclude_tags_length;
136 notmuch_config_destructor (notmuch_config_t *config)
138 if (config->key_file)
139 g_key_file_free (config->key_file);
145 get_name_from_passwd_file (void *ctx)
149 struct passwd passwd, *ignored;
153 pw_buf_size = sysconf (_SC_GETPW_R_SIZE_MAX);
154 if (pw_buf_size == -1) pw_buf_size = 64;
155 pw_buf = talloc_size (ctx, pw_buf_size);
157 while ((e = getpwuid_r (getuid (), &passwd, pw_buf,
158 pw_buf_size, &ignored)) == ERANGE) {
159 pw_buf_size = pw_buf_size * 2;
160 pw_buf = talloc_zero_size (ctx, pw_buf_size);
164 char *comma = strchr (passwd.pw_gecos, ',');
166 name = talloc_strndup (ctx, passwd.pw_gecos,
167 comma - passwd.pw_gecos);
169 name = talloc_strdup (ctx, passwd.pw_gecos);
171 name = talloc_strdup (ctx, "");
174 talloc_free (pw_buf);
180 get_username_from_passwd_file (void *ctx)
184 struct passwd passwd, *ignored;
188 pw_buf_size = sysconf (_SC_GETPW_R_SIZE_MAX);
189 if (pw_buf_size == -1) pw_buf_size = 64;
190 pw_buf = talloc_zero_size (ctx, pw_buf_size);
192 while ((e = getpwuid_r (getuid (), &passwd, pw_buf,
193 pw_buf_size, &ignored)) == ERANGE) {
194 pw_buf_size = pw_buf_size * 2;
195 pw_buf = talloc_zero_size (ctx, pw_buf_size);
199 name = talloc_strdup (ctx, passwd.pw_name);
201 name = talloc_strdup (ctx, "");
203 talloc_free (pw_buf);
209 get_config_from_file (notmuch_config_t *config, bool create_new)
211 #define BUF_SIZE 4096
212 char *config_str = NULL;
214 int config_bufsize = BUF_SIZE;
216 GError *error = NULL;
219 FILE *fp = fopen (config->filename, "r");
221 if (errno == ENOENT) {
222 /* If create_new is true, then the caller is prepared for a
223 * default configuration file in the case of FILE NOT FOUND.
226 config->is_new = true;
229 fprintf (stderr, "Configuration file %s not found.\n"
230 "Try running 'notmuch setup' to create a configuration.\n",
234 fprintf (stderr, "Error opening config file '%s': %s\n",
235 config->filename, strerror (errno));
240 config_str = talloc_zero_array (config, char, config_bufsize);
241 if (config_str == NULL) {
242 fprintf (stderr, "Error reading '%s': Out of memory\n", config->filename);
246 while ((len = fread (config_str + config_len, 1,
247 config_bufsize - config_len, fp)) > 0) {
249 if (config_len == config_bufsize) {
250 config_bufsize += BUF_SIZE;
251 config_str = talloc_realloc (config, config_str, char, config_bufsize);
252 if (config_str == NULL) {
253 fprintf (stderr, "Error reading '%s': Failed to reallocate memory\n",
261 fprintf (stderr, "Error reading '%s': I/O error\n", config->filename);
265 if (g_key_file_load_from_data (config->key_file, config_str, config_len,
266 G_KEY_FILE_KEEP_COMMENTS, &error)) {
271 fprintf (stderr, "Error parsing config file '%s': %s\n",
272 config->filename, error->message);
274 g_error_free (error);
281 talloc_free (config_str);
286 /* Open the named notmuch configuration file. If the filename is NULL,
287 * the value of the environment variable $NOTMUCH_CONFIG will be used.
288 * If $NOTMUCH_CONFIG is unset, the default configuration file
289 * ($HOME/.notmuch-config) will be used.
291 * If any error occurs, (out of memory, or a permission-denied error,
292 * etc.), this function will print a message to stderr and return
295 * FILE NOT FOUND: When the specified configuration file (whether from
296 * 'filename' or the $NOTMUCH_CONFIG environment variable) does not
297 * exist, the behavior of this function depends on the 'is_new_ret'
300 * If is_new_ret is NULL, then a "file not found" message will be
301 * printed to stderr and NULL will be returned.
303 * If is_new_ret is non-NULL then a default configuration will be
304 * returned and *is_new_ret will be set to 1 on return so that
305 * the caller can recognize this case.
307 * These default configuration settings are determined as
310 * database_path: $MAILDIR, otherwise $HOME/mail
312 * user_name: $NAME variable if set, otherwise
313 * read from /etc/passwd
315 * user_primary_mail: $EMAIL variable if set, otherwise
316 * constructed from the username and
317 * hostname of the current machine.
319 * user_other_email: Not set.
321 * The default configuration also contains comments to guide the
322 * user in editing the file directly.
325 notmuch_config_open (void *ctx,
326 const char *filename,
327 notmuch_command_mode_t config_mode)
329 GError *error = NULL;
331 char *notmuch_config_env = NULL;
332 int file_had_database_group;
333 int file_had_new_group;
334 int file_had_user_group;
335 int file_had_maildir_group;
336 int file_had_search_group;
337 int file_had_crypto_group;
339 notmuch_config_t *config = talloc_zero (ctx, notmuch_config_t);
341 if (config == NULL) {
342 fprintf (stderr, "Out of memory.\n");
346 talloc_set_destructor (config, notmuch_config_destructor);
348 /* non-zero defaults */
349 config->maildir_synchronize_flags = true;
352 config->filename = talloc_strdup (config, filename);
353 } else if ((notmuch_config_env = getenv ("NOTMUCH_CONFIG"))) {
354 config->filename = talloc_strdup (config, notmuch_config_env);
356 config->filename = talloc_asprintf (config, "%s/.notmuch-config",
360 config->key_file = g_key_file_new ();
362 if (config_mode & NOTMUCH_COMMAND_CONFIG_OPEN) {
363 bool create_new = (config_mode & NOTMUCH_COMMAND_CONFIG_CREATE) != 0;
365 if (! get_config_from_file (config, create_new)) {
366 talloc_free (config);
371 /* Whenever we know of configuration sections that don't appear in
372 * the configuration file, we add some comments to help the user
373 * understand what can be done.
375 * It would be convenient to just add those comments now, but
376 * apparently g_key_file will clear any comments when keys are
377 * added later that create the groups. So we have to check for the
378 * groups now, but add the comments only after setting all of our
381 file_had_database_group = g_key_file_has_group (config->key_file,
383 file_had_new_group = g_key_file_has_group (config->key_file, "new");
384 file_had_user_group = g_key_file_has_group (config->key_file, "user");
385 file_had_maildir_group = g_key_file_has_group (config->key_file, "maildir");
386 file_had_search_group = g_key_file_has_group (config->key_file, "search");
387 file_had_crypto_group = g_key_file_has_group (config->key_file, "crypto");
389 if (notmuch_config_get_database_path (config) == NULL) {
390 char *path = getenv ("MAILDIR");
392 path = talloc_strdup (config, path);
394 path = talloc_asprintf (config, "%s/mail",
396 notmuch_config_set_database_path (config, path);
400 if (notmuch_config_get_user_name (config) == NULL) {
401 char *name = getenv ("NAME");
403 name = talloc_strdup (config, name);
405 name = get_name_from_passwd_file (config);
406 notmuch_config_set_user_name (config, name);
410 if (notmuch_config_get_user_primary_email (config) == NULL) {
411 char *email = getenv ("EMAIL");
413 notmuch_config_set_user_primary_email (config, email);
416 struct hostent *hostent;
417 const char *domainname;
419 char *username = get_username_from_passwd_file (config);
421 gethostname (hostname, 256);
422 hostname[255] = '\0';
424 hostent = gethostbyname (hostname);
425 if (hostent && (domainname = strchr (hostent->h_name, '.')))
428 domainname = "(none)";
430 email = talloc_asprintf (config, "%s@%s.%s",
431 username, hostname, domainname);
433 notmuch_config_set_user_primary_email (config, email);
435 talloc_free (username);
440 if (notmuch_config_get_new_tags (config, &tmp) == NULL) {
441 const char *tags[] = { "unread", "inbox" };
442 notmuch_config_set_new_tags (config, tags, 2);
445 if (notmuch_config_get_new_ignore (config, &tmp) == NULL) {
446 notmuch_config_set_new_ignore (config, NULL, 0);
449 if (notmuch_config_get_search_exclude_tags (config, &tmp) == NULL) {
450 if (config->is_new) {
451 const char *tags[] = { "deleted", "spam" };
452 notmuch_config_set_search_exclude_tags (config, tags, 2);
454 notmuch_config_set_search_exclude_tags (config, NULL, 0);
459 config->maildir_synchronize_flags =
460 g_key_file_get_boolean (config->key_file,
461 "maildir", "synchronize_flags", &error);
463 notmuch_config_set_maildir_synchronize_flags (config, true);
464 g_error_free (error);
467 /* Whenever we know of configuration sections that don't appear in
468 * the configuration file, we add some comments to help the user
469 * understand what can be done. */
471 g_key_file_set_comment (config->key_file, NULL, NULL,
472 toplevel_config_comment, NULL);
474 if (! file_had_database_group)
475 g_key_file_set_comment (config->key_file, "database", NULL,
476 database_config_comment, NULL);
478 if (! file_had_new_group)
479 g_key_file_set_comment (config->key_file, "new", NULL,
480 new_config_comment, NULL);
482 if (! file_had_user_group)
483 g_key_file_set_comment (config->key_file, "user", NULL,
484 user_config_comment, NULL);
486 if (! file_had_maildir_group)
487 g_key_file_set_comment (config->key_file, "maildir", NULL,
488 maildir_config_comment, NULL);
490 if (! file_had_search_group)
491 g_key_file_set_comment (config->key_file, "search", NULL,
492 search_config_comment, NULL);
494 if (! file_had_crypto_group)
495 g_key_file_set_comment (config->key_file, "crypto", NULL,
496 crypto_config_comment, NULL);
501 /* Close the given notmuch_config_t object, freeing all resources.
503 * Note: Any changes made to the configuration are *not* saved by this
504 * function. To save changes, call notmuch_config_save before
505 * notmuch_config_close.
508 notmuch_config_close (notmuch_config_t *config)
510 talloc_free (config);
513 const char *_notmuch_config_get_path (notmuch_config_t *config) {
514 return config->filename;
516 /* Save any changes made to the notmuch configuration.
518 * Any comments originally in the file will be preserved.
520 * Returns 0 if successful, and 1 in case of any error, (after
521 * printing a description of the error to stderr).
524 notmuch_config_save (notmuch_config_t *config)
527 char *data, *filename;
528 GError *error = NULL;
530 data = g_key_file_to_data (config->key_file, &length, NULL);
532 fprintf (stderr, "Out of memory.\n");
536 /* Try not to overwrite symlinks. */
537 filename = canonicalize_file_name (config->filename);
539 if (errno == ENOENT) {
540 filename = strdup (config->filename);
542 fprintf (stderr, "Out of memory.\n");
547 fprintf (stderr, "Error canonicalizing %s: %s\n", config->filename,
554 if (! g_file_set_contents (filename, data, length, &error)) {
555 if (strcmp (filename, config->filename) != 0) {
556 fprintf (stderr, "Error saving configuration to %s (-> %s): %s\n",
557 config->filename, filename, error->message);
559 fprintf (stderr, "Error saving configuration to %s: %s\n",
560 filename, error->message);
562 g_error_free (error);
574 notmuch_config_is_new (notmuch_config_t *config)
576 return config->is_new;
580 _config_get (notmuch_config_t *config, char **field,
581 const char *group, const char *key)
583 /* read from config file and cache value, if not cached already */
584 if (*field == NULL) {
586 value = g_key_file_get_string (config->key_file, group, key, NULL);
588 *field = talloc_strdup (config, value);
596 _config_set (notmuch_config_t *config, char **field,
597 const char *group, const char *key, const char *value)
599 g_key_file_set_string (config->key_file, group, key, value);
601 /* drop the cached value */
602 talloc_free (*field);
607 _config_get_list (notmuch_config_t *config,
608 const char *section, const char *key,
609 const char ***outlist, size_t *list_length, size_t *ret_length)
613 /* read from config file and cache value, if not cached already */
614 if (*outlist == NULL) {
616 char **inlist = g_key_file_get_string_list (config->key_file,
617 section, key, list_length, NULL);
621 *outlist = talloc_size (config, sizeof (char *) * (*list_length + 1));
623 for (i = 0; i < *list_length; i++)
624 (*outlist)[i] = talloc_strdup (*outlist, inlist[i]);
626 (*outlist)[i] = NULL;
633 *ret_length = *list_length;
639 _config_set_list (notmuch_config_t *config,
640 const char *group, const char *key,
642 size_t length, const char ***config_var )
644 g_key_file_set_string_list (config->key_file, group, key, list, length);
646 /* drop the cached value */
647 talloc_free (*config_var);
652 notmuch_config_get_database_path (notmuch_config_t *config)
654 char *db_path = (char *) _config_get (config, &config->database_path, "database", "path");
656 if (db_path && *db_path != '/') {
657 /* If the path in the configuration file begins with any
658 * character other than /, presume that it is relative to
659 * $HOME and update as appropriate.
661 char *abs_path = talloc_asprintf (config, "%s/%s", getenv ("HOME"), db_path);
662 talloc_free (db_path);
663 db_path = config->database_path = abs_path;
670 notmuch_config_set_database_path (notmuch_config_t *config,
671 const char *database_path)
673 _config_set (config, &config->database_path, "database", "path", database_path);
677 notmuch_config_get_user_name (notmuch_config_t *config)
679 return _config_get (config, &config->user_name, "user", "name");
683 notmuch_config_set_user_name (notmuch_config_t *config,
684 const char *user_name)
686 _config_set (config, &config->user_name, "user", "name", user_name);
690 notmuch_config_get_user_primary_email (notmuch_config_t *config)
692 return _config_get (config, &config->user_primary_email, "user", "primary_email");
696 notmuch_config_set_user_primary_email (notmuch_config_t *config,
697 const char *primary_email)
699 _config_set (config, &config->user_primary_email, "user", "primary_email", primary_email);
703 notmuch_config_get_user_other_email (notmuch_config_t *config, size_t *length)
705 return _config_get_list (config, "user", "other_email",
706 &(config->user_other_email),
707 &(config->user_other_email_length), length);
711 notmuch_config_get_new_tags (notmuch_config_t *config, size_t *length)
713 return _config_get_list (config, "new", "tags",
715 &(config->new_tags_length), length);
719 notmuch_config_get_new_ignore (notmuch_config_t *config, size_t *length)
721 return _config_get_list (config, "new", "ignore",
722 &(config->new_ignore),
723 &(config->new_ignore_length), length);
727 notmuch_config_set_user_other_email (notmuch_config_t *config,
731 _config_set_list (config, "user", "other_email", list, length,
732 &(config->user_other_email));
736 notmuch_config_set_new_tags (notmuch_config_t *config,
740 _config_set_list (config, "new", "tags", list, length,
741 &(config->new_tags));
745 notmuch_config_set_new_ignore (notmuch_config_t *config,
749 _config_set_list (config, "new", "ignore", list, length,
750 &(config->new_ignore));
754 notmuch_config_get_search_exclude_tags (notmuch_config_t *config, size_t *length)
756 return _config_get_list (config, "search", "exclude_tags",
757 &(config->search_exclude_tags),
758 &(config->search_exclude_tags_length), length);
762 notmuch_config_set_search_exclude_tags (notmuch_config_t *config,
766 _config_set_list (config, "search", "exclude_tags", list, length,
767 &(config->search_exclude_tags));
771 /* Given a configuration item of the form <group>.<key> return the
772 * component group and key. If any error occurs, print a message on
773 * stderr and return 1. Otherwise, return 0.
775 * Note: This function modifies the original 'item' string.
778 _item_split (char *item, char **group, char **key)
784 period = strchr (item, '.');
785 if (period == NULL || *(period + 1) == '\0') {
787 "Invalid configuration name: %s\n"
788 "(Should be of the form <section>.<item>)\n", item);
798 /* These are more properly called Xapian fields, but the user facing
799 * docs call them prefixes, so make the error message match */
801 validate_field_name (const char *str)
805 if (! g_utf8_validate (str, -1, NULL)) {
806 fprintf (stderr, "Invalid utf8: %s\n", str);
810 key = g_utf8_strrchr (str, -1, '.');
812 INTERNAL_ERROR ("Impossible code path on input: %s\n", str);
818 fprintf (stderr, "Empty prefix name: %s\n", str);
822 if (! unicode_word_utf8 (key)) {
823 fprintf (stderr, "Non-word character in prefix name: %s\n", key);
827 if (key[0] >= 'a' && key[0] <= 'z') {
828 fprintf (stderr, "Prefix names starting with lower case letters are reserved: %s\n", key);
835 #define BUILT_WITH_PREFIX "built_with."
837 typedef struct config_key {
841 bool (*validate)(const char *);
844 static struct config_key
845 config_key_table[] = {
846 { "index.decrypt", true, false, NULL },
847 { "index.header.", true, true, validate_field_name },
848 { "query.", true, true, NULL },
851 static config_key_info_t *
852 _config_key_info (const char *item)
854 for (size_t i = 0; i < ARRAY_SIZE (config_key_table); i++) {
855 if (config_key_table[i].prefix &&
856 strncmp (item, config_key_table[i].name,
857 strlen (config_key_table[i].name)) == 0)
858 return config_key_table + i;
859 if (strcmp (item, config_key_table[i].name) == 0)
860 return config_key_table + i;
866 _stored_in_db (const char *item)
868 config_key_info_t *info;
870 info = _config_key_info (item);
872 return (info && info->in_db);
876 _print_db_config (notmuch_config_t *config, const char *name)
878 notmuch_database_t *notmuch;
881 if (notmuch_database_open (notmuch_config_get_database_path (config),
882 NOTMUCH_DATABASE_MODE_READ_ONLY, ¬much))
885 /* XXX Handle UUID mismatch? */
887 if (print_status_database ("notmuch config", notmuch,
888 notmuch_database_get_config (notmuch, name, &val)))
897 notmuch_config_command_get (notmuch_config_t *config, char *item)
899 if (strcmp (item, "database.path") == 0) {
900 printf ("%s\n", notmuch_config_get_database_path (config));
901 } else if (strcmp (item, "user.name") == 0) {
902 printf ("%s\n", notmuch_config_get_user_name (config));
903 } else if (strcmp (item, "user.primary_email") == 0) {
904 printf ("%s\n", notmuch_config_get_user_primary_email (config));
905 } else if (strcmp (item, "user.other_email") == 0) {
906 const char **other_email;
909 other_email = notmuch_config_get_user_other_email (config, &length);
910 for (i = 0; i < length; i++)
911 printf ("%s\n", other_email[i]);
912 } else if (strcmp (item, "new.tags") == 0) {
916 tags = notmuch_config_get_new_tags (config, &length);
917 for (i = 0; i < length; i++)
918 printf ("%s\n", tags[i]);
919 } else if (STRNCMP_LITERAL (item, BUILT_WITH_PREFIX) == 0) {
921 notmuch_built_with (item + strlen (BUILT_WITH_PREFIX)) ? "true" : "false");
922 } else if (_stored_in_db (item)) {
923 return _print_db_config (config, item);
929 if (_item_split (item, &group, &key))
932 value = g_key_file_get_string_list (config->key_file,
936 fprintf (stderr, "Unknown configuration item: %s.%s\n",
941 for (i = 0; i < length; i++)
942 printf ("%s\n", value[i]);
951 _set_db_config (notmuch_config_t *config, const char *key, int argc, char **argv)
953 notmuch_database_t *notmuch;
954 const char *val = "";
957 /* XXX handle lists? */
958 fprintf (stderr, "notmuch config set: at most one value expected for %s\n", key);
966 if (notmuch_database_open (notmuch_config_get_database_path (config),
967 NOTMUCH_DATABASE_MODE_READ_WRITE, ¬much))
970 /* XXX Handle UUID mismatch? */
972 if (print_status_database ("notmuch config", notmuch,
973 notmuch_database_set_config (notmuch, key, val)))
976 if (print_status_database ("notmuch config", notmuch,
977 notmuch_database_close (notmuch)))
984 notmuch_config_command_set (notmuch_config_t *config, char *item, int argc, char *argv[])
987 config_key_info_t *key_info;
989 if (STRNCMP_LITERAL (item, BUILT_WITH_PREFIX) == 0) {
990 fprintf (stderr, "Error: read only option: %s\n", item);
994 key_info = _config_key_info (item);
995 if (key_info && key_info->validate && (! key_info->validate (item)))
998 if (key_info && key_info->in_db) {
999 return _set_db_config (config, item, argc, argv);
1002 if (_item_split (item, &group, &key))
1005 /* With only the name of an item, we clear it from the
1006 * configuration file.
1008 * With a single value, we set it as a string.
1010 * With multiple values, we set them as a string list.
1014 g_key_file_remove_key (config->key_file, group, key, NULL);
1017 g_key_file_set_string (config->key_file, group, key, argv[0]);
1020 g_key_file_set_string_list (config->key_file, group, key,
1021 (const gchar **) argv, argc);
1025 return notmuch_config_save (config);
1030 _notmuch_config_list_built_with ()
1032 printf ("%scompact=%s\n",
1034 notmuch_built_with ("compact") ? "true" : "false");
1035 printf ("%sfield_processor=%s\n",
1037 notmuch_built_with ("field_processor") ? "true" : "false");
1038 printf ("%sretry_lock=%s\n",
1040 notmuch_built_with ("retry_lock") ? "true" : "false");
1044 _list_db_config (notmuch_config_t *config)
1046 notmuch_database_t *notmuch;
1047 notmuch_config_list_t *list;
1049 if (notmuch_database_open (notmuch_config_get_database_path (config),
1050 NOTMUCH_DATABASE_MODE_READ_ONLY, ¬much))
1051 return EXIT_FAILURE;
1053 /* XXX Handle UUID mismatch? */
1056 if (print_status_database ("notmuch config", notmuch,
1057 notmuch_database_get_config_list (notmuch, "", &list)))
1058 return EXIT_FAILURE;
1060 for (; notmuch_config_list_valid (list); notmuch_config_list_move_to_next (list)) {
1061 printf ("%s=%s\n", notmuch_config_list_key (list), notmuch_config_list_value (list));
1063 notmuch_config_list_destroy (list);
1065 return EXIT_SUCCESS;
1069 notmuch_config_command_list (notmuch_config_t *config)
1072 size_t g, groups_length;
1074 groups = g_key_file_get_groups (config->key_file, &groups_length);
1078 for (g = 0; g < groups_length; g++) {
1080 size_t k, keys_length;
1082 keys = g_key_file_get_keys (config->key_file,
1083 groups[g], &keys_length, NULL);
1087 for (k = 0; k < keys_length; k++) {
1090 value = g_key_file_get_string (config->key_file,
1091 groups[g], keys[k], NULL);
1092 if (value != NULL) {
1093 printf ("%s.%s=%s\n", groups[g], keys[k], value);
1101 g_strfreev (groups);
1103 _notmuch_config_list_built_with ();
1104 return _list_db_config (config);
1108 notmuch_config_command (notmuch_config_t *config, unused(notmuch_database_t *notmuch), int argc, char *argv[])
1113 opt_index = notmuch_minimal_options ("config", argc, argv);
1115 return EXIT_FAILURE;
1117 if (notmuch_requested_db_uuid)
1118 fprintf (stderr, "Warning: ignoring --uuid=%s\n",
1119 notmuch_requested_db_uuid);
1121 /* skip at least subcommand argument */
1126 fprintf (stderr, "Error: notmuch config requires at least one argument.\n");
1127 return EXIT_FAILURE;
1130 if (strcmp (argv[0], "get") == 0) {
1132 fprintf (stderr, "Error: notmuch config get requires exactly "
1134 return EXIT_FAILURE;
1136 ret = notmuch_config_command_get (config, argv[1]);
1137 } else if (strcmp (argv[0], "set") == 0) {
1139 fprintf (stderr, "Error: notmuch config set requires at least "
1141 return EXIT_FAILURE;
1143 ret = notmuch_config_command_set (config, argv[1], argc - 2, argv + 2);
1144 } else if (strcmp (argv[0], "list") == 0) {
1145 ret = notmuch_config_command_list (config);
1147 fprintf (stderr, "Unrecognized argument for notmuch config: %s\n",
1149 return EXIT_FAILURE;
1152 return ret ? EXIT_FAILURE : EXIT_SUCCESS;
1157 notmuch_config_get_maildir_synchronize_flags (notmuch_config_t *config)
1159 return config->maildir_synchronize_flags;
1163 notmuch_config_set_maildir_synchronize_flags (notmuch_config_t *config,
1164 bool synchronize_flags)
1166 g_key_file_set_boolean (config->key_file,
1167 "maildir", "synchronize_flags", synchronize_flags);
1168 config->maildir_synchronize_flags = synchronize_flags;