]> git.notmuchmail.org Git - notmuch/blob - lib/config.cc
lib: drop trailing slash for path and folder searches (infix)
[notmuch] / lib / config.cc
1 /* config.cc - API for database metadata
2  *
3  * Copyright © 2016 David Bremner
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 https://www.gnu.org/licenses/ .
17  *
18  * Author: David Bremner <david@tethera.net>
19  */
20
21 #include "notmuch.h"
22 #include "notmuch-private.h"
23 #include "database-private.h"
24
25 #include <pwd.h>
26 #include <netdb.h>
27
28 static const std::string CONFIG_PREFIX = "C";
29
30 struct _notmuch_config_list {
31     notmuch_database_t *notmuch;
32     Xapian::TermIterator iterator;
33     char *current_key;
34     char *current_val;
35 };
36
37 struct _notmuch_config_values {
38     const char *iterator;
39     size_t tok_len;
40     const char *string;
41     void *children; /* talloc_context */
42 };
43
44 struct _notmuch_config_pairs {
45     notmuch_string_map_iterator_t *iter;
46 };
47
48 static const char *_notmuch_config_key_to_string (notmuch_config_key_t key);
49 static char *_expand_path (void *ctx, const char *key, const char *val);
50
51 static int
52 _notmuch_config_list_destroy (notmuch_config_list_t *list)
53 {
54     /* invoke destructor w/o deallocating memory */
55     list->iterator.~TermIterator();
56     return 0;
57 }
58
59 notmuch_status_t
60 notmuch_database_set_config (notmuch_database_t *notmuch,
61                              const char *key,
62                              const char *value)
63 {
64     notmuch_status_t status;
65
66     status = _notmuch_database_ensure_writable (notmuch);
67     if (status)
68         return status;
69
70     if (! notmuch->config) {
71         if ((status = _notmuch_config_load_from_database (notmuch)))
72             return status;
73     }
74
75     try {
76         notmuch->writable_xapian_db->set_metadata (CONFIG_PREFIX + key, value);
77     } catch (const Xapian::Error &error) {
78         status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
79         notmuch->exception_reported = true;
80         _notmuch_database_log (notmuch, "Error: A Xapian exception occurred setting metadata: %s\n",
81                                error.get_msg ().c_str ());
82     }
83
84     if (status)
85         return status;
86
87     _notmuch_string_map_set (notmuch->config, key, value);
88
89     return NOTMUCH_STATUS_SUCCESS;
90 }
91
92 static notmuch_status_t
93 _metadata_value (notmuch_database_t *notmuch,
94                  const char *key,
95                  std::string &value)
96 {
97     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
98
99     try {
100         value = notmuch->xapian_db->get_metadata (CONFIG_PREFIX + key);
101     } catch (const Xapian::Error &error) {
102         status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
103         notmuch->exception_reported = true;
104         _notmuch_database_log (notmuch, "Error: A Xapian exception occurred getting metadata: %s\n",
105                                error.get_msg ().c_str ());
106     }
107     return status;
108 }
109
110 notmuch_status_t
111 notmuch_database_get_config (notmuch_database_t *notmuch,
112                              const char *key,
113                              char **value)
114 {
115     const char *stored_val;
116     notmuch_status_t status;
117
118     if (! notmuch->config) {
119         if ((status = _notmuch_config_load_from_database (notmuch)))
120             return status;
121     }
122
123     if (! value)
124         return NOTMUCH_STATUS_NULL_POINTER;
125
126     stored_val = _notmuch_string_map_get (notmuch->config, key);
127     if (! stored_val) {
128         /* XXX in principle this API should be fixed so empty string
129          * is distinguished from not found */
130         *value = strdup ("");
131     } else {
132         *value = strdup (stored_val);
133     }
134
135     return NOTMUCH_STATUS_SUCCESS;
136 }
137
138 notmuch_status_t
139 notmuch_database_get_config_list (notmuch_database_t *notmuch,
140                                   const char *prefix,
141                                   notmuch_config_list_t **out)
142 {
143     notmuch_config_list_t *list = NULL;
144     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
145
146     list = talloc (notmuch, notmuch_config_list_t);
147     if (! list) {
148         status = NOTMUCH_STATUS_OUT_OF_MEMORY;
149         goto DONE;
150     }
151
152     list->notmuch = notmuch;
153     list->current_key = NULL;
154     list->current_val = NULL;
155
156     try {
157
158         new(&(list->iterator)) Xapian::TermIterator (notmuch->xapian_db->metadata_keys_begin
159                                                          (CONFIG_PREFIX + (prefix ? prefix : "")));
160         talloc_set_destructor (list, _notmuch_config_list_destroy);
161
162     } catch (const Xapian::Error &error) {
163         _notmuch_database_log (notmuch,
164                                "A Xapian exception occurred getting metadata iterator: %s.\n",
165                                error.get_msg ().c_str ());
166         notmuch->exception_reported = true;
167         status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
168     }
169
170     *out = list;
171
172   DONE:
173     if (status) {
174         if (list) {
175             talloc_free (list);
176             if (status != NOTMUCH_STATUS_XAPIAN_EXCEPTION)
177                 _notmuch_config_list_destroy (list);
178         }
179     } else {
180         talloc_set_destructor (list, _notmuch_config_list_destroy);
181     }
182
183     return status;
184 }
185
186 notmuch_bool_t
187 notmuch_config_list_valid (notmuch_config_list_t *metadata)
188 {
189     if (metadata->iterator == metadata->notmuch->xapian_db->metadata_keys_end ())
190         return false;
191
192     return true;
193 }
194
195 static inline char *
196 _key_from_iterator (notmuch_config_list_t *list)
197 {
198     return talloc_strdup (list, (*list->iterator).c_str () + CONFIG_PREFIX.length ());
199 }
200
201 const char *
202 notmuch_config_list_key (notmuch_config_list_t *list)
203 {
204     if (list->current_key)
205         talloc_free (list->current_key);
206
207     list->current_key = _key_from_iterator (list);
208
209     return list->current_key;
210 }
211
212 const char *
213 notmuch_config_list_value (notmuch_config_list_t *list)
214 {
215     std::string strval;
216     notmuch_status_t status;
217     char *key = _key_from_iterator (list);
218
219     /* TODO: better error reporting?? */
220     status = _metadata_value (list->notmuch, key, strval);
221     if (status)
222         return NULL;
223
224     if (list->current_val)
225         talloc_free (list->current_val);
226
227     list->current_val = talloc_strdup (list, strval.c_str ());
228     talloc_free (key);
229     return list->current_val;
230 }
231
232 void
233 notmuch_config_list_move_to_next (notmuch_config_list_t *list)
234 {
235     list->iterator++;
236 }
237
238 void
239 notmuch_config_list_destroy (notmuch_config_list_t *list)
240 {
241     talloc_free (list);
242 }
243
244 notmuch_status_t
245 _notmuch_config_load_from_database (notmuch_database_t *notmuch)
246 {
247     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
248     notmuch_config_list_t *list;
249
250     if (notmuch->config == NULL)
251         notmuch->config = _notmuch_string_map_create (notmuch);
252
253     if (unlikely (notmuch->config == NULL))
254         return NOTMUCH_STATUS_OUT_OF_MEMORY;
255
256     status = notmuch_database_get_config_list (notmuch, "", &list);
257     if (status)
258         return status;
259
260     for (; notmuch_config_list_valid (list); notmuch_config_list_move_to_next (list)) {
261         const char *key = notmuch_config_list_key (list);
262         char *normalized_val = NULL;
263
264         /* If we opened from a given path, do not overwrite it */
265         if (strcmp (key, "database.path") == 0 &&
266             (notmuch->params & NOTMUCH_PARAM_DATABASE) &&
267             notmuch->xapian_db)
268             continue;
269
270         normalized_val = _expand_path (list, key, notmuch_config_list_value (list));
271         _notmuch_string_map_append (notmuch->config, key, normalized_val);
272         talloc_free (normalized_val);
273     }
274
275     return status;
276 }
277
278 notmuch_config_values_t *
279 notmuch_config_get_values (notmuch_database_t *notmuch, notmuch_config_key_t key)
280 {
281     const char *key_str = _notmuch_config_key_to_string (key);
282
283     if (! key_str)
284         return NULL;
285
286     return notmuch_config_get_values_string (notmuch, key_str);
287 }
288
289 notmuch_config_values_t *
290 notmuch_config_get_values_string (notmuch_database_t *notmuch, const char *key_str)
291 {
292     notmuch_config_values_t *values = NULL;
293     bool ok = false;
294
295     values = talloc (notmuch, notmuch_config_values_t);
296     if (unlikely (! values))
297         goto DONE;
298
299     values->children = talloc_new (values);
300
301     values->string = _notmuch_string_map_get (notmuch->config, key_str);
302     if (! values->string)
303         goto DONE;
304
305     values->iterator = strsplit_len (values->string, ';', &(values->tok_len));
306     ok = true;
307
308   DONE:
309     if (! ok) {
310         if (values)
311             talloc_free (values);
312         return NULL;
313     }
314     return values;
315 }
316
317 notmuch_bool_t
318 notmuch_config_values_valid (notmuch_config_values_t *values)
319 {
320     if (! values)
321         return false;
322
323     return (values->iterator != NULL);
324 }
325
326 const char *
327 notmuch_config_values_get (notmuch_config_values_t *values)
328 {
329     return talloc_strndup (values->children, values->iterator, values->tok_len);
330 }
331
332 void
333 notmuch_config_values_start (notmuch_config_values_t *values)
334 {
335     if (values == NULL)
336         return;
337     if (values->children) {
338         talloc_free (values->children);
339     }
340
341     values->children = talloc_new (values);
342
343     values->iterator = strsplit_len (values->string, ';', &(values->tok_len));
344 }
345
346 void
347 notmuch_config_values_move_to_next (notmuch_config_values_t *values)
348 {
349     values->iterator += values->tok_len;
350     values->iterator = strsplit_len (values->iterator, ';', &(values->tok_len));
351 }
352
353 void
354 notmuch_config_values_destroy (notmuch_config_values_t *values)
355 {
356     talloc_free (values);
357 }
358
359 notmuch_config_pairs_t *
360 notmuch_config_get_pairs (notmuch_database_t *notmuch,
361                           const char *prefix)
362 {
363     notmuch_config_pairs_t *pairs = talloc (notmuch, notmuch_config_pairs_t);
364
365     pairs->iter = _notmuch_string_map_iterator_create (notmuch->config, prefix, false);
366     return pairs;
367 }
368
369 notmuch_bool_t
370 notmuch_config_pairs_valid (notmuch_config_pairs_t *pairs)
371 {
372     return _notmuch_string_map_iterator_valid (pairs->iter);
373 }
374
375 void
376 notmuch_config_pairs_move_to_next (notmuch_config_pairs_t *pairs)
377 {
378     _notmuch_string_map_iterator_move_to_next (pairs->iter);
379 }
380
381 const char *
382 notmuch_config_pairs_key (notmuch_config_pairs_t *pairs)
383 {
384     return _notmuch_string_map_iterator_key (pairs->iter);
385 }
386
387 const char *
388 notmuch_config_pairs_value (notmuch_config_pairs_t *pairs)
389 {
390     return _notmuch_string_map_iterator_value (pairs->iter);
391 }
392
393 void
394 notmuch_config_pairs_destroy (notmuch_config_pairs_t *pairs)
395 {
396     _notmuch_string_map_iterator_destroy (pairs->iter);
397     talloc_free (pairs);
398 }
399
400 static char *
401 _expand_path (void *ctx, const char *key, const char *val)
402 {
403     char *expanded_val;
404
405     if ((strcmp (key, "database.path") == 0 ||
406          strcmp (key, "database.mail_root") == 0 ||
407          strcmp (key, "database.hook_dir") == 0 ||
408          strcmp (key, "database.backup_path") == 0 ) &&
409         val[0] != '/')
410         expanded_val = talloc_asprintf (ctx, "%s/%s", getenv ("HOME"), val);
411     else
412         expanded_val = talloc_strdup (ctx, val);
413
414     return expanded_val;
415 }
416
417 notmuch_status_t
418 _notmuch_config_load_from_file (notmuch_database_t *notmuch,
419                                 GKeyFile *file)
420 {
421     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
422     gchar **groups = NULL, **keys, *val;
423
424     if (notmuch->config == NULL)
425         notmuch->config = _notmuch_string_map_create (notmuch);
426
427     if (unlikely (notmuch->config == NULL)) {
428         status = NOTMUCH_STATUS_OUT_OF_MEMORY;
429         goto DONE;
430     }
431
432     groups = g_key_file_get_groups (file, NULL);
433     for (gchar **grp = groups; *grp; grp++) {
434         keys = g_key_file_get_keys (file, *grp, NULL, NULL);
435         for (gchar **keys_p = keys; *keys_p; keys_p++) {
436             char *absolute_key = talloc_asprintf (notmuch, "%s.%s", *grp,  *keys_p);
437             char *normalized_val;
438
439             /* If we opened from a given path, do not overwrite it */
440             if (strcmp (absolute_key, "database.path") == 0 &&
441                 (notmuch->params & NOTMUCH_PARAM_DATABASE) &&
442                 notmuch->xapian_db)
443                 continue;
444
445             val = g_key_file_get_string (file, *grp, *keys_p, NULL);
446             if (! val) {
447                 status = NOTMUCH_STATUS_FILE_ERROR;
448                 goto DONE;
449             }
450
451             normalized_val = _expand_path (notmuch, absolute_key, val);
452             _notmuch_string_map_set (notmuch->config, absolute_key, normalized_val);
453             g_free (val);
454             talloc_free (absolute_key);
455             talloc_free (normalized_val);
456             if (status)
457                 goto DONE;
458         }
459         g_strfreev (keys);
460     }
461
462   DONE:
463     if (groups)
464         g_strfreev (groups);
465
466     return status;
467 }
468
469 notmuch_status_t
470 notmuch_config_get_bool (notmuch_database_t *notmuch, notmuch_config_key_t key, notmuch_bool_t *val)
471 {
472     const char *key_string, *val_string;
473
474     key_string = _notmuch_config_key_to_string (key);
475     if (! key_string) {
476         return NOTMUCH_STATUS_ILLEGAL_ARGUMENT;
477     }
478
479     val_string = _notmuch_string_map_get (notmuch->config, key_string);
480     if (! val_string) {
481         *val = FALSE;
482         return NOTMUCH_STATUS_SUCCESS;
483     }
484
485     if (strcase_equal (val_string, "false") || strcase_equal (val_string, "no"))
486         *val = FALSE;
487     else if (strcase_equal (val_string, "true") || strcase_equal (val_string, "yes"))
488         *val = TRUE;
489     else
490         return NOTMUCH_STATUS_ILLEGAL_ARGUMENT;
491
492     return NOTMUCH_STATUS_SUCCESS;
493 }
494
495 static const char *
496 _get_name_from_passwd_file (void *ctx)
497 {
498     long pw_buf_size;
499     char *pw_buf;
500     struct passwd passwd, *ignored;
501     const char *name;
502     int e;
503
504     pw_buf_size = sysconf (_SC_GETPW_R_SIZE_MAX);
505     if (pw_buf_size == -1) pw_buf_size = 64;
506     pw_buf = (char *) talloc_size (ctx, pw_buf_size);
507
508     while ((e = getpwuid_r (getuid (), &passwd, pw_buf,
509                             pw_buf_size, &ignored)) == ERANGE) {
510         pw_buf_size = pw_buf_size * 2;
511         pw_buf = (char *) talloc_zero_size (ctx, pw_buf_size);
512     }
513
514     if (e == 0) {
515         char *comma = strchr (passwd.pw_gecos, ',');
516         if (comma)
517             name = talloc_strndup (ctx, passwd.pw_gecos,
518                                    comma - passwd.pw_gecos);
519         else
520             name = talloc_strdup (ctx, passwd.pw_gecos);
521     } else {
522         name = talloc_strdup (ctx, "");
523     }
524
525     talloc_free (pw_buf);
526
527     return name;
528 }
529
530 static char *
531 _get_username_from_passwd_file (void *ctx)
532 {
533     long pw_buf_size;
534     char *pw_buf;
535     struct passwd passwd, *ignored;
536     char *name;
537     int e;
538
539     pw_buf_size = sysconf (_SC_GETPW_R_SIZE_MAX);
540     if (pw_buf_size == -1) pw_buf_size = 64;
541     pw_buf = (char *) talloc_zero_size (ctx, pw_buf_size);
542
543     while ((e = getpwuid_r (getuid (), &passwd, pw_buf,
544                             pw_buf_size, &ignored)) == ERANGE) {
545         pw_buf_size = pw_buf_size * 2;
546         pw_buf = (char *) talloc_zero_size (ctx, pw_buf_size);
547     }
548
549     if (e == 0)
550         name = talloc_strdup (ctx, passwd.pw_name);
551     else
552         name = talloc_strdup (ctx, "");
553
554     talloc_free (pw_buf);
555
556     return name;
557 }
558
559 static const char *
560 _get_email_from_passwd_file (void *ctx)
561 {
562     char *email;
563
564     char *username = _get_username_from_passwd_file (ctx);
565
566     email = talloc_asprintf (ctx, "%s@localhost", username);
567
568     talloc_free (username);
569     return email;
570 }
571
572 static const char *
573 _notmuch_config_key_to_string (notmuch_config_key_t key)
574 {
575     switch (key) {
576     case NOTMUCH_CONFIG_DATABASE_PATH:
577         return "database.path";
578     case NOTMUCH_CONFIG_MAIL_ROOT:
579         return "database.mail_root";
580     case NOTMUCH_CONFIG_HOOK_DIR:
581         return "database.hook_dir";
582     case NOTMUCH_CONFIG_BACKUP_DIR:
583         return "database.backup_dir";
584     case NOTMUCH_CONFIG_EXCLUDE_TAGS:
585         return "search.exclude_tags";
586     case NOTMUCH_CONFIG_NEW_TAGS:
587         return "new.tags";
588     case NOTMUCH_CONFIG_NEW_IGNORE:
589         return "new.ignore";
590     case NOTMUCH_CONFIG_SYNC_MAILDIR_FLAGS:
591         return "maildir.synchronize_flags";
592     case NOTMUCH_CONFIG_PRIMARY_EMAIL:
593         return "user.primary_email";
594     case NOTMUCH_CONFIG_OTHER_EMAIL:
595         return "user.other_email";
596     case NOTMUCH_CONFIG_USER_NAME:
597         return "user.name";
598     case NOTMUCH_CONFIG_AUTOCOMMIT:
599         return "database.autocommit";
600     case NOTMUCH_CONFIG_EXTRA_HEADERS:
601         return "show.extra_headers";
602     default:
603         return NULL;
604     }
605 }
606
607 static const char *
608 _notmuch_config_default (notmuch_database_t *notmuch, notmuch_config_key_t key)
609 {
610     char *path;
611     const char *name, *email;
612
613     switch (key) {
614     case NOTMUCH_CONFIG_DATABASE_PATH:
615         path = getenv ("MAILDIR");
616         if (path)
617             path = talloc_strdup (notmuch, path);
618         else
619             path = talloc_asprintf (notmuch, "%s/mail",
620                                     getenv ("HOME"));
621         return path;
622     case NOTMUCH_CONFIG_MAIL_ROOT:
623         /* by default, mail root is the same as database path */
624         return notmuch_database_get_path (notmuch);
625     case NOTMUCH_CONFIG_EXCLUDE_TAGS:
626         return "";
627     case NOTMUCH_CONFIG_NEW_TAGS:
628         return "unread;inbox";
629     case NOTMUCH_CONFIG_SYNC_MAILDIR_FLAGS:
630         return "true";
631     case NOTMUCH_CONFIG_USER_NAME:
632         name = getenv ("NAME");
633         if (name)
634             name = talloc_strdup (notmuch, name);
635         else
636             name = _get_name_from_passwd_file (notmuch);
637         return name;
638     case NOTMUCH_CONFIG_PRIMARY_EMAIL:
639         email = getenv ("EMAIL");
640         if (email)
641             email = talloc_strdup (notmuch, email);
642         else
643             email = _get_email_from_passwd_file (notmuch);
644         return email;
645     case NOTMUCH_CONFIG_NEW_IGNORE:
646         return "";
647     case NOTMUCH_CONFIG_AUTOCOMMIT:
648         return "8000";
649     case NOTMUCH_CONFIG_EXTRA_HEADERS:
650     case NOTMUCH_CONFIG_HOOK_DIR:
651     case NOTMUCH_CONFIG_BACKUP_DIR:
652     case NOTMUCH_CONFIG_OTHER_EMAIL:
653         return NULL;
654     default:
655     case NOTMUCH_CONFIG_LAST:
656         INTERNAL_ERROR ("illegal key enum %d", key);
657     }
658 }
659
660 notmuch_status_t
661 _notmuch_config_load_defaults (notmuch_database_t *notmuch)
662 {
663     notmuch_config_key_t key;
664     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
665
666     if (notmuch->config == NULL)
667         notmuch->config = _notmuch_string_map_create (notmuch);
668
669     for (key = NOTMUCH_CONFIG_FIRST;
670          key < NOTMUCH_CONFIG_LAST;
671          key = notmuch_config_key_t (key + 1)) {
672         const char *val = notmuch_config_get (notmuch, key);
673         const char *key_string = _notmuch_config_key_to_string (key);
674
675         val = _notmuch_string_map_get (notmuch->config, key_string);
676         if (! val) {
677             if (key == NOTMUCH_CONFIG_MAIL_ROOT && (notmuch->params & NOTMUCH_PARAM_SPLIT))
678                 status = NOTMUCH_STATUS_NO_MAIL_ROOT;
679
680             _notmuch_string_map_set (notmuch->config, key_string, _notmuch_config_default (notmuch,
681                                                                                            key));
682         }
683     }
684     return status;
685 }
686
687 const char *
688 notmuch_config_get (notmuch_database_t *notmuch, notmuch_config_key_t key)
689 {
690
691     return _notmuch_string_map_get (notmuch->config, _notmuch_config_key_to_string (key));
692 }
693
694 const char *
695 notmuch_config_path (notmuch_database_t *notmuch)
696 {
697     return notmuch->config_path;
698 }
699
700 notmuch_status_t
701 notmuch_config_set (notmuch_database_t *notmuch, notmuch_config_key_t key, const char *val)
702 {
703
704     return notmuch_database_set_config (notmuch, _notmuch_config_key_to_string (key), val);
705 }
706
707 void
708 _notmuch_config_cache (notmuch_database_t *notmuch, notmuch_config_key_t key, const char *val)
709 {
710     if (notmuch->config == NULL)
711         notmuch->config = _notmuch_string_map_create (notmuch);
712
713     _notmuch_string_map_set (notmuch->config, _notmuch_config_key_to_string (key), val);
714 }