]> git.cworth.org Git - notmuch-old/blob - lib/config.cc
003ce6795c16602b6ed8173e48e14b04c5ae69b1
[notmuch-old] / 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             val = g_key_file_get_string (file, *grp, *keys_p, NULL);
439             if (! val) {
440                 status = NOTMUCH_STATUS_FILE_ERROR;
441                 goto DONE;
442             }
443
444             /* If we opened from a given path, do not overwrite it */
445             if (strcmp (absolute_key, "database.path") == 0 &&
446                 (notmuch->params & NOTMUCH_PARAM_DATABASE) &&
447                 notmuch->xapian_db)
448                 continue;
449
450             normalized_val = _expand_path (notmuch, absolute_key, val);
451             _notmuch_string_map_set (notmuch->config, absolute_key, normalized_val);
452             g_free (val);
453             talloc_free (absolute_key);
454             talloc_free (normalized_val);
455             if (status)
456                 goto DONE;
457         }
458         g_strfreev (keys);
459     }
460
461   DONE:
462     if (groups)
463         g_strfreev (groups);
464
465     return status;
466 }
467
468 notmuch_status_t
469 notmuch_config_get_bool (notmuch_database_t *notmuch, notmuch_config_key_t key, notmuch_bool_t *val)
470 {
471     const char *key_string, *val_string;
472
473     key_string = _notmuch_config_key_to_string (key);
474     if (! key_string) {
475         return NOTMUCH_STATUS_ILLEGAL_ARGUMENT;
476     }
477
478     val_string = _notmuch_string_map_get (notmuch->config, key_string);
479     if (! val_string) {
480         *val = FALSE;
481         return NOTMUCH_STATUS_SUCCESS;
482     }
483
484     if (strcase_equal (val_string, "false") || strcase_equal (val_string, "no"))
485         *val = FALSE;
486     else if (strcase_equal (val_string, "true") || strcase_equal (val_string, "yes"))
487         *val = TRUE;
488     else
489         return NOTMUCH_STATUS_ILLEGAL_ARGUMENT;
490
491     return NOTMUCH_STATUS_SUCCESS;
492 }
493
494 static const char *
495 _get_name_from_passwd_file (void *ctx)
496 {
497     long pw_buf_size;
498     char *pw_buf;
499     struct passwd passwd, *ignored;
500     const char *name;
501     int e;
502
503     pw_buf_size = sysconf (_SC_GETPW_R_SIZE_MAX);
504     if (pw_buf_size == -1) pw_buf_size = 64;
505     pw_buf = (char *) talloc_size (ctx, pw_buf_size);
506
507     while ((e = getpwuid_r (getuid (), &passwd, pw_buf,
508                             pw_buf_size, &ignored)) == ERANGE) {
509         pw_buf_size = pw_buf_size * 2;
510         pw_buf = (char *) talloc_zero_size (ctx, pw_buf_size);
511     }
512
513     if (e == 0) {
514         char *comma = strchr (passwd.pw_gecos, ',');
515         if (comma)
516             name = talloc_strndup (ctx, passwd.pw_gecos,
517                                    comma - passwd.pw_gecos);
518         else
519             name = talloc_strdup (ctx, passwd.pw_gecos);
520     } else {
521         name = talloc_strdup (ctx, "");
522     }
523
524     talloc_free (pw_buf);
525
526     return name;
527 }
528
529 static char *
530 _get_username_from_passwd_file (void *ctx)
531 {
532     long pw_buf_size;
533     char *pw_buf;
534     struct passwd passwd, *ignored;
535     char *name;
536     int e;
537
538     pw_buf_size = sysconf (_SC_GETPW_R_SIZE_MAX);
539     if (pw_buf_size == -1) pw_buf_size = 64;
540     pw_buf = (char *) talloc_zero_size (ctx, pw_buf_size);
541
542     while ((e = getpwuid_r (getuid (), &passwd, pw_buf,
543                             pw_buf_size, &ignored)) == ERANGE) {
544         pw_buf_size = pw_buf_size * 2;
545         pw_buf = (char *) talloc_zero_size (ctx, pw_buf_size);
546     }
547
548     if (e == 0)
549         name = talloc_strdup (ctx, passwd.pw_name);
550     else
551         name = talloc_strdup (ctx, "");
552
553     talloc_free (pw_buf);
554
555     return name;
556 }
557
558 static const char *
559 _get_email_from_passwd_file (void *ctx)
560 {
561     char *email;
562
563     char *username = _get_username_from_passwd_file (ctx);
564
565     email = talloc_asprintf (ctx, "%s@localhost", username);
566
567     talloc_free (username);
568     return email;
569 }
570
571 static const char *
572 _notmuch_config_key_to_string (notmuch_config_key_t key)
573 {
574     switch (key) {
575     case NOTMUCH_CONFIG_DATABASE_PATH:
576         return "database.path";
577     case NOTMUCH_CONFIG_MAIL_ROOT:
578         return "database.mail_root";
579     case NOTMUCH_CONFIG_HOOK_DIR:
580         return "database.hook_dir";
581     case NOTMUCH_CONFIG_BACKUP_DIR:
582         return "database.backup_dir";
583     case NOTMUCH_CONFIG_EXCLUDE_TAGS:
584         return "search.exclude_tags";
585     case NOTMUCH_CONFIG_NEW_TAGS:
586         return "new.tags";
587     case NOTMUCH_CONFIG_NEW_IGNORE:
588         return "new.ignore";
589     case NOTMUCH_CONFIG_SYNC_MAILDIR_FLAGS:
590         return "maildir.synchronize_flags";
591     case NOTMUCH_CONFIG_PRIMARY_EMAIL:
592         return "user.primary_email";
593     case NOTMUCH_CONFIG_OTHER_EMAIL:
594         return "user.other_email";
595     case NOTMUCH_CONFIG_USER_NAME:
596         return "user.name";
597     case NOTMUCH_CONFIG_AUTOCOMMIT:
598         return "database.autocommit";
599     case NOTMUCH_CONFIG_EXTRA_HEADERS:
600         return "show.extra_headers";
601     default:
602         return NULL;
603     }
604 }
605
606 static const char *
607 _notmuch_config_default (notmuch_database_t *notmuch, notmuch_config_key_t key)
608 {
609     char *path;
610     const char *name, *email;
611
612     switch (key) {
613     case NOTMUCH_CONFIG_DATABASE_PATH:
614         path = getenv ("MAILDIR");
615         if (path)
616             path = talloc_strdup (notmuch, path);
617         else
618             path = talloc_asprintf (notmuch, "%s/mail",
619                                     getenv ("HOME"));
620         return path;
621     case NOTMUCH_CONFIG_MAIL_ROOT:
622         /* by default, mail root is the same as database path */
623         return notmuch_database_get_path (notmuch);
624     case NOTMUCH_CONFIG_EXCLUDE_TAGS:
625         return "";
626     case NOTMUCH_CONFIG_NEW_TAGS:
627         return "unread;inbox";
628     case NOTMUCH_CONFIG_SYNC_MAILDIR_FLAGS:
629         return "true";
630     case NOTMUCH_CONFIG_USER_NAME:
631         name = getenv ("NAME");
632         if (name)
633             name = talloc_strdup (notmuch, name);
634         else
635             name = _get_name_from_passwd_file (notmuch);
636         return name;
637     case NOTMUCH_CONFIG_PRIMARY_EMAIL:
638         email = getenv ("EMAIL");
639         if (email)
640             email = talloc_strdup (notmuch, email);
641         else
642             email = _get_email_from_passwd_file (notmuch);
643         return email;
644     case NOTMUCH_CONFIG_NEW_IGNORE:
645         return "";
646     case NOTMUCH_CONFIG_AUTOCOMMIT:
647         return "8000";
648     case NOTMUCH_CONFIG_EXTRA_HEADERS:
649     case NOTMUCH_CONFIG_HOOK_DIR:
650     case NOTMUCH_CONFIG_BACKUP_DIR:
651     case NOTMUCH_CONFIG_OTHER_EMAIL:
652         return NULL;
653     default:
654     case NOTMUCH_CONFIG_LAST:
655         INTERNAL_ERROR ("illegal key enum %d", key);
656     }
657 }
658
659 notmuch_status_t
660 _notmuch_config_load_defaults (notmuch_database_t *notmuch)
661 {
662     notmuch_config_key_t key;
663     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
664
665     if (notmuch->config == NULL)
666         notmuch->config = _notmuch_string_map_create (notmuch);
667
668     for (key = NOTMUCH_CONFIG_FIRST;
669          key < NOTMUCH_CONFIG_LAST;
670          key = notmuch_config_key_t (key + 1)) {
671         const char *val = notmuch_config_get (notmuch, key);
672         const char *key_string = _notmuch_config_key_to_string (key);
673
674         val = _notmuch_string_map_get (notmuch->config, key_string);
675         if (! val) {
676             if (key == NOTMUCH_CONFIG_MAIL_ROOT && (notmuch->params & NOTMUCH_PARAM_SPLIT))
677                 status = NOTMUCH_STATUS_NO_MAIL_ROOT;
678
679             _notmuch_string_map_set (notmuch->config, key_string, _notmuch_config_default (notmuch,
680                                                                                            key));
681         }
682     }
683     return status;
684 }
685
686 const char *
687 notmuch_config_get (notmuch_database_t *notmuch, notmuch_config_key_t key)
688 {
689
690     return _notmuch_string_map_get (notmuch->config, _notmuch_config_key_to_string (key));
691 }
692
693 const char *
694 notmuch_config_path (notmuch_database_t *notmuch)
695 {
696     return notmuch->config_path;
697 }
698
699 notmuch_status_t
700 notmuch_config_set (notmuch_database_t *notmuch, notmuch_config_key_t key, const char *val)
701 {
702
703     return notmuch_database_set_config (notmuch, _notmuch_config_key_to_string (key), val);
704 }
705
706 void
707 _notmuch_config_cache (notmuch_database_t *notmuch, notmuch_config_key_t key, const char *val)
708 {
709     if (notmuch->config == NULL)
710         notmuch->config = _notmuch_string_map_create (notmuch);
711
712     _notmuch_string_map_set (notmuch->config, _notmuch_config_key_to_string (key), val);
713 }