]> git.cworth.org Git - notmuch/blob - lib/open.cc
2d9c4365b2d38e3d60fee2364813a1f8f12c761f
[notmuch] / lib / open.cc
1 #include <unistd.h>
2 #include "database-private.h"
3 #include "parse-time-vrp.h"
4
5 #if HAVE_XAPIAN_DB_RETRY_LOCK
6 #define DB_ACTION (Xapian::DB_CREATE_OR_OPEN | Xapian::DB_RETRY_LOCK)
7 #else
8 #define DB_ACTION Xapian::DB_CREATE_OR_OPEN
9 #endif
10
11 notmuch_status_t
12 notmuch_database_open (const char *path,
13                        notmuch_database_mode_t mode,
14                        notmuch_database_t **database)
15 {
16     char *status_string = NULL;
17     notmuch_status_t status;
18
19     status = notmuch_database_open_verbose (path, mode, database,
20                                             &status_string);
21
22     if (status_string) {
23         fputs (status_string, stderr);
24         free (status_string);
25     }
26
27     return status;
28 }
29
30 notmuch_status_t
31 notmuch_database_open_verbose (const char *path,
32                                notmuch_database_mode_t mode,
33                                notmuch_database_t **database,
34                                char **status_string)
35 {
36     return notmuch_database_open_with_config (path, mode, "", NULL,
37                                               database, status_string);
38 }
39
40 static const char *
41 _xdg_dir (void *ctx,
42           const char *xdg_root_variable,
43           const char *xdg_prefix,
44           const char *profile_name)
45 {
46     const char *xdg_root = getenv (xdg_root_variable);
47
48     if (! xdg_root) {
49         const char *home = getenv ("HOME");
50
51         if (! home) return NULL;
52
53         xdg_root = talloc_asprintf (ctx,
54                                     "%s/%s",
55                                     home,
56                                     xdg_prefix);
57     }
58
59     if (! profile_name)
60         profile_name = getenv ("NOTMUCH_PROFILE");
61
62     if (! profile_name)
63         profile_name = "default";
64
65     return talloc_asprintf (ctx,
66                             "%s/notmuch/%s",
67                             xdg_root,
68                             profile_name);
69 }
70
71 static notmuch_status_t
72 _load_key_file (const char *path,
73                 const char *profile,
74                 GKeyFile **key_file)
75 {
76     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
77     void *local = talloc_new (NULL);
78
79     if (path && EMPTY_STRING (path))
80         goto DONE;
81
82     if (! path)
83         path = getenv ("NOTMUCH_CONFIG");
84
85     if (! path) {
86         const char *dir = _xdg_dir (local, "XDG_CONFIG_HOME", ".config", profile);
87
88         if (dir) {
89             path = talloc_asprintf (local, "%s/config", dir);
90             if (access (path, R_OK) !=0)
91                 path = NULL;
92         }
93     }
94
95     if (! path) {
96         const char *home = getenv ("HOME");
97
98         path = talloc_asprintf (local, "%s/.notmuch-config", home);
99
100         if (! profile)
101             profile = getenv ("NOTMUCH_PROFILE");
102
103         if (profile)
104             path = talloc_asprintf (local, "%s.%s", path, profile);
105     }
106
107     *key_file = g_key_file_new ();
108     if (! g_key_file_load_from_file (*key_file, path, G_KEY_FILE_NONE, NULL)) {
109         status = NOTMUCH_STATUS_FILE_ERROR;
110     }
111
112 DONE:
113     talloc_free (local);
114     return status;
115 }
116
117 notmuch_status_t
118 notmuch_database_open_with_config (const char *database_path,
119                                    notmuch_database_mode_t mode,
120                                    const char *config_path,
121                                    unused(const char *profile),
122                                    notmuch_database_t **database,
123                                    char **status_string)
124 {
125     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
126     void *local = talloc_new (NULL);
127     notmuch_database_t *notmuch = NULL;
128     char *notmuch_path, *xapian_path, *incompat_features;
129     char *message = NULL;
130     struct stat st;
131     int err;
132     unsigned int version;
133     GKeyFile *key_file = NULL;
134     static int initialized = 0;
135
136     status = _load_key_file (config_path, profile, &key_file);
137     if (status) {
138         message = strdup ("Error: cannot load config file");
139         goto DONE;
140     }
141         
142     if (! database_path && key_file)
143         database_path = g_key_file_get_value (key_file, "database", "path", NULL);
144
145     if (database_path == NULL) {
146         message = strdup ("Error: Cannot open a database for a NULL path.\n");
147         status = NOTMUCH_STATUS_NULL_POINTER;
148         goto DONE;
149     }
150
151     if (database_path[0] != '/') {
152         message = strdup ("Error: Database path must be absolute.\n");
153         status = NOTMUCH_STATUS_PATH_ERROR;
154         goto DONE;
155     }
156
157     if (! (notmuch_path = talloc_asprintf (local, "%s/%s", database_path, ".notmuch"))) {
158         message = strdup ("Out of memory\n");
159         status = NOTMUCH_STATUS_OUT_OF_MEMORY;
160         goto DONE;
161     }
162
163     err = stat (notmuch_path, &st);
164     if (err) {
165         IGNORE_RESULT (asprintf (&message, "Error opening database at %s: %s\n",
166                                  notmuch_path, strerror (errno)));
167         status = NOTMUCH_STATUS_FILE_ERROR;
168         goto DONE;
169     }
170
171     if (! (xapian_path = talloc_asprintf (local, "%s/%s", notmuch_path, "xapian"))) {
172         message = strdup ("Out of memory\n");
173         status = NOTMUCH_STATUS_OUT_OF_MEMORY;
174         goto DONE;
175     }
176
177     /* Initialize the GLib type system and threads */
178 #if ! GLIB_CHECK_VERSION (2, 35, 1)
179     g_type_init ();
180 #endif
181
182     /* Initialize gmime */
183     if (! initialized) {
184         g_mime_init ();
185         initialized = 1;
186     }
187
188     notmuch = talloc_zero (NULL, notmuch_database_t);
189     notmuch->exception_reported = false;
190     notmuch->status_string = NULL;
191     notmuch->path = talloc_strdup (notmuch, database_path);
192
193     strip_trailing (notmuch->path, '/');
194
195     notmuch->writable_xapian_db = NULL;
196     notmuch->atomic_nesting = 0;
197     notmuch->view = 1;
198     try {
199         std::string last_thread_id;
200         std::string last_mod;
201
202         if (mode == NOTMUCH_DATABASE_MODE_READ_WRITE) {
203             notmuch->writable_xapian_db = new Xapian::WritableDatabase (xapian_path,
204                                                                         DB_ACTION);
205             notmuch->xapian_db = notmuch->writable_xapian_db;
206         } else {
207             notmuch->xapian_db = new Xapian::Database (xapian_path);
208         }
209
210         /* Check version.  As of database version 3, we represent
211          * changes in terms of features, so assume a version bump
212          * means a dramatically incompatible change. */
213         version = notmuch_database_get_version (notmuch);
214         if (version > NOTMUCH_DATABASE_VERSION) {
215             IGNORE_RESULT (asprintf (&message,
216                                      "Error: Notmuch database at %s\n"
217                                      "       has a newer database format version (%u) than supported by this\n"
218                                      "       version of notmuch (%u).\n",
219                                      notmuch_path, version, NOTMUCH_DATABASE_VERSION));
220             notmuch_database_destroy (notmuch);
221             notmuch = NULL;
222             status = NOTMUCH_STATUS_FILE_ERROR;
223             goto DONE;
224         }
225
226         /* Check features. */
227         incompat_features = NULL;
228         notmuch->features = _notmuch_database_parse_features (
229             local, notmuch->xapian_db->get_metadata ("features").c_str (),
230             version, mode == NOTMUCH_DATABASE_MODE_READ_WRITE ? 'w' : 'r',
231             &incompat_features);
232         if (incompat_features) {
233             IGNORE_RESULT (asprintf (&message,
234                                      "Error: Notmuch database at %s\n"
235                                      "       requires features (%s)\n"
236                                      "       not supported by this version of notmuch.\n",
237                                      notmuch_path, incompat_features));
238             notmuch_database_destroy (notmuch);
239             notmuch = NULL;
240             status = NOTMUCH_STATUS_FILE_ERROR;
241             goto DONE;
242         }
243
244         notmuch->last_doc_id = notmuch->xapian_db->get_lastdocid ();
245         last_thread_id = notmuch->xapian_db->get_metadata ("last_thread_id");
246         if (last_thread_id.empty ()) {
247             notmuch->last_thread_id = 0;
248         } else {
249             const char *str;
250             char *end;
251
252             str = last_thread_id.c_str ();
253             notmuch->last_thread_id = strtoull (str, &end, 16);
254             if (*end != '\0')
255                 INTERNAL_ERROR ("Malformed database last_thread_id: %s", str);
256         }
257
258         /* Get current highest revision number. */
259         last_mod = notmuch->xapian_db->get_value_upper_bound (
260             NOTMUCH_VALUE_LAST_MOD);
261         if (last_mod.empty ())
262             notmuch->revision = 0;
263         else
264             notmuch->revision = Xapian::sortable_unserialise (last_mod);
265         notmuch->uuid = talloc_strdup (
266             notmuch, notmuch->xapian_db->get_uuid ().c_str ());
267
268         notmuch->query_parser = new Xapian::QueryParser;
269         notmuch->term_gen = new Xapian::TermGenerator;
270         notmuch->term_gen->set_stemmer (Xapian::Stem ("english"));
271         notmuch->value_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_TIMESTAMP);
272         notmuch->date_range_processor = new ParseTimeRangeProcessor (NOTMUCH_VALUE_TIMESTAMP, "date:");
273         notmuch->last_mod_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_LAST_MOD, "lastmod:");
274         notmuch->query_parser->set_default_op (Xapian::Query::OP_AND);
275         notmuch->query_parser->set_database (*notmuch->xapian_db);
276         notmuch->query_parser->set_stemmer (Xapian::Stem ("english"));
277         notmuch->query_parser->set_stemming_strategy (Xapian::QueryParser::STEM_SOME);
278         notmuch->query_parser->add_rangeprocessor (notmuch->value_range_processor);
279         notmuch->query_parser->add_rangeprocessor (notmuch->date_range_processor);
280         notmuch->query_parser->add_rangeprocessor (notmuch->last_mod_range_processor);
281
282         /* Configuration information is needed to set up query parser */
283         status = _notmuch_config_load_from_database (notmuch);
284         if (status)
285             goto DONE;
286
287         if (key_file)
288             status = _notmuch_config_load_from_file (notmuch, key_file);
289         if (status)
290             goto DONE;
291
292         status = _notmuch_database_setup_standard_query_fields (notmuch);
293         if (status)
294             goto DONE;
295
296         status = _notmuch_database_setup_user_query_fields (notmuch);
297         if (status)
298             goto DONE;
299
300     } catch (const Xapian::Error &error) {
301         IGNORE_RESULT (asprintf (&message, "A Xapian exception occurred opening database: %s\n",
302                                  error.get_msg ().c_str ()));
303         notmuch_database_destroy (notmuch);
304         notmuch = NULL;
305         status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
306     }
307
308   DONE:
309     talloc_free (local);
310
311     if (message) {
312         if (status_string)
313             *status_string = message;
314         else
315             free (message);
316     }
317
318     if (database)
319         *database = notmuch;
320     else
321         talloc_free (notmuch);
322
323     if (notmuch)
324         notmuch->open = true;
325
326     return status;
327 }