X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=lib%2Fopen.cc;h=30cfcf9e6a985728cc4c21024aed70eb72c1cf38;hp=8f572b0b4f5557a43e7ab516edbaf39580e75173;hb=HEAD;hpb=a7873df331bcd53dd1bc8da95c4279163437cc13 diff --git a/lib/open.cc b/lib/open.cc index 8f572b0b..463e38bf 100644 --- a/lib/open.cc +++ b/lib/open.cc @@ -3,6 +3,8 @@ #include "database-private.h" #include "parse-time-vrp.h" +#include "lastmod-fp.h" +#include "path-util.h" #if HAVE_XAPIAN_DB_RETRY_LOCK #define DB_ACTION (Xapian::DB_CREATE_OR_OPEN | Xapian::DB_RETRY_LOCK) @@ -18,9 +20,8 @@ notmuch_database_open (const char *path, char *status_string = NULL; notmuch_status_t status; - status = notmuch_database_open_verbose (path, mode, database, - &status_string); - + status = notmuch_database_open_with_config (path, mode, "", NULL, + database, &status_string); if (status_string) { fputs (status_string, stderr); free (status_string); @@ -113,12 +114,12 @@ _choose_dir (notmuch_database_t *notmuch, } static notmuch_status_t -_load_key_file (const char *path, +_load_key_file (notmuch_database_t *notmuch, + const char *path, const char *profile, GKeyFile **key_file) { notmuch_status_t status = NOTMUCH_STATUS_SUCCESS; - void *local = talloc_new (NULL); if (path && EMPTY_STRING (path)) goto DONE; @@ -126,11 +127,13 @@ _load_key_file (const char *path, if (! path) path = getenv ("NOTMUCH_CONFIG"); - if (! path) { - const char *dir = _xdg_dir (local, "XDG_CONFIG_HOME", ".config", profile); + if (path) + path = talloc_strdup (notmuch, path); + else { + const char *dir = _xdg_dir (notmuch, "XDG_CONFIG_HOME", ".config", profile); if (dir) { - path = talloc_asprintf (local, "%s/config", dir); + path = talloc_asprintf (notmuch, "%s/config", dir); if (access (path, R_OK) != 0) path = NULL; } @@ -139,13 +142,13 @@ _load_key_file (const char *path, if (! path) { const char *home = getenv ("HOME"); - path = talloc_asprintf (local, "%s/.notmuch-config", home); + path = talloc_asprintf (notmuch, "%s/.notmuch-config", home); if (! profile) profile = getenv ("NOTMUCH_PROFILE"); if (profile) - path = talloc_asprintf (local, "%s.%s", path, profile); + path = talloc_asprintf (notmuch, "%s.%s", path, profile); } *key_file = g_key_file_new (); @@ -154,7 +157,9 @@ _load_key_file (const char *path, } DONE: - talloc_free (local); + if (path) + notmuch->config_path = path; + return status; } @@ -182,53 +187,129 @@ _db_dir_exists (const char *database_path, char **message) } static notmuch_status_t -_choose_database_path (void *ctx, - const char *config_path, +_choose_database_path (notmuch_database_t *notmuch, const char *profile, - GKeyFile **key_file, + GKeyFile *key_file, const char **database_path, - bool *split, char **message) { notmuch_status_t status; - status = _load_key_file (config_path, profile, key_file); - if (status) { - *message = strdup ("Error: cannot load config file.\n"); - return status; - } - if (! *database_path) { *database_path = getenv ("NOTMUCH_DATABASE"); } - if (! *database_path && *key_file) { - char *path = g_key_file_get_value (*key_file, "database", "path", NULL); + if (! *database_path && key_file) { + char *path = g_key_file_get_string (key_file, "database", "path", NULL); if (path) { - *database_path = talloc_strdup (ctx, path); + if (path[0] == '/') + *database_path = talloc_strdup (notmuch, path); + else + *database_path = talloc_asprintf (notmuch, "%s/%s", getenv ("HOME"), path); g_free (path); } } + if (! *database_path) { + *database_path = _xdg_dir (notmuch, "XDG_DATA_HOME", ".local/share", profile); + status = _db_dir_exists (*database_path, message); + if (status) { + *database_path = NULL; + } else { + notmuch->params |= NOTMUCH_PARAM_SPLIT; + } + } if (! *database_path) { - *database_path = _xdg_dir (ctx, "XDG_DATA_HOME", ".local/share", profile); - *split = true; + *database_path = getenv ("MAILDIR"); + } + + if (! *database_path) { + *database_path = talloc_asprintf (notmuch, "%s/mail", getenv ("HOME")); + status = _db_dir_exists (*database_path, message); + if (status) { + *database_path = NULL; + } } if (*database_path == NULL) { - *message = strdup ("Error: Cannot open a database for a NULL path.\n"); - return NOTMUCH_STATUS_NULL_POINTER; + *message = strdup ("Error: could not locate database.\n"); + return NOTMUCH_STATUS_NO_DATABASE; + } + + if (*database_path[0] != '/') { + *message = strdup ("Error: Database path must be absolute.\n"); + return NOTMUCH_STATUS_PATH_ERROR; + } + + status = _db_dir_exists (*database_path, message); + if (status) { + IGNORE_RESULT (asprintf (message, + "Error: database path '%s' does not exist or is not a directory.\n", + *database_path)); + return NOTMUCH_STATUS_NO_DATABASE; + } + + if (*message) { + free (*message); + *message = NULL; + } + + return NOTMUCH_STATUS_SUCCESS; +} + +static notmuch_status_t +_mkdir (const char *path, char **message) +{ + if (g_mkdir_with_parents (path, 0755)) { + IGNORE_RESULT (asprintf (message, "Error: Cannot create directory %s: %s.\n", + path, strerror (errno))); + return NOTMUCH_STATUS_FILE_ERROR; + } + return NOTMUCH_STATUS_SUCCESS; +} + +static notmuch_status_t +_create_database_path (notmuch_database_t *notmuch, + const char *profile, + GKeyFile *key_file, + const char **database_path, + char **message) +{ + notmuch_status_t status; + + if (! *database_path) { + *database_path = getenv ("NOTMUCH_DATABASE"); + } + + if (! *database_path && key_file) { + char *path = g_key_file_get_string (key_file, "database", "path", NULL); + if (path) { + if (path[0] == '/') + *database_path = talloc_strdup (notmuch, path); + else + *database_path = talloc_asprintf (notmuch, "%s/%s", getenv ("HOME"), path); + g_free (path); + } + } + + if (! *database_path) { + *database_path = _xdg_dir (notmuch, "XDG_DATA_HOME", ".local/share", profile); + notmuch->params |= NOTMUCH_PARAM_SPLIT; } if (*database_path[0] != '/') { *message = strdup ("Error: Database path must be absolute.\n"); return NOTMUCH_STATUS_PATH_ERROR; } + + if ((status = _mkdir (*database_path, message))) + return status; + return NOTMUCH_STATUS_SUCCESS; } -notmuch_database_t * -_alloc_notmuch () +static notmuch_database_t * +_alloc_notmuch (const char *database_path, const char *config_path, const char *profile) { notmuch_database_t *notmuch; @@ -239,8 +320,22 @@ _alloc_notmuch () notmuch->exception_reported = false; notmuch->status_string = NULL; notmuch->writable_xapian_db = NULL; + notmuch->config_path = NULL; notmuch->atomic_nesting = 0; + notmuch->transaction_count = 0; + notmuch->transaction_threshold = 0; notmuch->view = 1; + notmuch->index_as_text = NULL; + notmuch->index_as_text_length = 0; + + notmuch->params = NOTMUCH_PARAM_NONE; + if (database_path) + notmuch->params |= NOTMUCH_PARAM_DATABASE; + if (config_path) + notmuch->params |= NOTMUCH_PARAM_CONFIG; + if (profile) + notmuch->params |= NOTMUCH_PARAM_PROFILE; + return notmuch; } @@ -280,6 +375,9 @@ _notmuch_choose_xapian_path (void *ctx, const char *database_path, if (status != NOTMUCH_STATUS_PATH_ERROR) goto DONE; + if (*message_ptr) + free (*message_ptr); + notmuch_path = talloc_asprintf (ctx, "%s/.notmuch", database_path); status = _db_dir_exists (notmuch_path, message_ptr); if (status) @@ -306,21 +404,81 @@ _set_database_path (notmuch_database_t *notmuch, } static void -_init_libs () +_load_database_state (notmuch_database_t *notmuch) { + std::string last_thread_id; + std::string last_mod; - static int initialized = 0; + notmuch->last_doc_id = notmuch->xapian_db->get_lastdocid (); + last_thread_id = notmuch->xapian_db->get_metadata ("last_thread_id"); + if (last_thread_id.empty ()) { + notmuch->last_thread_id = 0; + } else { + const char *str; + char *end; - /* Initialize the GLib type system and threads */ -#if ! GLIB_CHECK_VERSION (2, 35, 1) - g_type_init (); -#endif + str = last_thread_id.c_str (); + notmuch->last_thread_id = strtoull (str, &end, 16); + if (*end != '\0') + INTERNAL_ERROR ("Malformed database last_thread_id: %s", str); + } - /* Initialize gmime */ - if (! initialized) { - g_mime_init (); - initialized = 1; + /* Get current highest revision number. */ + last_mod = notmuch->xapian_db->get_value_upper_bound ( + NOTMUCH_VALUE_LAST_MOD); + if (last_mod.empty ()) + notmuch->revision = 0; + else + notmuch->revision = Xapian::sortable_unserialise (last_mod); + notmuch->uuid = talloc_strdup ( + notmuch, notmuch->xapian_db->get_uuid ().c_str ()); +} + +/* XXX This should really be done lazily, but the error reporting path in the indexing code + * would need to be redone to report any errors. + */ +notmuch_status_t +_ensure_index_as_text (notmuch_database_t *notmuch, char **message) +{ + int nregex = 0; + regex_t *regexv = NULL; + + if (notmuch->index_as_text) + return NOTMUCH_STATUS_SUCCESS; + + for (notmuch_config_values_t *list = notmuch_config_get_values (notmuch, + NOTMUCH_CONFIG_INDEX_AS_TEXT); + notmuch_config_values_valid (list); + notmuch_config_values_move_to_next (list)) { + regex_t *new_regex; + int rerr; + const char *str = notmuch_config_values_get (list); + size_t len = strlen (str); + + /* str must be non-empty, because n_c_get_values skips empty + * strings */ + assert (len > 0); + + regexv = talloc_realloc (notmuch, regexv, regex_t, nregex + 1); + new_regex = ®exv[nregex]; + + rerr = regcomp (new_regex, str, REG_EXTENDED | REG_NOSUB); + if (rerr) { + size_t error_size = regerror (rerr, new_regex, NULL, 0); + char *error = (char *) talloc_size (str, error_size); + + regerror (rerr, new_regex, error, error_size); + IGNORE_RESULT (asprintf (message, "Error in index.as_text: %s: %s\n", error, str)); + + return NOTMUCH_STATUS_ILLEGAL_ARGUMENT; + } + nregex++; } + + notmuch->index_as_text = regexv; + notmuch->index_as_text_length = nregex; + + return NOTMUCH_STATUS_SUCCESS; } static notmuch_status_t @@ -333,12 +491,12 @@ _finish_open (notmuch_database_t *notmuch, notmuch_status_t status = NOTMUCH_STATUS_SUCCESS; char *incompat_features; char *message = NULL; + const char *autocommit_str; + char *autocommit_end; unsigned int version; const char *database_path = notmuch_database_get_path (notmuch); try { - std::string last_thread_id; - std::string last_mod; if (mode == NOTMUCH_DATABASE_MODE_READ_WRITE) { notmuch->writable_xapian_db = new Xapian::WritableDatabase (notmuch->xapian_path, @@ -358,8 +516,6 @@ _finish_open (notmuch_database_t *notmuch, " has a newer database format version (%u) than supported by this\n" " version of notmuch (%u).\n", database_path, version, NOTMUCH_DATABASE_VERSION)); - notmuch_database_destroy (notmuch); - notmuch = NULL; status = NOTMUCH_STATUS_FILE_ERROR; goto DONE; } @@ -376,35 +532,11 @@ _finish_open (notmuch_database_t *notmuch, " requires features (%s)\n" " not supported by this version of notmuch.\n", database_path, incompat_features)); - notmuch_database_destroy (notmuch); - notmuch = NULL; status = NOTMUCH_STATUS_FILE_ERROR; goto DONE; } - notmuch->last_doc_id = notmuch->xapian_db->get_lastdocid (); - last_thread_id = notmuch->xapian_db->get_metadata ("last_thread_id"); - if (last_thread_id.empty ()) { - notmuch->last_thread_id = 0; - } else { - const char *str; - char *end; - - str = last_thread_id.c_str (); - notmuch->last_thread_id = strtoull (str, &end, 16); - if (*end != '\0') - INTERNAL_ERROR ("Malformed database last_thread_id: %s", str); - } - - /* Get current highest revision number. */ - last_mod = notmuch->xapian_db->get_value_upper_bound ( - NOTMUCH_VALUE_LAST_MOD); - if (last_mod.empty ()) - notmuch->revision = 0; - else - notmuch->revision = Xapian::sortable_unserialise (last_mod); - notmuch->uuid = talloc_strdup ( - notmuch, notmuch->xapian_db->get_uuid ().c_str ()); + _load_database_state (notmuch); notmuch->query_parser = new Xapian::QueryParser; notmuch->term_gen = new Xapian::TermGenerator; @@ -412,11 +544,11 @@ _finish_open (notmuch_database_t *notmuch, notmuch->value_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_TIMESTAMP); notmuch->date_range_processor = new ParseTimeRangeProcessor (NOTMUCH_VALUE_TIMESTAMP, "date:"); - notmuch->last_mod_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_LAST_MOD, - "lastmod:"); + notmuch->last_mod_range_processor = new LastModRangeProcessor (notmuch, "lastmod:"); notmuch->query_parser->set_default_op (Xapian::Query::OP_AND); notmuch->query_parser->set_database (*notmuch->xapian_db); - notmuch->query_parser->set_stemmer (Xapian::Stem ("english")); + notmuch->stemmer = new Xapian::Stem ("english"); + notmuch->query_parser->set_stemmer (*notmuch->stemmer); notmuch->query_parser->set_stemming_strategy (Xapian::QueryParser::STEM_SOME); notmuch->query_parser->add_rangeprocessor (notmuch->value_range_processor); notmuch->query_parser->add_rangeprocessor (notmuch->date_range_processor); @@ -428,7 +560,7 @@ _finish_open (notmuch_database_t *notmuch, goto DONE; if (key_file) - status = _notmuch_config_load_from_file (notmuch, key_file); + status = _notmuch_config_load_from_file (notmuch, key_file, &message); if (status) goto DONE; @@ -453,6 +585,18 @@ _finish_open (notmuch_database_t *notmuch, if (status) goto DONE; + status = _ensure_index_as_text (notmuch, &message); + if (status) + goto DONE; + + autocommit_str = notmuch_config_get (notmuch, NOTMUCH_CONFIG_AUTOCOMMIT); + if (unlikely (! autocommit_str)) { + INTERNAL_ERROR ("missing configuration for autocommit"); + } + notmuch->transaction_threshold = strtoul (autocommit_str, &autocommit_end, 10); + if (*autocommit_end != '\0') + INTERNAL_ERROR ("Malformed database database.autocommit value: %s", autocommit_str); + status = _notmuch_database_setup_standard_query_fields (notmuch); if (status) goto DONE; @@ -464,8 +608,6 @@ _finish_open (notmuch_database_t *notmuch, } catch (const Xapian::Error &error) { IGNORE_RESULT (asprintf (&message, "A Xapian exception occurred opening database: %s\n", error.get_msg ().c_str ())); - notmuch_database_destroy (notmuch); - notmuch = NULL; status = NOTMUCH_STATUS_XAPIAN_EXCEPTION; } DONE: @@ -483,22 +625,26 @@ notmuch_database_open_with_config (const char *database_path, char **status_string) { notmuch_status_t status = NOTMUCH_STATUS_SUCCESS; - void *local = talloc_new (NULL); notmuch_database_t *notmuch = NULL; char *message = NULL; GKeyFile *key_file = NULL; - bool split = false; - _init_libs (); + _notmuch_init (); - notmuch = _alloc_notmuch (); + notmuch = _alloc_notmuch (database_path, config_path, profile); if (! notmuch) { status = NOTMUCH_STATUS_OUT_OF_MEMORY; goto DONE; } - if ((status = _choose_database_path (local, config_path, profile, - &key_file, &database_path, &split, + status = _load_key_file (notmuch, config_path, profile, &key_file); + if (status) { + message = strdup ("Error: cannot load config file.\n"); + goto DONE; + } + + if ((status = _choose_database_path (notmuch, profile, key_file, + &database_path, &message))) goto DONE; @@ -516,8 +662,6 @@ notmuch_database_open_with_config (const char *database_path, status = _finish_open (notmuch, profile, mode, key_file, &message); DONE: - talloc_free (local); - if (key_file) g_key_file_free (key_file); @@ -528,10 +672,13 @@ notmuch_database_open_with_config (const char *database_path, free (message); } + if (status && notmuch) { + notmuch_database_destroy (notmuch); + notmuch = NULL; + } + if (database) *database = notmuch; - else - talloc_free (notmuch); if (notmuch) notmuch->open = true; @@ -576,63 +723,60 @@ notmuch_database_create_with_config (const char *database_path, const char *notmuch_path = NULL; char *message = NULL; GKeyFile *key_file = NULL; - void *local = talloc_new (NULL); - int err; - bool split = false; - _init_libs (); + _notmuch_init (); - notmuch = _alloc_notmuch (); + notmuch = _alloc_notmuch (database_path, config_path, profile); if (! notmuch) { status = NOTMUCH_STATUS_OUT_OF_MEMORY; goto DONE; } - _init_libs (); - - if ((status = _choose_database_path (local, config_path, profile, - &key_file, &database_path, &split, - &message))) + status = _load_key_file (notmuch, config_path, profile, &key_file); + if (status) { + message = strdup ("Error: cannot load config file.\n"); goto DONE; + } - status = _db_dir_exists (database_path, &message); - if (status) + status = _choose_database_path (notmuch, profile, key_file, + &database_path, &message); + switch (status) { + case NOTMUCH_STATUS_SUCCESS: + break; + case NOTMUCH_STATUS_NO_DATABASE: + if ((status = _create_database_path (notmuch, profile, key_file, + &database_path, &message))) + goto DONE; + break; + default: goto DONE; + } _set_database_path (notmuch, database_path); - if (key_file && ! split) { - char *mail_root = canonicalize_file_name ( - g_key_file_get_value (key_file, "database", "mail_root", NULL)); - char *db_path = canonicalize_file_name (database_path); + if (key_file && ! (notmuch->params & NOTMUCH_PARAM_SPLIT)) { + char *mail_root = notmuch_canonicalize_file_name ( + g_key_file_get_string (key_file, "database", "mail_root", NULL)); + char *db_path = notmuch_canonicalize_file_name (database_path); - split = (mail_root && (0 != strcmp (mail_root, db_path))); + if (mail_root && (0 != strcmp (mail_root, db_path))) + notmuch->params |= NOTMUCH_PARAM_SPLIT; free (mail_root); free (db_path); } - if (split) { + if (notmuch->params & NOTMUCH_PARAM_SPLIT) { notmuch_path = database_path; } else { - if (! (notmuch_path = talloc_asprintf (local, "%s/%s", database_path, ".notmuch"))) { + if (! (notmuch_path = talloc_asprintf (notmuch, "%s/%s", database_path, ".notmuch"))) { status = NOTMUCH_STATUS_OUT_OF_MEMORY; goto DONE; } - err = mkdir (notmuch_path, 0755); - if (err) { - if (errno == EEXIST) { - status = NOTMUCH_STATUS_DATABASE_EXISTS; - talloc_free (notmuch); - notmuch = NULL; - } else { - IGNORE_RESULT (asprintf (&message, "Error: Cannot create directory %s: %s.\n", - notmuch_path, strerror (errno))); - status = NOTMUCH_STATUS_FILE_ERROR; - } + status = _mkdir (notmuch_path, &message); + if (status) goto DONE; - } } if (! (notmuch->xapian_path = talloc_asprintf (notmuch, "%s/%s", notmuch_path, "xapian"))) { @@ -648,6 +792,9 @@ notmuch_database_create_with_config (const char *database_path, goto DONE; } + if (message) + free (message); + status = _finish_open (notmuch, profile, NOTMUCH_DATABASE_MODE_READ_WRITE, @@ -669,8 +816,6 @@ notmuch_database_create_with_config (const char *database_path, } DONE: - talloc_free (local); - if (key_file) g_key_file_free (key_file); @@ -680,10 +825,16 @@ notmuch_database_create_with_config (const char *database_path, else free (message); } + if (status && notmuch) { + notmuch_database_destroy (notmuch); + notmuch = NULL; + } + if (database) *database = notmuch; - else - talloc_free (notmuch); + + if (notmuch) + notmuch->open = true; return status; } @@ -719,6 +870,8 @@ notmuch_database_reopen (notmuch_database_t *notmuch, DB_ACTION); } } + + _load_database_state (notmuch); } catch (const Xapian::Error &error) { if (! notmuch->exception_reported) { _notmuch_database_log (notmuch, "Error: A Xapian exception reopening database: %s\n", @@ -732,3 +885,111 @@ notmuch_database_reopen (notmuch_database_t *notmuch, notmuch->open = true; return NOTMUCH_STATUS_SUCCESS; } + +static notmuch_status_t +_maybe_load_config_from_database (notmuch_database_t *notmuch, + GKeyFile *key_file, + const char *database_path, + const char *profile) +{ + char *message; /* ignored */ + + if (_db_dir_exists (database_path, &message)) + return NOTMUCH_STATUS_NO_DATABASE; + + _set_database_path (notmuch, database_path); + + if (_notmuch_choose_xapian_path (notmuch, database_path, ¬much->xapian_path, &message)) + return NOTMUCH_STATUS_NO_DATABASE; + + (void) _finish_open (notmuch, profile, NOTMUCH_DATABASE_MODE_READ_ONLY, key_file, &message); + + return NOTMUCH_STATUS_SUCCESS; +} + +notmuch_status_t +notmuch_database_load_config (const char *database_path, + const char *config_path, + const char *profile, + notmuch_database_t **database, + char **status_string) +{ + notmuch_status_t status = NOTMUCH_STATUS_SUCCESS, warning = NOTMUCH_STATUS_SUCCESS; + notmuch_database_t *notmuch = NULL; + char *message = NULL; + GKeyFile *key_file = NULL; + + _notmuch_init (); + + notmuch = _alloc_notmuch (database_path, config_path, profile); + if (! notmuch) { + status = NOTMUCH_STATUS_OUT_OF_MEMORY; + goto DONE; + } + + status = _load_key_file (notmuch, config_path, profile, &key_file); + switch (status) { + case NOTMUCH_STATUS_SUCCESS: + break; + case NOTMUCH_STATUS_NO_CONFIG: + warning = status; + break; + default: + message = strdup ("Error: cannot load config file.\n"); + goto DONE; + } + + status = _choose_database_path (notmuch, profile, key_file, + &database_path, &message); + switch (status) { + case NOTMUCH_STATUS_NO_DATABASE: + case NOTMUCH_STATUS_SUCCESS: + if (! warning) + warning = status; + break; + default: + goto DONE; + } + + + if (database_path) { + status = _maybe_load_config_from_database (notmuch, key_file, database_path, profile); + switch (status) { + case NOTMUCH_STATUS_NO_DATABASE: + case NOTMUCH_STATUS_SUCCESS: + if (! warning) + warning = status; + break; + default: + goto DONE; + } + } + + if (key_file) { + status = _notmuch_config_load_from_file (notmuch, key_file, &message); + if (status) + goto DONE; + } + status = _notmuch_config_load_defaults (notmuch); + if (status) + goto DONE; + + DONE: + if (status_string) + *status_string = message; + + if (status && + status != NOTMUCH_STATUS_NO_DATABASE + && status != NOTMUCH_STATUS_NO_CONFIG) { + notmuch_database_destroy (notmuch); + notmuch = NULL; + } + + if (database) + *database = notmuch; + + if (status) + return status; + else + return warning; +}