2016-03-22 11:54:47 +01:00
|
|
|
/* config.cc - API for database metadata
|
|
|
|
*
|
|
|
|
* Copyright © 2016 David Bremner
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2016-06-02 18:26:14 +02:00
|
|
|
* along with this program. If not, see https://www.gnu.org/licenses/ .
|
2016-03-22 11:54:47 +01:00
|
|
|
*
|
|
|
|
* Author: David Bremner <david@tethera.net>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "notmuch.h"
|
|
|
|
#include "notmuch-private.h"
|
|
|
|
#include "database-private.h"
|
|
|
|
|
|
|
|
static const std::string CONFIG_PREFIX = "C";
|
|
|
|
|
2016-03-22 11:54:48 +01:00
|
|
|
struct _notmuch_config_list {
|
|
|
|
notmuch_database_t *notmuch;
|
|
|
|
Xapian::TermIterator iterator;
|
|
|
|
char *current_key;
|
|
|
|
char *current_val;
|
|
|
|
};
|
|
|
|
|
2020-08-08 16:16:49 +02:00
|
|
|
struct _notmuch_config_values {
|
|
|
|
const char *iterator;
|
|
|
|
size_t tok_len;
|
2021-01-01 14:28:24 +01:00
|
|
|
const char *string;
|
|
|
|
void *children; /* talloc_context */
|
2020-08-08 16:16:49 +02:00
|
|
|
};
|
|
|
|
|
2021-03-13 13:45:34 +01:00
|
|
|
static const char *_notmuch_config_key_to_string (notmuch_config_key_t key);
|
2020-12-24 21:10:05 +01:00
|
|
|
|
2016-03-22 11:54:48 +01:00
|
|
|
static int
|
|
|
|
_notmuch_config_list_destroy (notmuch_config_list_t *list)
|
|
|
|
{
|
|
|
|
/* invoke destructor w/o deallocating memory */
|
|
|
|
list->iterator.~TermIterator();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-03-22 11:54:47 +01:00
|
|
|
notmuch_status_t
|
|
|
|
notmuch_database_set_config (notmuch_database_t *notmuch,
|
|
|
|
const char *key,
|
|
|
|
const char *value)
|
|
|
|
{
|
|
|
|
notmuch_status_t status;
|
|
|
|
|
|
|
|
status = _notmuch_database_ensure_writable (notmuch);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
2020-08-08 16:16:37 +02:00
|
|
|
if (! notmuch->config) {
|
|
|
|
if ((status = _notmuch_config_load_from_database (notmuch)))
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2016-03-22 11:54:47 +01:00
|
|
|
try {
|
2020-07-27 01:31:36 +02:00
|
|
|
notmuch->writable_xapian_db->set_metadata (CONFIG_PREFIX + key, value);
|
2016-03-22 11:54:47 +01:00
|
|
|
} catch (const Xapian::Error &error) {
|
|
|
|
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
|
2017-10-07 10:44:05 +02:00
|
|
|
notmuch->exception_reported = true;
|
2016-03-22 11:54:47 +01:00
|
|
|
_notmuch_database_log (notmuch, "Error: A Xapian exception occurred setting metadata: %s\n",
|
2019-06-13 12:55:35 +02:00
|
|
|
error.get_msg ().c_str ());
|
2016-03-22 11:54:47 +01:00
|
|
|
}
|
2020-08-08 16:16:37 +02:00
|
|
|
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
_notmuch_string_map_set (notmuch->config, key, value);
|
|
|
|
|
|
|
|
return NOTMUCH_STATUS_SUCCESS;
|
2016-03-22 11:54:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static notmuch_status_t
|
|
|
|
_metadata_value (notmuch_database_t *notmuch,
|
|
|
|
const char *key,
|
|
|
|
std::string &value)
|
|
|
|
{
|
|
|
|
notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
|
|
|
|
|
|
|
|
try {
|
|
|
|
value = notmuch->xapian_db->get_metadata (CONFIG_PREFIX + key);
|
|
|
|
} catch (const Xapian::Error &error) {
|
|
|
|
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
|
2017-10-07 10:44:05 +02:00
|
|
|
notmuch->exception_reported = true;
|
2016-03-22 11:54:47 +01:00
|
|
|
_notmuch_database_log (notmuch, "Error: A Xapian exception occurred getting metadata: %s\n",
|
2019-06-13 12:55:35 +02:00
|
|
|
error.get_msg ().c_str ());
|
2016-03-22 11:54:47 +01:00
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
notmuch_status_t
|
|
|
|
notmuch_database_get_config (notmuch_database_t *notmuch,
|
|
|
|
const char *key,
|
|
|
|
char **value)
|
|
|
|
{
|
2021-03-13 13:45:34 +01:00
|
|
|
const char *stored_val;
|
2016-03-22 11:54:47 +01:00
|
|
|
notmuch_status_t status;
|
|
|
|
|
2020-08-08 16:16:37 +02:00
|
|
|
if (! notmuch->config) {
|
|
|
|
if ((status = _notmuch_config_load_from_database (notmuch)))
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2016-03-22 11:54:47 +01:00
|
|
|
if (! value)
|
|
|
|
return NOTMUCH_STATUS_NULL_POINTER;
|
|
|
|
|
2020-08-08 16:16:37 +02:00
|
|
|
stored_val = _notmuch_string_map_get (notmuch->config, key);
|
|
|
|
if (! stored_val) {
|
|
|
|
/* XXX in principle this API should be fixed so empty string
|
|
|
|
* is distinguished from not found */
|
2021-03-13 13:45:34 +01:00
|
|
|
*value = strdup ("");
|
2020-08-08 16:16:37 +02:00
|
|
|
} else {
|
|
|
|
*value = strdup (stored_val);
|
|
|
|
}
|
2016-03-22 11:54:47 +01:00
|
|
|
|
|
|
|
return NOTMUCH_STATUS_SUCCESS;
|
|
|
|
}
|
2016-03-22 11:54:48 +01:00
|
|
|
|
|
|
|
notmuch_status_t
|
|
|
|
notmuch_database_get_config_list (notmuch_database_t *notmuch,
|
|
|
|
const char *prefix,
|
|
|
|
notmuch_config_list_t **out)
|
|
|
|
{
|
|
|
|
notmuch_config_list_t *list = NULL;
|
|
|
|
notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
|
|
|
|
|
|
|
|
list = talloc (notmuch, notmuch_config_list_t);
|
|
|
|
if (! list) {
|
|
|
|
status = NOTMUCH_STATUS_OUT_OF_MEMORY;
|
|
|
|
goto DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
list->notmuch = notmuch;
|
|
|
|
list->current_key = NULL;
|
|
|
|
list->current_val = NULL;
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
|
|
|
new(&(list->iterator)) Xapian::TermIterator (notmuch->xapian_db->metadata_keys_begin
|
2019-06-13 12:55:35 +02:00
|
|
|
(CONFIG_PREFIX + (prefix ? prefix : "")));
|
2020-10-30 01:13:01 +01:00
|
|
|
talloc_set_destructor (list, _notmuch_config_list_destroy);
|
2016-03-22 11:54:48 +01:00
|
|
|
|
|
|
|
} catch (const Xapian::Error &error) {
|
2021-03-13 13:45:34 +01:00
|
|
|
_notmuch_database_log (notmuch,
|
|
|
|
"A Xapian exception occurred getting metadata iterator: %s.\n",
|
2019-06-13 12:55:35 +02:00
|
|
|
error.get_msg ().c_str ());
|
2017-10-07 10:44:05 +02:00
|
|
|
notmuch->exception_reported = true;
|
2016-03-22 11:54:48 +01:00
|
|
|
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
|
|
|
|
}
|
|
|
|
|
|
|
|
*out = list;
|
|
|
|
|
|
|
|
DONE:
|
2020-08-08 16:16:47 +02:00
|
|
|
if (status) {
|
|
|
|
if (list) {
|
|
|
|
talloc_free (list);
|
|
|
|
if (status != NOTMUCH_STATUS_XAPIAN_EXCEPTION)
|
|
|
|
_notmuch_config_list_destroy (list);
|
|
|
|
}
|
2021-03-13 13:45:34 +01:00
|
|
|
} else {
|
2020-08-08 16:16:47 +02:00
|
|
|
talloc_set_destructor (list, _notmuch_config_list_destroy);
|
|
|
|
}
|
2016-03-22 11:54:48 +01:00
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
notmuch_bool_t
|
|
|
|
notmuch_config_list_valid (notmuch_config_list_t *metadata)
|
|
|
|
{
|
|
|
|
if (metadata->iterator == metadata->notmuch->xapian_db->metadata_keys_end ())
|
2017-10-07 10:44:05 +02:00
|
|
|
return false;
|
2016-03-22 11:54:48 +01:00
|
|
|
|
2017-10-07 10:44:05 +02:00
|
|
|
return true;
|
2016-03-22 11:54:48 +01:00
|
|
|
}
|
|
|
|
|
2021-03-13 13:45:34 +01:00
|
|
|
static inline char *
|
|
|
|
_key_from_iterator (notmuch_config_list_t *list)
|
|
|
|
{
|
2019-11-25 03:31:34 +01:00
|
|
|
return talloc_strdup (list, (*list->iterator).c_str () + CONFIG_PREFIX.length ());
|
|
|
|
}
|
|
|
|
|
2016-03-22 11:54:48 +01:00
|
|
|
const char *
|
|
|
|
notmuch_config_list_key (notmuch_config_list_t *list)
|
|
|
|
{
|
|
|
|
if (list->current_key)
|
|
|
|
talloc_free (list->current_key);
|
|
|
|
|
2019-11-25 03:31:34 +01:00
|
|
|
list->current_key = _key_from_iterator (list);
|
2016-03-22 11:54:48 +01:00
|
|
|
|
|
|
|
return list->current_key;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
notmuch_config_list_value (notmuch_config_list_t *list)
|
|
|
|
{
|
|
|
|
std::string strval;
|
|
|
|
notmuch_status_t status;
|
2019-11-25 03:31:34 +01:00
|
|
|
char *key = _key_from_iterator (list);
|
2016-03-22 11:54:48 +01:00
|
|
|
|
|
|
|
/* TODO: better error reporting?? */
|
|
|
|
status = _metadata_value (list->notmuch, key, strval);
|
|
|
|
if (status)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (list->current_val)
|
|
|
|
talloc_free (list->current_val);
|
|
|
|
|
|
|
|
list->current_val = talloc_strdup (list, strval.c_str ());
|
2019-11-25 03:31:34 +01:00
|
|
|
talloc_free (key);
|
2016-03-22 11:54:48 +01:00
|
|
|
return list->current_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
notmuch_config_list_move_to_next (notmuch_config_list_t *list)
|
|
|
|
{
|
|
|
|
list->iterator++;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
notmuch_config_list_destroy (notmuch_config_list_t *list)
|
|
|
|
{
|
|
|
|
talloc_free (list);
|
|
|
|
}
|
2020-08-08 16:16:37 +02:00
|
|
|
|
|
|
|
notmuch_status_t
|
|
|
|
_notmuch_config_load_from_database (notmuch_database_t *notmuch)
|
|
|
|
{
|
|
|
|
notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
|
|
|
|
notmuch_config_list_t *list;
|
|
|
|
|
|
|
|
if (notmuch->config == NULL)
|
|
|
|
notmuch->config = _notmuch_string_map_create (notmuch);
|
|
|
|
|
2021-03-13 13:45:34 +01:00
|
|
|
if (unlikely (notmuch->config == NULL))
|
2020-08-08 16:16:37 +02:00
|
|
|
return NOTMUCH_STATUS_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
status = notmuch_database_get_config_list (notmuch, "", &list);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
for (; notmuch_config_list_valid (list); notmuch_config_list_move_to_next (list)) {
|
|
|
|
_notmuch_string_map_append (notmuch->config,
|
|
|
|
notmuch_config_list_key (list),
|
|
|
|
notmuch_config_list_value (list));
|
|
|
|
}
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
2020-08-08 16:16:36 +02:00
|
|
|
|
2020-08-08 16:16:49 +02:00
|
|
|
notmuch_config_values_t *
|
|
|
|
notmuch_config_get_values (notmuch_database_t *notmuch, notmuch_config_key_t key)
|
|
|
|
{
|
2021-01-01 14:28:24 +01:00
|
|
|
notmuch_config_values_t *values = NULL;
|
|
|
|
bool ok = false;
|
2020-08-08 16:16:49 +02:00
|
|
|
|
|
|
|
const char *key_str = _notmuch_config_key_to_string (key);
|
|
|
|
|
|
|
|
if (! key_str)
|
2021-01-01 14:28:24 +01:00
|
|
|
goto DONE;
|
2020-08-08 16:16:49 +02:00
|
|
|
|
|
|
|
values = talloc (notmuch, notmuch_config_values_t);
|
2021-03-13 13:45:34 +01:00
|
|
|
if (unlikely (! values))
|
2021-01-01 14:28:24 +01:00
|
|
|
goto DONE;
|
|
|
|
|
|
|
|
values->children = talloc_new (values);
|
|
|
|
|
|
|
|
values->string = _notmuch_string_map_get (notmuch->config, key_str);
|
|
|
|
if (! values->string)
|
|
|
|
goto DONE;
|
2020-08-08 16:16:49 +02:00
|
|
|
|
2021-01-01 14:28:24 +01:00
|
|
|
values->iterator = strsplit_len (values->string, ';', &(values->tok_len));
|
|
|
|
ok = true;
|
|
|
|
|
2021-03-13 13:45:34 +01:00
|
|
|
DONE:
|
|
|
|
if (! ok) {
|
2021-01-01 14:28:24 +01:00
|
|
|
if (values)
|
2021-03-13 13:45:34 +01:00
|
|
|
talloc_free (values);
|
2021-01-01 14:28:24 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2020-08-08 16:16:49 +02:00
|
|
|
return values;
|
|
|
|
}
|
|
|
|
|
|
|
|
notmuch_bool_t
|
2021-03-13 13:45:34 +01:00
|
|
|
notmuch_config_values_valid (notmuch_config_values_t *values)
|
|
|
|
{
|
2020-08-08 16:16:49 +02:00
|
|
|
if (! values)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return (values->iterator != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
2021-03-13 13:45:34 +01:00
|
|
|
notmuch_config_values_get (notmuch_config_values_t *values)
|
|
|
|
{
|
2020-08-08 16:16:49 +02:00
|
|
|
return talloc_strndup (values, values->iterator, values->tok_len);
|
|
|
|
}
|
|
|
|
|
2021-01-01 14:28:24 +01:00
|
|
|
void
|
2021-03-13 13:45:34 +01:00
|
|
|
notmuch_config_values_start (notmuch_config_values_t *values)
|
|
|
|
{
|
2021-01-01 14:28:24 +01:00
|
|
|
if (values == NULL)
|
|
|
|
return;
|
|
|
|
if (values->children) {
|
|
|
|
talloc_free (values->children);
|
|
|
|
}
|
|
|
|
|
|
|
|
values->children = talloc_new (values);
|
|
|
|
|
|
|
|
values->iterator = strsplit_len (values->string, ';', &(values->tok_len));
|
|
|
|
}
|
|
|
|
|
2020-08-08 16:16:49 +02:00
|
|
|
void
|
2021-03-13 13:45:34 +01:00
|
|
|
notmuch_config_values_move_to_next (notmuch_config_values_t *values)
|
|
|
|
{
|
2020-08-08 16:16:49 +02:00
|
|
|
values->iterator += values->tok_len;
|
|
|
|
values->iterator = strsplit_len (values->iterator, ';', &(values->tok_len));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2021-03-13 13:45:34 +01:00
|
|
|
notmuch_config_values_destroy (notmuch_config_values_t *values)
|
|
|
|
{
|
2020-08-08 16:16:49 +02:00
|
|
|
talloc_free (values);
|
|
|
|
}
|
|
|
|
|
2020-08-08 16:16:36 +02:00
|
|
|
notmuch_status_t
|
|
|
|
_notmuch_config_load_from_file (notmuch_database_t *notmuch,
|
|
|
|
GKeyFile *file)
|
|
|
|
{
|
|
|
|
notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
|
2021-03-06 14:49:33 +01:00
|
|
|
gchar **groups = NULL, **keys, *val;
|
2020-08-08 16:16:36 +02:00
|
|
|
|
|
|
|
if (notmuch->config == NULL)
|
|
|
|
notmuch->config = _notmuch_string_map_create (notmuch);
|
|
|
|
|
2021-03-13 13:45:34 +01:00
|
|
|
if (unlikely (notmuch->config == NULL)) {
|
2020-08-08 16:16:36 +02:00
|
|
|
status = NOTMUCH_STATUS_OUT_OF_MEMORY;
|
|
|
|
goto DONE;
|
|
|
|
}
|
|
|
|
|
2021-03-06 14:49:33 +01:00
|
|
|
groups = g_key_file_get_groups (file, NULL);
|
|
|
|
for (gchar **grp = groups; *grp; grp++) {
|
|
|
|
keys = g_key_file_get_keys (file, *grp, NULL, NULL);
|
|
|
|
for (gchar **keys_p = keys; *keys_p; keys_p++) {
|
|
|
|
char *absolute_key = talloc_asprintf (notmuch, "%s.%s", *grp, *keys_p);
|
|
|
|
val = g_key_file_get_value (file, *grp, *keys_p, NULL);
|
2020-08-08 16:16:36 +02:00
|
|
|
if (! val) {
|
|
|
|
status = NOTMUCH_STATUS_FILE_ERROR;
|
|
|
|
goto DONE;
|
|
|
|
}
|
|
|
|
_notmuch_string_map_set (notmuch->config, absolute_key, val);
|
2021-03-06 14:49:33 +01:00
|
|
|
g_free (val);
|
2020-08-08 16:16:36 +02:00
|
|
|
talloc_free (absolute_key);
|
|
|
|
if (status)
|
|
|
|
goto DONE;
|
|
|
|
}
|
2021-03-06 14:49:33 +01:00
|
|
|
g_strfreev (keys);
|
2020-08-08 16:16:36 +02:00
|
|
|
}
|
|
|
|
|
2021-03-13 13:45:34 +01:00
|
|
|
DONE:
|
2021-03-06 14:49:33 +01:00
|
|
|
if (groups)
|
|
|
|
g_strfreev (groups);
|
|
|
|
|
2020-08-08 16:16:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
2020-08-26 03:36:43 +02:00
|
|
|
|
2020-08-26 13:41:48 +02:00
|
|
|
notmuch_status_t
|
|
|
|
notmuch_config_get_bool (notmuch_database_t *notmuch, notmuch_config_key_t key, notmuch_bool_t *val)
|
|
|
|
{
|
|
|
|
const char *key_string, *val_string;
|
|
|
|
|
|
|
|
key_string = _notmuch_config_key_to_string (key);
|
|
|
|
if (! key_string) {
|
|
|
|
return NOTMUCH_STATUS_ILLEGAL_ARGUMENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
val_string = _notmuch_string_map_get (notmuch->config, key_string);
|
|
|
|
if (! val_string) {
|
|
|
|
*val = FALSE;
|
|
|
|
return NOTMUCH_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcase_equal (val_string, "false") || strcase_equal (val_string, "no"))
|
|
|
|
*val = FALSE;
|
|
|
|
else if (strcase_equal (val_string, "true") || strcase_equal (val_string, "yes"))
|
|
|
|
*val = TRUE;
|
|
|
|
else
|
|
|
|
return NOTMUCH_STATUS_ILLEGAL_ARGUMENT;
|
|
|
|
|
|
|
|
return NOTMUCH_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2020-12-24 21:10:05 +01:00
|
|
|
static const char *
|
2021-03-13 13:45:34 +01:00
|
|
|
_notmuch_config_key_to_string (notmuch_config_key_t key)
|
|
|
|
{
|
2020-08-26 03:36:43 +02:00
|
|
|
switch (key) {
|
|
|
|
case NOTMUCH_CONFIG_DATABASE_PATH:
|
|
|
|
return "database.path";
|
2020-12-31 23:20:31 +01:00
|
|
|
case NOTMUCH_CONFIG_MAIL_ROOT:
|
|
|
|
return "database.mail_root";
|
2021-01-09 14:19:50 +01:00
|
|
|
case NOTMUCH_CONFIG_HOOK_DIR:
|
|
|
|
return "database.hook_dir";
|
2020-08-26 03:36:43 +02:00
|
|
|
case NOTMUCH_CONFIG_EXCLUDE_TAGS:
|
|
|
|
return "search.exclude_tags";
|
|
|
|
case NOTMUCH_CONFIG_NEW_TAGS:
|
|
|
|
return "new.tags";
|
2021-01-01 14:01:24 +01:00
|
|
|
case NOTMUCH_CONFIG_NEW_IGNORE:
|
|
|
|
return "new.ignore";
|
2020-08-26 03:36:43 +02:00
|
|
|
case NOTMUCH_CONFIG_SYNC_MAILDIR_FLAGS:
|
|
|
|
return "maildir.synchronize_flags";
|
|
|
|
case NOTMUCH_CONFIG_PRIMARY_EMAIL:
|
|
|
|
return "user.primary_email";
|
|
|
|
case NOTMUCH_CONFIG_OTHER_EMAIL:
|
|
|
|
return "user.other_email";
|
|
|
|
case NOTMUCH_CONFIG_USER_NAME:
|
|
|
|
return "user.name";
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-24 21:10:05 +01:00
|
|
|
static const char *
|
2020-12-31 23:20:31 +01:00
|
|
|
_notmuch_config_default (notmuch_database_t *notmuch, notmuch_config_key_t key)
|
2021-03-13 13:45:34 +01:00
|
|
|
{
|
2020-12-24 21:10:05 +01:00
|
|
|
char *path;
|
|
|
|
|
|
|
|
switch (key) {
|
|
|
|
case NOTMUCH_CONFIG_DATABASE_PATH:
|
|
|
|
path = getenv ("MAILDIR");
|
|
|
|
if (path)
|
2020-12-31 23:20:31 +01:00
|
|
|
path = talloc_strdup (notmuch, path);
|
2020-12-24 21:10:05 +01:00
|
|
|
else
|
2020-12-31 23:20:31 +01:00
|
|
|
path = talloc_asprintf (notmuch, "%s/mail",
|
2020-12-24 21:10:05 +01:00
|
|
|
getenv ("HOME"));
|
|
|
|
return path;
|
2020-12-31 23:20:31 +01:00
|
|
|
case NOTMUCH_CONFIG_MAIL_ROOT:
|
|
|
|
/* by default, mail root is the same as database path */
|
|
|
|
return notmuch_database_get_path (notmuch);
|
2020-12-24 21:10:05 +01:00
|
|
|
case NOTMUCH_CONFIG_EXCLUDE_TAGS:
|
|
|
|
return "";
|
|
|
|
case NOTMUCH_CONFIG_NEW_TAGS:
|
|
|
|
return "inbox;unread";
|
|
|
|
case NOTMUCH_CONFIG_SYNC_MAILDIR_FLAGS:
|
|
|
|
return "true";
|
2021-01-09 14:19:50 +01:00
|
|
|
case NOTMUCH_CONFIG_HOOK_DIR:
|
2021-01-01 14:01:24 +01:00
|
|
|
case NOTMUCH_CONFIG_NEW_IGNORE:
|
2020-12-24 21:10:05 +01:00
|
|
|
case NOTMUCH_CONFIG_USER_NAME:
|
|
|
|
case NOTMUCH_CONFIG_PRIMARY_EMAIL:
|
|
|
|
case NOTMUCH_CONFIG_OTHER_EMAIL:
|
|
|
|
return NULL;
|
|
|
|
default:
|
|
|
|
case NOTMUCH_CONFIG_LAST:
|
|
|
|
INTERNAL_ERROR ("illegal key enum %d", key);
|
2021-03-13 13:45:34 +01:00
|
|
|
}
|
2020-12-24 21:10:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
notmuch_status_t
|
2021-03-13 13:45:34 +01:00
|
|
|
_notmuch_config_load_defaults (notmuch_database_t *notmuch)
|
|
|
|
{
|
2020-12-24 21:10:05 +01:00
|
|
|
notmuch_config_key_t key;
|
2021-03-13 13:45:34 +01:00
|
|
|
|
2020-12-24 21:10:05 +01:00
|
|
|
for (key = NOTMUCH_CONFIG_FIRST;
|
|
|
|
key < NOTMUCH_CONFIG_LAST;
|
2021-03-13 13:45:34 +01:00
|
|
|
key = notmuch_config_key_t (key + 1)) {
|
2020-12-24 21:10:05 +01:00
|
|
|
const char *val = notmuch_config_get (notmuch, key);
|
|
|
|
const char *key_string = _notmuch_config_key_to_string (key);
|
|
|
|
|
|
|
|
val = _notmuch_string_map_get (notmuch->config, key_string);
|
|
|
|
if (! val) {
|
2021-03-13 13:45:34 +01:00
|
|
|
_notmuch_string_map_set (notmuch->config, key_string, _notmuch_config_default (notmuch,
|
|
|
|
key));
|
2020-12-24 21:10:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return NOTMUCH_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2020-08-26 03:36:43 +02:00
|
|
|
const char *
|
2021-03-13 13:45:34 +01:00
|
|
|
notmuch_config_get (notmuch_database_t *notmuch, notmuch_config_key_t key)
|
|
|
|
{
|
2020-08-26 03:36:43 +02:00
|
|
|
|
|
|
|
return _notmuch_string_map_get (notmuch->config, _notmuch_config_key_to_string (key));
|
|
|
|
}
|
|
|
|
|
|
|
|
notmuch_status_t
|
2021-03-13 13:45:34 +01:00
|
|
|
notmuch_config_set (notmuch_database_t *notmuch, notmuch_config_key_t key, const char *val)
|
|
|
|
{
|
2020-08-26 03:36:43 +02:00
|
|
|
|
|
|
|
return notmuch_database_set_config (notmuch, _notmuch_config_key_to_string (key), val);
|
|
|
|
}
|
2020-12-24 04:35:42 +01:00
|
|
|
|
|
|
|
void
|
2021-03-13 13:45:34 +01:00
|
|
|
_notmuch_config_cache (notmuch_database_t *notmuch, notmuch_config_key_t key, const char *val)
|
|
|
|
{
|
2021-02-02 21:43:58 +01:00
|
|
|
if (notmuch->config == NULL)
|
|
|
|
notmuch->config = _notmuch_string_map_create (notmuch);
|
|
|
|
|
2020-12-24 04:35:42 +01:00
|
|
|
_notmuch_string_map_set (notmuch->config, _notmuch_config_key_to_string (key), val);
|
|
|
|
}
|