lib: Return an error from operations that require an upgrade
[notmuch] / lib / database.cc
1 /* database.cc - The database interfaces of the notmuch mail library
2  *
3  * Copyright © 2009 Carl Worth
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 http://www.gnu.org/licenses/ .
17  *
18  * Author: Carl Worth <cworth@cworth.org>
19  */
20
21 #include "database-private.h"
22 #include "parse-time-vrp.h"
23 #include "string-util.h"
24
25 #include <iostream>
26
27 #include <sys/time.h>
28 #include <sys/stat.h>
29 #include <signal.h>
30 #include <ftw.h>
31
32 #include <glib.h> /* g_free, GPtrArray, GHashTable */
33 #include <glib-object.h> /* g_type_init */
34
35 #include <gmime/gmime.h> /* g_mime_init */
36
37 using namespace std;
38
39 #define ARRAY_SIZE(arr) (sizeof (arr) / sizeof (arr[0]))
40
41 typedef struct {
42     const char *name;
43     const char *prefix;
44 } prefix_t;
45
46 #define NOTMUCH_DATABASE_VERSION 3
47
48 #define STRINGIFY(s) _SUB_STRINGIFY(s)
49 #define _SUB_STRINGIFY(s) #s
50
51 /* Here's the current schema for our database (for NOTMUCH_DATABASE_VERSION):
52  *
53  * We currently have two different types of documents (mail and
54  * directory) and also some metadata.
55  *
56  * Mail document
57  * -------------
58  * A mail document is associated with a particular email message. It
59  * is stored in one or more files on disk (though only one has its
60  * content indexed) and is uniquely identified  by its "id" field
61  * (which is generally the message ID). It is indexed with the
62  * following prefixed terms which the database uses to construct
63  * threads, etc.:
64  *
65  *    Single terms of given prefix:
66  *
67  *      type:   mail
68  *
69  *      id:     Unique ID of mail. This is from the Message-ID header
70  *              if present and not too long (see NOTMUCH_MESSAGE_ID_MAX).
71  *              If it's present and too long, then we use
72  *              "notmuch-sha1-<sha1_sum_of_message_id>".
73  *              If this header is not present, we use
74  *              "notmuch-sha1-<sha1_sum_of_entire_file>".
75  *
76  *      thread: The ID of the thread to which the mail belongs
77  *
78  *      replyto: The ID from the In-Reply-To header of the mail (if any).
79  *
80  *    Multiple terms of given prefix:
81  *
82  *      reference: All message IDs from In-Reply-To and References
83  *                 headers in the message.
84  *
85  *      tag:       Any tags associated with this message by the user.
86  *
87  *      file-direntry:  A colon-separated pair of values
88  *                      (INTEGER:STRING), where INTEGER is the
89  *                      document ID of a directory document, and
90  *                      STRING is the name of a file within that
91  *                      directory for this mail message.
92  *
93  *    A mail document also has four values:
94  *
95  *      TIMESTAMP:      The time_t value corresponding to the message's
96  *                      Date header.
97  *
98  *      MESSAGE_ID:     The unique ID of the mail mess (see "id" above)
99  *
100  *      FROM:           The value of the "From" header
101  *
102  *      SUBJECT:        The value of the "Subject" header
103  *
104  * In addition, terms from the content of the message are added with
105  * "from", "to", "attachment", and "subject" prefixes for use by the
106  * user in searching. Similarly, terms from the path of the mail
107  * message are added with "folder" and "path" prefixes. But the
108  * database doesn't really care itself about any of these.
109  *
110  * The data portion of a mail document is empty.
111  *
112  * Directory document
113  * ------------------
114  * A directory document is used by a client of the notmuch library to
115  * maintain data necessary to allow for efficient polling of mail
116  * directories.
117  *
118  * All directory documents contain one term:
119  *
120  *      directory:      The directory path (relative to the database path)
121  *                      Or the SHA1 sum of the directory path (if the
122  *                      path itself is too long to fit in a Xapian
123  *                      term).
124  *
125  * And all directory documents for directories other than top-level
126  * directories also contain the following term:
127  *
128  *      directory-direntry: A colon-separated pair of values
129  *                          (INTEGER:STRING), where INTEGER is the
130  *                          document ID of the parent directory
131  *                          document, and STRING is the name of this
132  *                          directory within that parent.
133  *
134  * All directory documents have a single value:
135  *
136  *      TIMESTAMP:      The mtime of the directory (at last scan)
137  *
138  * The data portion of a directory document contains the path of the
139  * directory (relative to the database path).
140  *
141  * Database metadata
142  * -----------------
143  * Xapian allows us to store arbitrary name-value pairs as
144  * "metadata". We currently use the following metadata names with the
145  * given meanings:
146  *
147  *      version         The database schema version, (which is distinct
148  *                      from both the notmuch package version (see
149  *                      notmuch --version) and the libnotmuch library
150  *                      version. The version is stored as an base-10
151  *                      ASCII integer. The initial database version
152  *                      was 1, (though a schema existed before that
153  *                      were no "version" database value existed at
154  *                      all). Successive versions are allocated as
155  *                      changes are made to the database (such as by
156  *                      indexing new fields).
157  *
158  *      features        The set of features supported by this
159  *                      database. This consists of a set of
160  *                      '\n'-separated lines, where each is a feature
161  *                      name, a '\t', and compatibility flags.  If the
162  *                      compatibility flags contain 'w', then the
163  *                      opener must support this feature to safely
164  *                      write this database.  If the compatibility
165  *                      flags contain 'r', then the opener must
166  *                      support this feature to read this database.
167  *                      Introduced in database version 3.
168  *
169  *      last_thread_id  The last thread ID generated. This is stored
170  *                      as a 16-byte hexadecimal ASCII representation
171  *                      of a 64-bit unsigned integer. The first ID
172  *                      generated is 1 and the value will be
173  *                      incremented for each thread ID.
174  *
175  *      thread_id_*     A pre-allocated thread ID for a particular
176  *                      message. This is actually an arbitrarily large
177  *                      family of metadata name. Any particular name is
178  *                      formed by concatenating "thread_id_" with a message
179  *                      ID (or the SHA1 sum of a message ID if it is very
180  *                      long---see description of 'id' in the mail
181  *                      document). The value stored is a thread ID.
182  *
183  *                      These thread ID metadata values are stored
184  *                      whenever a message references a parent message
185  *                      that does not yet exist in the database. A
186  *                      thread ID will be allocated and stored, and if
187  *                      the message is later added, the stored thread
188  *                      ID will be used (and the metadata value will
189  *                      be cleared).
190  *
191  *                      Even before a message is added, it's
192  *                      pre-allocated thread ID is useful so that all
193  *                      descendant messages that reference this common
194  *                      parent can be recognized as belonging to the
195  *                      same thread.
196  */
197
198 /* With these prefix values we follow the conventions published here:
199  *
200  * http://xapian.org/docs/omega/termprefixes.html
201  *
202  * as much as makes sense. Note that I took some liberty in matching
203  * the reserved prefix values to notmuch concepts, (for example, 'G'
204  * is documented as "newsGroup (or similar entity - e.g. a web forum
205  * name)", for which I think the thread is the closest analogue in
206  * notmuch. This in spite of the fact that we will eventually be
207  * storing mailing-list messages where 'G' for "mailing list name"
208  * might be even a closer analogue. I'm treating the single-character
209  * prefixes preferentially for core notmuch concepts (which will be
210  * nearly universal to all mail messages).
211  */
212
213 static prefix_t BOOLEAN_PREFIX_INTERNAL[] = {
214     { "type",                   "T" },
215     { "reference",              "XREFERENCE" },
216     { "replyto",                "XREPLYTO" },
217     { "directory",              "XDIRECTORY" },
218     { "file-direntry",          "XFDIRENTRY" },
219     { "directory-direntry",     "XDDIRENTRY" },
220 };
221
222 static prefix_t BOOLEAN_PREFIX_EXTERNAL[] = {
223     { "thread",                 "G" },
224     { "tag",                    "K" },
225     { "is",                     "K" },
226     { "id",                     "Q" },
227     { "path",                   "P" },
228     /*
229      * Without the ":", since this is a multi-letter prefix, Xapian
230      * will add a colon itself if the first letter of the path is
231      * upper-case ASCII. Including the ":" forces there to always be a
232      * colon, which keeps our own logic simpler.
233      */
234     { "folder",                 "XFOLDER:" },
235 };
236
237 static prefix_t PROBABILISTIC_PREFIX[]= {
238     { "from",                   "XFROM" },
239     { "to",                     "XTO" },
240     { "attachment",             "XATTACHMENT" },
241     { "subject",                "XSUBJECT"},
242 };
243
244 const char *
245 _find_prefix (const char *name)
246 {
247     unsigned int i;
248
249     for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_INTERNAL); i++) {
250         if (strcmp (name, BOOLEAN_PREFIX_INTERNAL[i].name) == 0)
251             return BOOLEAN_PREFIX_INTERNAL[i].prefix;
252     }
253
254     for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) {
255         if (strcmp (name, BOOLEAN_PREFIX_EXTERNAL[i].name) == 0)
256             return BOOLEAN_PREFIX_EXTERNAL[i].prefix;
257     }
258
259     for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) {
260         if (strcmp (name, PROBABILISTIC_PREFIX[i].name) == 0)
261             return PROBABILISTIC_PREFIX[i].prefix;
262     }
263
264     INTERNAL_ERROR ("No prefix exists for '%s'\n", name);
265
266     return "";
267 }
268
269 static const struct {
270     /* NOTMUCH_FEATURE_* value. */
271     _notmuch_features value;
272     /* Feature name as it appears in the database.  This name should
273      * be appropriate for displaying to the user if an older version
274      * of notmuch doesn't support this feature. */
275     const char *name;
276     /* Compatibility flags when this feature is declared. */
277     const char *flags;
278 } feature_names[] = {
279     { NOTMUCH_FEATURE_FILE_TERMS,
280       "multiple paths per message", "rw" },
281     { NOTMUCH_FEATURE_DIRECTORY_DOCS,
282       "relative directory paths", "rw" },
283     /* Header values are not required for reading a database because a
284      * reader can just refer to the message file. */
285     { NOTMUCH_FEATURE_FROM_SUBJECT_ID_VALUES,
286       "from/subject/message-ID in database", "w" },
287     { NOTMUCH_FEATURE_BOOL_FOLDER,
288       "exact folder:/path: search", "rw" },
289 };
290
291 const char *
292 notmuch_status_to_string (notmuch_status_t status)
293 {
294     switch (status) {
295     case NOTMUCH_STATUS_SUCCESS:
296         return "No error occurred";
297     case NOTMUCH_STATUS_OUT_OF_MEMORY:
298         return "Out of memory";
299     case NOTMUCH_STATUS_READ_ONLY_DATABASE:
300         return "Attempt to write to a read-only database";
301     case NOTMUCH_STATUS_XAPIAN_EXCEPTION:
302         return "A Xapian exception occurred";
303     case NOTMUCH_STATUS_FILE_ERROR:
304         return "Something went wrong trying to read or write a file";
305     case NOTMUCH_STATUS_FILE_NOT_EMAIL:
306         return "File is not an email";
307     case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
308         return "Message ID is identical to a message in database";
309     case NOTMUCH_STATUS_NULL_POINTER:
310         return "Erroneous NULL pointer";
311     case NOTMUCH_STATUS_TAG_TOO_LONG:
312         return "Tag value is too long (exceeds NOTMUCH_TAG_MAX)";
313     case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW:
314         return "Unbalanced number of calls to notmuch_message_freeze/thaw";
315     case NOTMUCH_STATUS_UNBALANCED_ATOMIC:
316         return "Unbalanced number of calls to notmuch_database_begin_atomic/end_atomic";
317     case NOTMUCH_STATUS_UNSUPPORTED_OPERATION:
318         return "Unsupported operation";
319     case NOTMUCH_STATUS_UPGRADE_REQUIRED:
320         return "Operation requires a database upgrade";
321     default:
322     case NOTMUCH_STATUS_LAST_STATUS:
323         return "Unknown error status value";
324     }
325 }
326
327 static void
328 find_doc_ids_for_term (notmuch_database_t *notmuch,
329                        const char *term,
330                        Xapian::PostingIterator *begin,
331                        Xapian::PostingIterator *end)
332 {
333     *begin = notmuch->xapian_db->postlist_begin (term);
334
335     *end = notmuch->xapian_db->postlist_end (term);
336 }
337
338 static void
339 find_doc_ids (notmuch_database_t *notmuch,
340               const char *prefix_name,
341               const char *value,
342               Xapian::PostingIterator *begin,
343               Xapian::PostingIterator *end)
344 {
345     char *term;
346
347     term = talloc_asprintf (notmuch, "%s%s",
348                             _find_prefix (prefix_name), value);
349
350     find_doc_ids_for_term (notmuch, term, begin, end);
351
352     talloc_free (term);
353 }
354
355 notmuch_private_status_t
356 _notmuch_database_find_unique_doc_id (notmuch_database_t *notmuch,
357                                       const char *prefix_name,
358                                       const char *value,
359                                       unsigned int *doc_id)
360 {
361     Xapian::PostingIterator i, end;
362
363     find_doc_ids (notmuch, prefix_name, value, &i, &end);
364
365     if (i == end) {
366         *doc_id = 0;
367         return NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND;
368     }
369
370     *doc_id = *i;
371
372 #if DEBUG_DATABASE_SANITY
373     i++;
374
375     if (i != end)
376         INTERNAL_ERROR ("Term %s:%s is not unique as expected.\n",
377                         prefix_name, value);
378 #endif
379
380     return NOTMUCH_PRIVATE_STATUS_SUCCESS;
381 }
382
383 static Xapian::Document
384 find_document_for_doc_id (notmuch_database_t *notmuch, unsigned doc_id)
385 {
386     return notmuch->xapian_db->get_document (doc_id);
387 }
388
389 /* Generate a compressed version of 'message_id' of the form:
390  *
391  *      notmuch-sha1-<sha1_sum_of_message_id>
392  */
393 static char *
394 _message_id_compressed (void *ctx, const char *message_id)
395 {
396     char *sha1, *compressed;
397
398     sha1 = _notmuch_sha1_of_string (message_id);
399
400     compressed = talloc_asprintf (ctx, "notmuch-sha1-%s", sha1);
401     free (sha1);
402
403     return compressed;
404 }
405
406 notmuch_status_t
407 notmuch_database_find_message (notmuch_database_t *notmuch,
408                                const char *message_id,
409                                notmuch_message_t **message_ret)
410 {
411     notmuch_private_status_t status;
412     unsigned int doc_id;
413
414     if (message_ret == NULL)
415         return NOTMUCH_STATUS_NULL_POINTER;
416
417     if (strlen (message_id) > NOTMUCH_MESSAGE_ID_MAX)
418         message_id = _message_id_compressed (notmuch, message_id);
419
420     try {
421         status = _notmuch_database_find_unique_doc_id (notmuch, "id",
422                                                        message_id, &doc_id);
423
424         if (status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND)
425             *message_ret = NULL;
426         else {
427             *message_ret = _notmuch_message_create (notmuch, notmuch, doc_id,
428                                                     NULL);
429             if (*message_ret == NULL)
430                 return NOTMUCH_STATUS_OUT_OF_MEMORY;
431         }
432
433         return NOTMUCH_STATUS_SUCCESS;
434     } catch (const Xapian::Error &error) {
435         fprintf (stderr, "A Xapian exception occurred finding message: %s.\n",
436                  error.get_msg().c_str());
437         notmuch->exception_reported = TRUE;
438         *message_ret = NULL;
439         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
440     }
441 }
442
443 /* Advance 'str' past any whitespace or RFC 822 comments. A comment is
444  * a (potentially nested) parenthesized sequence with '\' used to
445  * escape any character (including parentheses).
446  *
447  * If the sequence to be skipped continues to the end of the string,
448  * then 'str' will be left pointing at the final terminating '\0'
449  * character.
450  */
451 static void
452 skip_space_and_comments (const char **str)
453 {
454     const char *s;
455
456     s = *str;
457     while (*s && (isspace (*s) || *s == '(')) {
458         while (*s && isspace (*s))
459             s++;
460         if (*s == '(') {
461             int nesting = 1;
462             s++;
463             while (*s && nesting) {
464                 if (*s == '(') {
465                     nesting++;
466                 } else if (*s == ')') {
467                     nesting--;
468                 } else if (*s == '\\') {
469                     if (*(s+1))
470                         s++;
471                 }
472                 s++;
473             }
474         }
475     }
476
477     *str = s;
478 }
479
480 /* Parse an RFC 822 message-id, discarding whitespace, any RFC 822
481  * comments, and the '<' and '>' delimiters.
482  *
483  * If not NULL, then *next will be made to point to the first character
484  * not parsed, (possibly pointing to the final '\0' terminator.
485  *
486  * Returns a newly talloc'ed string belonging to 'ctx'.
487  *
488  * Returns NULL if there is any error parsing the message-id. */
489 static char *
490 _parse_message_id (void *ctx, const char *message_id, const char **next)
491 {
492     const char *s, *end;
493     char *result;
494
495     if (message_id == NULL || *message_id == '\0')
496         return NULL;
497
498     s = message_id;
499
500     skip_space_and_comments (&s);
501
502     /* Skip any unstructured text as well. */
503     while (*s && *s != '<')
504         s++;
505
506     if (*s == '<') {
507         s++;
508     } else {
509         if (next)
510             *next = s;
511         return NULL;
512     }
513
514     skip_space_and_comments (&s);
515
516     end = s;
517     while (*end && *end != '>')
518         end++;
519     if (next) {
520         if (*end)
521             *next = end + 1;
522         else
523             *next = end;
524     }
525
526     if (end > s && *end == '>')
527         end--;
528     if (end <= s)
529         return NULL;
530
531     result = talloc_strndup (ctx, s, end - s + 1);
532
533     /* Finally, collapse any whitespace that is within the message-id
534      * itself. */
535     {
536         char *r;
537         int len;
538
539         for (r = result, len = strlen (r); *r; r++, len--)
540             if (*r == ' ' || *r == '\t')
541                 memmove (r, r+1, len);
542     }
543
544     return result;
545 }
546
547 /* Parse a References header value, putting a (talloc'ed under 'ctx')
548  * copy of each referenced message-id into 'hash'.
549  *
550  * We explicitly avoid including any reference identical to
551  * 'message_id' in the result (to avoid mass confusion when a single
552  * message references itself cyclically---and yes, mail messages are
553  * not infrequent in the wild that do this---don't ask me why).
554  *
555  * Return the last reference parsed, if it is not equal to message_id.
556  */
557 static char *
558 parse_references (void *ctx,
559                   const char *message_id,
560                   GHashTable *hash,
561                   const char *refs)
562 {
563     char *ref, *last_ref = NULL;
564
565     if (refs == NULL || *refs == '\0')
566         return NULL;
567
568     while (*refs) {
569         ref = _parse_message_id (ctx, refs, &refs);
570
571         if (ref && strcmp (ref, message_id)) {
572             g_hash_table_insert (hash, ref, NULL);
573             last_ref = ref;
574         }
575     }
576
577     /* The return value of this function is used to add a parent
578      * reference to the database.  We should avoid making a message
579      * its own parent, thus the above check.
580      */
581     return last_ref;
582 }
583
584 notmuch_status_t
585 notmuch_database_create (const char *path, notmuch_database_t **database)
586 {
587     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
588     notmuch_database_t *notmuch = NULL;
589     char *notmuch_path = NULL;
590     struct stat st;
591     int err;
592
593     if (path == NULL) {
594         fprintf (stderr, "Error: Cannot create a database for a NULL path.\n");
595         status = NOTMUCH_STATUS_NULL_POINTER;
596         goto DONE;
597     }
598
599     err = stat (path, &st);
600     if (err) {
601         fprintf (stderr, "Error: Cannot create database at %s: %s.\n",
602                  path, strerror (errno));
603         status = NOTMUCH_STATUS_FILE_ERROR;
604         goto DONE;
605     }
606
607     if (! S_ISDIR (st.st_mode)) {
608         fprintf (stderr, "Error: Cannot create database at %s: Not a directory.\n",
609                  path);
610         status = NOTMUCH_STATUS_FILE_ERROR;
611         goto DONE;
612     }
613
614     notmuch_path = talloc_asprintf (NULL, "%s/%s", path, ".notmuch");
615
616     err = mkdir (notmuch_path, 0755);
617
618     if (err) {
619         fprintf (stderr, "Error: Cannot create directory %s: %s.\n",
620                  notmuch_path, strerror (errno));
621         status = NOTMUCH_STATUS_FILE_ERROR;
622         goto DONE;
623     }
624
625     status = notmuch_database_open (path,
626                                     NOTMUCH_DATABASE_MODE_READ_WRITE,
627                                     &notmuch);
628     if (status)
629         goto DONE;
630
631     /* Upgrade doesn't add this feature to existing databases, but new
632      * databases have it. */
633     notmuch->features |= NOTMUCH_FEATURE_FROM_SUBJECT_ID_VALUES;
634
635     status = notmuch_database_upgrade (notmuch, NULL, NULL);
636     if (status) {
637         notmuch_database_close(notmuch);
638         notmuch = NULL;
639     }
640
641   DONE:
642     if (notmuch_path)
643         talloc_free (notmuch_path);
644
645     if (database)
646         *database = notmuch;
647     else
648         talloc_free (notmuch);
649     return status;
650 }
651
652 notmuch_status_t
653 _notmuch_database_ensure_writable (notmuch_database_t *notmuch)
654 {
655     if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY) {
656         fprintf (stderr, "Cannot write to a read-only database.\n");
657         return NOTMUCH_STATUS_READ_ONLY_DATABASE;
658     }
659
660     return NOTMUCH_STATUS_SUCCESS;
661 }
662
663 /* Parse a database features string from the given database version.
664  * Returns the feature bit set.
665  *
666  * For version < 3, this ignores the features string and returns a
667  * hard-coded set of features.
668  *
669  * If there are unrecognized features that are required to open the
670  * database in mode (which should be 'r' or 'w'), return a
671  * comma-separated list of unrecognized but required features in
672  * *incompat_out suitable for presenting to the user.  *incompat_out
673  * will be allocated from ctx.
674  */
675 static _notmuch_features
676 _parse_features (const void *ctx, const char *features, unsigned int version,
677                  char mode, char **incompat_out)
678 {
679     _notmuch_features res = static_cast<_notmuch_features>(0);
680     unsigned int namelen, i;
681     size_t llen = 0;
682     const char *flags;
683
684     /* Prior to database version 3, features were implied by the
685      * version number. */
686     if (version == 0)
687         return NOTMUCH_FEATURES_V0;
688     else if (version == 1)
689         return NOTMUCH_FEATURES_V1;
690     else if (version == 2)
691         return NOTMUCH_FEATURES_V2;
692
693     /* Parse the features string */
694     while ((features = strtok_len_c (features + llen, "\n", &llen)) != NULL) {
695         flags = strchr (features, '\t');
696         if (! flags || flags > features + llen)
697             continue;
698         namelen = flags - features;
699
700         for (i = 0; i < ARRAY_SIZE (feature_names); ++i) {
701             if (strlen (feature_names[i].name) == namelen &&
702                 strncmp (feature_names[i].name, features, namelen) == 0) {
703                 res |= feature_names[i].value;
704                 break;
705             }
706         }
707
708         if (i == ARRAY_SIZE (feature_names) && incompat_out) {
709             /* Unrecognized feature */
710             const char *have = strchr (flags, mode);
711             if (have && have < features + llen) {
712                 /* This feature is required to access this database in
713                  * 'mode', but we don't understand it. */
714                 if (! *incompat_out)
715                     *incompat_out = talloc_strdup (ctx, "");
716                 *incompat_out = talloc_asprintf_append_buffer (
717                     *incompat_out, "%s%.*s", **incompat_out ? ", " : "",
718                     namelen, features);
719             }
720         }
721     }
722
723     return res;
724 }
725
726 static char *
727 _print_features (const void *ctx, unsigned int features)
728 {
729     unsigned int i;
730     char *res = talloc_strdup (ctx, "");
731
732     for (i = 0; i < ARRAY_SIZE (feature_names); ++i)
733         if (features & feature_names[i].value)
734             res = talloc_asprintf_append_buffer (
735                 res, "%s\t%s\n", feature_names[i].name, feature_names[i].flags);
736
737     return res;
738 }
739
740 notmuch_status_t
741 notmuch_database_open (const char *path,
742                        notmuch_database_mode_t mode,
743                        notmuch_database_t **database)
744 {
745     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
746     void *local = talloc_new (NULL);
747     notmuch_database_t *notmuch = NULL;
748     char *notmuch_path, *xapian_path, *incompat_features;
749     struct stat st;
750     int err;
751     unsigned int i, version;
752     static int initialized = 0;
753
754     if (path == NULL) {
755         fprintf (stderr, "Error: Cannot open a database for a NULL path.\n");
756         status = NOTMUCH_STATUS_NULL_POINTER;
757         goto DONE;
758     }
759
760     if (! (notmuch_path = talloc_asprintf (local, "%s/%s", path, ".notmuch"))) {
761         fprintf (stderr, "Out of memory\n");
762         status = NOTMUCH_STATUS_OUT_OF_MEMORY;
763         goto DONE;
764     }
765
766     err = stat (notmuch_path, &st);
767     if (err) {
768         fprintf (stderr, "Error opening database at %s: %s\n",
769                  notmuch_path, strerror (errno));
770         status = NOTMUCH_STATUS_FILE_ERROR;
771         goto DONE;
772     }
773
774     if (! (xapian_path = talloc_asprintf (local, "%s/%s", notmuch_path, "xapian"))) {
775         fprintf (stderr, "Out of memory\n");
776         status = NOTMUCH_STATUS_OUT_OF_MEMORY;
777         goto DONE;
778     }
779
780     /* Initialize the GLib type system and threads */
781 #if !GLIB_CHECK_VERSION(2, 35, 1)
782     g_type_init ();
783 #endif
784
785     /* Initialize gmime */
786     if (! initialized) {
787         g_mime_init (GMIME_ENABLE_RFC2047_WORKAROUNDS);
788         initialized = 1;
789     }
790
791     notmuch = talloc_zero (NULL, notmuch_database_t);
792     notmuch->exception_reported = FALSE;
793     notmuch->path = talloc_strdup (notmuch, path);
794
795     if (notmuch->path[strlen (notmuch->path) - 1] == '/')
796         notmuch->path[strlen (notmuch->path) - 1] = '\0';
797
798     notmuch->mode = mode;
799     notmuch->atomic_nesting = 0;
800     try {
801         string last_thread_id;
802
803         if (mode == NOTMUCH_DATABASE_MODE_READ_WRITE) {
804             notmuch->xapian_db = new Xapian::WritableDatabase (xapian_path,
805                                                                Xapian::DB_CREATE_OR_OPEN);
806         } else {
807             notmuch->xapian_db = new Xapian::Database (xapian_path);
808         }
809
810         /* Check version.  As of database version 3, we represent
811          * changes in terms of features, so assume a version bump
812          * means a dramatically incompatible change. */
813         version = notmuch_database_get_version (notmuch);
814         if (version > NOTMUCH_DATABASE_VERSION) {
815             fprintf (stderr,
816                      "Error: Notmuch database at %s\n"
817                      "       has a newer database format version (%u) than supported by this\n"
818                      "       version of notmuch (%u).\n",
819                      notmuch_path, version, NOTMUCH_DATABASE_VERSION);
820             notmuch->mode = NOTMUCH_DATABASE_MODE_READ_ONLY;
821             notmuch_database_destroy (notmuch);
822             notmuch = NULL;
823             status = NOTMUCH_STATUS_FILE_ERROR;
824             goto DONE;
825         }
826
827         /* Check features. */
828         incompat_features = NULL;
829         notmuch->features = _parse_features (
830             local, notmuch->xapian_db->get_metadata ("features").c_str (),
831             version, mode == NOTMUCH_DATABASE_MODE_READ_WRITE ? 'w' : 'r',
832             &incompat_features);
833         if (incompat_features) {
834             fprintf (stderr,
835                      "Error: Notmuch database at %s\n"
836                      "       requires features (%s)\n"
837                      "       not supported by this version of notmuch.\n",
838                      notmuch_path, incompat_features);
839             notmuch->mode = NOTMUCH_DATABASE_MODE_READ_ONLY;
840             notmuch_database_destroy (notmuch);
841             notmuch = NULL;
842             status = NOTMUCH_STATUS_FILE_ERROR;
843             goto DONE;
844         }
845
846         notmuch->last_doc_id = notmuch->xapian_db->get_lastdocid ();
847         last_thread_id = notmuch->xapian_db->get_metadata ("last_thread_id");
848         if (last_thread_id.empty ()) {
849             notmuch->last_thread_id = 0;
850         } else {
851             const char *str;
852             char *end;
853
854             str = last_thread_id.c_str ();
855             notmuch->last_thread_id = strtoull (str, &end, 16);
856             if (*end != '\0')
857                 INTERNAL_ERROR ("Malformed database last_thread_id: %s", str);
858         }
859
860         notmuch->query_parser = new Xapian::QueryParser;
861         notmuch->term_gen = new Xapian::TermGenerator;
862         notmuch->term_gen->set_stemmer (Xapian::Stem ("english"));
863         notmuch->value_range_processor = new Xapian::NumberValueRangeProcessor (NOTMUCH_VALUE_TIMESTAMP);
864         notmuch->date_range_processor = new ParseTimeValueRangeProcessor (NOTMUCH_VALUE_TIMESTAMP);
865
866         notmuch->query_parser->set_default_op (Xapian::Query::OP_AND);
867         notmuch->query_parser->set_database (*notmuch->xapian_db);
868         notmuch->query_parser->set_stemmer (Xapian::Stem ("english"));
869         notmuch->query_parser->set_stemming_strategy (Xapian::QueryParser::STEM_SOME);
870         notmuch->query_parser->add_valuerangeprocessor (notmuch->value_range_processor);
871         notmuch->query_parser->add_valuerangeprocessor (notmuch->date_range_processor);
872
873         for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) {
874             prefix_t *prefix = &BOOLEAN_PREFIX_EXTERNAL[i];
875             notmuch->query_parser->add_boolean_prefix (prefix->name,
876                                                        prefix->prefix);
877         }
878
879         for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) {
880             prefix_t *prefix = &PROBABILISTIC_PREFIX[i];
881             notmuch->query_parser->add_prefix (prefix->name, prefix->prefix);
882         }
883     } catch (const Xapian::Error &error) {
884         fprintf (stderr, "A Xapian exception occurred opening database: %s\n",
885                  error.get_msg().c_str());
886         notmuch_database_destroy (notmuch);
887         notmuch = NULL;
888         status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
889     }
890
891   DONE:
892     talloc_free (local);
893
894     if (database)
895         *database = notmuch;
896     else
897         talloc_free (notmuch);
898     return status;
899 }
900
901 notmuch_status_t
902 notmuch_database_close (notmuch_database_t *notmuch)
903 {
904     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
905
906     try {
907         if (notmuch->xapian_db != NULL &&
908             notmuch->mode == NOTMUCH_DATABASE_MODE_READ_WRITE)
909             (static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db))->flush ();
910     } catch (const Xapian::Error &error) {
911         status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
912         if (! notmuch->exception_reported) {
913             fprintf (stderr, "Error: A Xapian exception occurred flushing database: %s\n",
914                      error.get_msg().c_str());
915         }
916     }
917
918     /* Many Xapian objects (and thus notmuch objects) hold references to
919      * the database, so merely deleting the database may not suffice to
920      * close it.  Thus, we explicitly close it here. */
921     if (notmuch->xapian_db != NULL) {
922         try {
923             notmuch->xapian_db->close();
924         } catch (const Xapian::Error &error) {
925             /* don't clobber previous error status */
926             if (status == NOTMUCH_STATUS_SUCCESS)
927                 status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
928         }
929     }
930
931     delete notmuch->term_gen;
932     notmuch->term_gen = NULL;
933     delete notmuch->query_parser;
934     notmuch->query_parser = NULL;
935     delete notmuch->xapian_db;
936     notmuch->xapian_db = NULL;
937     delete notmuch->value_range_processor;
938     notmuch->value_range_processor = NULL;
939     delete notmuch->date_range_processor;
940     notmuch->date_range_processor = NULL;
941
942     return status;
943 }
944
945 #if HAVE_XAPIAN_COMPACT
946 static int
947 unlink_cb (const char *path,
948            unused (const struct stat *sb),
949            unused (int type),
950            unused (struct FTW *ftw))
951 {
952     return remove (path);
953 }
954
955 static int
956 rmtree (const char *path)
957 {
958     return nftw (path, unlink_cb, 64, FTW_DEPTH | FTW_PHYS);
959 }
960
961 class NotmuchCompactor : public Xapian::Compactor
962 {
963     notmuch_compact_status_cb_t status_cb;
964     void *status_closure;
965
966 public:
967     NotmuchCompactor(notmuch_compact_status_cb_t cb, void *closure) :
968         status_cb (cb), status_closure (closure) { }
969
970     virtual void
971     set_status (const std::string &table, const std::string &status)
972     {
973         char *msg;
974
975         if (status_cb == NULL)
976             return;
977
978         if (status.length () == 0)
979             msg = talloc_asprintf (NULL, "compacting table %s", table.c_str());
980         else
981             msg = talloc_asprintf (NULL, "     %s", status.c_str());
982
983         if (msg == NULL) {
984             return;
985         }
986
987         status_cb (msg, status_closure);
988         talloc_free (msg);
989     }
990 };
991
992 /* Compacts the given database, optionally saving the original database
993  * in backup_path. Additionally, a callback function can be provided to
994  * give the user feedback on the progress of the (likely long-lived)
995  * compaction process.
996  *
997  * The backup path must point to a directory on the same volume as the
998  * original database. Passing a NULL backup_path will result in the
999  * uncompacted database being deleted after compaction has finished.
1000  * Note that the database write lock will be held during the
1001  * compaction process to protect data integrity.
1002  */
1003 notmuch_status_t
1004 notmuch_database_compact (const char *path,
1005                           const char *backup_path,
1006                           notmuch_compact_status_cb_t status_cb,
1007                           void *closure)
1008 {
1009     void *local;
1010     char *notmuch_path, *xapian_path, *compact_xapian_path;
1011     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1012     notmuch_database_t *notmuch = NULL;
1013     struct stat statbuf;
1014     notmuch_bool_t keep_backup;
1015
1016     local = talloc_new (NULL);
1017     if (! local)
1018         return NOTMUCH_STATUS_OUT_OF_MEMORY;
1019
1020     ret = notmuch_database_open (path, NOTMUCH_DATABASE_MODE_READ_WRITE, &notmuch);
1021     if (ret) {
1022         goto DONE;
1023     }
1024
1025     if (! (notmuch_path = talloc_asprintf (local, "%s/%s", path, ".notmuch"))) {
1026         ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
1027         goto DONE;
1028     }
1029
1030     if (! (xapian_path = talloc_asprintf (local, "%s/%s", notmuch_path, "xapian"))) {
1031         ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
1032         goto DONE;
1033     }
1034
1035     if (! (compact_xapian_path = talloc_asprintf (local, "%s.compact", xapian_path))) {
1036         ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
1037         goto DONE;
1038     }
1039
1040     if (backup_path == NULL) {
1041         if (! (backup_path = talloc_asprintf (local, "%s.old", xapian_path))) {
1042             ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
1043             goto DONE;
1044         }
1045         keep_backup = FALSE;
1046     }
1047     else {
1048         keep_backup = TRUE;
1049     }
1050
1051     if (stat (backup_path, &statbuf) != -1) {
1052         fprintf (stderr, "Path already exists: %s\n", backup_path);
1053         ret = NOTMUCH_STATUS_FILE_ERROR;
1054         goto DONE;
1055     }
1056     if (errno != ENOENT) {
1057         fprintf (stderr, "Unknown error while stat()ing path: %s\n",
1058                  strerror (errno));
1059         ret = NOTMUCH_STATUS_FILE_ERROR;
1060         goto DONE;
1061     }
1062
1063     /* Unconditionally attempt to remove old work-in-progress database (if
1064      * any). This is "protected" by database lock. If this fails due to write
1065      * errors (etc), the following code will fail and provide error message.
1066      */
1067     (void) rmtree (compact_xapian_path);
1068
1069     try {
1070         NotmuchCompactor compactor (status_cb, closure);
1071
1072         compactor.set_renumber (false);
1073         compactor.add_source (xapian_path);
1074         compactor.set_destdir (compact_xapian_path);
1075         compactor.compact ();
1076     } catch (const Xapian::Error &error) {
1077         fprintf (stderr, "Error while compacting: %s\n", error.get_msg().c_str());
1078         ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
1079         goto DONE;
1080     }
1081
1082     if (rename (xapian_path, backup_path)) {
1083         fprintf (stderr, "Error moving %s to %s: %s\n",
1084                  xapian_path, backup_path, strerror (errno));
1085         ret = NOTMUCH_STATUS_FILE_ERROR;
1086         goto DONE;
1087     }
1088
1089     if (rename (compact_xapian_path, xapian_path)) {
1090         fprintf (stderr, "Error moving %s to %s: %s\n",
1091                  compact_xapian_path, xapian_path, strerror (errno));
1092         ret = NOTMUCH_STATUS_FILE_ERROR;
1093         goto DONE;
1094     }
1095
1096     if (! keep_backup) {
1097         if (rmtree (backup_path)) {
1098             fprintf (stderr, "Error removing old database %s: %s\n",
1099                      backup_path, strerror (errno));
1100             ret = NOTMUCH_STATUS_FILE_ERROR;
1101             goto DONE;
1102         }
1103     }
1104
1105   DONE:
1106     if (notmuch) {
1107         notmuch_status_t ret2;
1108
1109         ret2 = notmuch_database_destroy (notmuch);
1110
1111         /* don't clobber previous error status */
1112         if (ret == NOTMUCH_STATUS_SUCCESS && ret2 != NOTMUCH_STATUS_SUCCESS)
1113             ret = ret2;
1114     }
1115
1116     talloc_free (local);
1117
1118     return ret;
1119 }
1120 #else
1121 notmuch_status_t
1122 notmuch_database_compact (unused (const char *path),
1123                           unused (const char *backup_path),
1124                           unused (notmuch_compact_status_cb_t status_cb),
1125                           unused (void *closure))
1126 {
1127     fprintf (stderr, "notmuch was compiled against a xapian version lacking compaction support.\n");
1128     return NOTMUCH_STATUS_UNSUPPORTED_OPERATION;
1129 }
1130 #endif
1131
1132 notmuch_status_t
1133 notmuch_database_destroy (notmuch_database_t *notmuch)
1134 {
1135     notmuch_status_t status;
1136
1137     status = notmuch_database_close (notmuch);
1138     talloc_free (notmuch);
1139
1140     return status;
1141 }
1142
1143 const char *
1144 notmuch_database_get_path (notmuch_database_t *notmuch)
1145 {
1146     return notmuch->path;
1147 }
1148
1149 unsigned int
1150 notmuch_database_get_version (notmuch_database_t *notmuch)
1151 {
1152     unsigned int version;
1153     string version_string;
1154     const char *str;
1155     char *end;
1156
1157     version_string = notmuch->xapian_db->get_metadata ("version");
1158     if (version_string.empty ())
1159         return 0;
1160
1161     str = version_string.c_str ();
1162     if (str == NULL || *str == '\0')
1163         return 0;
1164
1165     version = strtoul (str, &end, 10);
1166     if (*end != '\0')
1167         INTERNAL_ERROR ("Malformed database version: %s", str);
1168
1169     return version;
1170 }
1171
1172 notmuch_bool_t
1173 notmuch_database_needs_upgrade (notmuch_database_t *notmuch)
1174 {
1175     return notmuch->mode == NOTMUCH_DATABASE_MODE_READ_WRITE &&
1176         ((NOTMUCH_FEATURES_CURRENT & ~notmuch->features) ||
1177          (notmuch_database_get_version (notmuch) < NOTMUCH_DATABASE_VERSION));
1178 }
1179
1180 static volatile sig_atomic_t do_progress_notify = 0;
1181
1182 static void
1183 handle_sigalrm (unused (int signal))
1184 {
1185     do_progress_notify = 1;
1186 }
1187
1188 /* Upgrade the current database.
1189  *
1190  * After opening a database in read-write mode, the client should
1191  * check if an upgrade is needed (notmuch_database_needs_upgrade) and
1192  * if so, upgrade with this function before making any modifications.
1193  *
1194  * The optional progress_notify callback can be used by the caller to
1195  * provide progress indication to the user. If non-NULL it will be
1196  * called periodically with 'count' as the number of messages upgraded
1197  * so far and 'total' the overall number of messages that will be
1198  * converted.
1199  */
1200 notmuch_status_t
1201 notmuch_database_upgrade (notmuch_database_t *notmuch,
1202                           void (*progress_notify) (void *closure,
1203                                                    double progress),
1204                           void *closure)
1205 {
1206     void *local = talloc_new (NULL);
1207     Xapian::TermIterator t, t_end;
1208     Xapian::WritableDatabase *db;
1209     struct sigaction action;
1210     struct itimerval timerval;
1211     notmuch_bool_t timer_is_active = FALSE;
1212     enum _notmuch_features target_features, new_features;
1213     notmuch_status_t status;
1214     unsigned int count = 0, total = 0;
1215
1216     status = _notmuch_database_ensure_writable (notmuch);
1217     if (status)
1218         return status;
1219
1220     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
1221
1222     target_features = notmuch->features | NOTMUCH_FEATURES_CURRENT;
1223     new_features = NOTMUCH_FEATURES_CURRENT & ~notmuch->features;
1224
1225     if (! new_features)
1226         return NOTMUCH_STATUS_SUCCESS;
1227
1228     if (progress_notify) {
1229         /* Setup our handler for SIGALRM */
1230         memset (&action, 0, sizeof (struct sigaction));
1231         action.sa_handler = handle_sigalrm;
1232         sigemptyset (&action.sa_mask);
1233         action.sa_flags = SA_RESTART;
1234         sigaction (SIGALRM, &action, NULL);
1235
1236         /* Then start a timer to send SIGALRM once per second. */
1237         timerval.it_interval.tv_sec = 1;
1238         timerval.it_interval.tv_usec = 0;
1239         timerval.it_value.tv_sec = 1;
1240         timerval.it_value.tv_usec = 0;
1241         setitimer (ITIMER_REAL, &timerval, NULL);
1242
1243         timer_is_active = TRUE;
1244     }
1245
1246     /* Figure out how much total work we need to do. */
1247     if (new_features &
1248         (NOTMUCH_FEATURE_FILE_TERMS | NOTMUCH_FEATURE_BOOL_FOLDER)) {
1249         notmuch_query_t *query = notmuch_query_create (notmuch, "");
1250         total += notmuch_query_count_messages (query);
1251         notmuch_query_destroy (query);
1252     }
1253     if (new_features & NOTMUCH_FEATURE_DIRECTORY_DOCS) {
1254         t_end = db->allterms_end ("XTIMESTAMP");
1255         for (t = db->allterms_begin ("XTIMESTAMP"); t != t_end; t++)
1256             ++total;
1257     }
1258
1259     /* Perform the upgrade in a transaction. */
1260     db->begin_transaction (true);
1261
1262     /* Set the target features so we write out changes in the desired
1263      * format. */
1264     notmuch->features = target_features;
1265
1266     /* Perform per-message upgrades. */
1267     if (new_features &
1268         (NOTMUCH_FEATURE_FILE_TERMS | NOTMUCH_FEATURE_BOOL_FOLDER)) {
1269         notmuch_query_t *query = notmuch_query_create (notmuch, "");
1270         notmuch_messages_t *messages;
1271         notmuch_message_t *message;
1272         char *filename;
1273
1274         for (messages = notmuch_query_search_messages (query);
1275              notmuch_messages_valid (messages);
1276              notmuch_messages_move_to_next (messages))
1277         {
1278             if (do_progress_notify) {
1279                 progress_notify (closure, (double) count / total);
1280                 do_progress_notify = 0;
1281             }
1282
1283             message = notmuch_messages_get (messages);
1284
1285             /* Before version 1, each message document had its
1286              * filename in the data field. Copy that into the new
1287              * format by calling notmuch_message_add_filename.
1288              */
1289             if (new_features & NOTMUCH_FEATURE_FILE_TERMS) {
1290                 filename = _notmuch_message_talloc_copy_data (message);
1291                 if (filename && *filename != '\0') {
1292                     _notmuch_message_add_filename (message, filename);
1293                     _notmuch_message_clear_data (message);
1294                 }
1295                 talloc_free (filename);
1296             }
1297
1298             /* Prior to version 2, the "folder:" prefix was
1299              * probabilistic and stemmed. Change it to the current
1300              * boolean prefix. Add "path:" prefixes while at it.
1301              */
1302             if (new_features & NOTMUCH_FEATURE_BOOL_FOLDER)
1303                 _notmuch_message_upgrade_folder (message);
1304
1305             _notmuch_message_sync (message);
1306
1307             notmuch_message_destroy (message);
1308
1309             count++;
1310         }
1311
1312         notmuch_query_destroy (query);
1313     }
1314
1315     /* Perform per-directory upgrades. */
1316
1317     /* Before version 1 we stored directory timestamps in
1318      * XTIMESTAMP documents instead of the current XDIRECTORY
1319      * documents. So copy those as well. */
1320     if (new_features & NOTMUCH_FEATURE_DIRECTORY_DOCS) {
1321         t_end = notmuch->xapian_db->allterms_end ("XTIMESTAMP");
1322
1323         for (t = notmuch->xapian_db->allterms_begin ("XTIMESTAMP");
1324              t != t_end;
1325              t++)
1326         {
1327             Xapian::PostingIterator p, p_end;
1328             std::string term = *t;
1329
1330             p_end = notmuch->xapian_db->postlist_end (term);
1331
1332             for (p = notmuch->xapian_db->postlist_begin (term);
1333                  p != p_end;
1334                  p++)
1335             {
1336                 Xapian::Document document;
1337                 time_t mtime;
1338                 notmuch_directory_t *directory;
1339
1340                 if (do_progress_notify) {
1341                     progress_notify (closure, (double) count / total);
1342                     do_progress_notify = 0;
1343                 }
1344
1345                 document = find_document_for_doc_id (notmuch, *p);
1346                 mtime = Xapian::sortable_unserialise (
1347                     document.get_value (NOTMUCH_VALUE_TIMESTAMP));
1348
1349                 directory = _notmuch_directory_create (notmuch, term.c_str() + 10,
1350                                                        NOTMUCH_FIND_CREATE, &status);
1351                 notmuch_directory_set_mtime (directory, mtime);
1352                 notmuch_directory_destroy (directory);
1353
1354                 db->delete_document (*p);
1355             }
1356
1357             ++count;
1358         }
1359     }
1360
1361     db->set_metadata ("features", _print_features (local, notmuch->features));
1362     db->set_metadata ("version", STRINGIFY (NOTMUCH_DATABASE_VERSION));
1363
1364     db->commit_transaction ();
1365
1366     if (timer_is_active) {
1367         /* Now stop the timer. */
1368         timerval.it_interval.tv_sec = 0;
1369         timerval.it_interval.tv_usec = 0;
1370         timerval.it_value.tv_sec = 0;
1371         timerval.it_value.tv_usec = 0;
1372         setitimer (ITIMER_REAL, &timerval, NULL);
1373
1374         /* And disable the signal handler. */
1375         action.sa_handler = SIG_IGN;
1376         sigaction (SIGALRM, &action, NULL);
1377     }
1378
1379     talloc_free (local);
1380     return NOTMUCH_STATUS_SUCCESS;
1381 }
1382
1383 notmuch_status_t
1384 notmuch_database_begin_atomic (notmuch_database_t *notmuch)
1385 {
1386     if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY ||
1387         notmuch->atomic_nesting > 0)
1388         goto DONE;
1389
1390     try {
1391         (static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db))->begin_transaction (false);
1392     } catch (const Xapian::Error &error) {
1393         fprintf (stderr, "A Xapian exception occurred beginning transaction: %s.\n",
1394                  error.get_msg().c_str());
1395         notmuch->exception_reported = TRUE;
1396         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
1397     }
1398
1399 DONE:
1400     notmuch->atomic_nesting++;
1401     return NOTMUCH_STATUS_SUCCESS;
1402 }
1403
1404 notmuch_status_t
1405 notmuch_database_end_atomic (notmuch_database_t *notmuch)
1406 {
1407     Xapian::WritableDatabase *db;
1408
1409     if (notmuch->atomic_nesting == 0)
1410         return NOTMUCH_STATUS_UNBALANCED_ATOMIC;
1411
1412     if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY ||
1413         notmuch->atomic_nesting > 1)
1414         goto DONE;
1415
1416     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
1417     try {
1418         db->commit_transaction ();
1419
1420         /* This is a hack for testing.  Xapian never flushes on a
1421          * non-flushed commit, even if the flush threshold is 1.
1422          * However, we rely on flushing to test atomicity. */
1423         const char *thresh = getenv ("XAPIAN_FLUSH_THRESHOLD");
1424         if (thresh && atoi (thresh) == 1)
1425             db->flush ();
1426     } catch (const Xapian::Error &error) {
1427         fprintf (stderr, "A Xapian exception occurred committing transaction: %s.\n",
1428                  error.get_msg().c_str());
1429         notmuch->exception_reported = TRUE;
1430         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
1431     }
1432
1433 DONE:
1434     notmuch->atomic_nesting--;
1435     return NOTMUCH_STATUS_SUCCESS;
1436 }
1437
1438 /* We allow the user to use arbitrarily long paths for directories. But
1439  * we have a term-length limit. So if we exceed that, we'll use the
1440  * SHA-1 of the path for the database term.
1441  *
1442  * Note: This function may return the original value of 'path'. If it
1443  * does not, then the caller is responsible to free() the returned
1444  * value.
1445  */
1446 const char *
1447 _notmuch_database_get_directory_db_path (const char *path)
1448 {
1449     int term_len = strlen (_find_prefix ("directory")) + strlen (path);
1450
1451     if (term_len > NOTMUCH_TERM_MAX)
1452         return _notmuch_sha1_of_string (path);
1453     else
1454         return path;
1455 }
1456
1457 /* Given a path, split it into two parts: the directory part is all
1458  * components except for the last, and the basename is that last
1459  * component. Getting the return-value for either part is optional
1460  * (the caller can pass NULL).
1461  *
1462  * The original 'path' can represent either a regular file or a
1463  * directory---the splitting will be carried out in the same way in
1464  * either case. Trailing slashes on 'path' will be ignored, and any
1465  * cases of multiple '/' characters appearing in series will be
1466  * treated as a single '/'.
1467  *
1468  * Allocation (if any) will have 'ctx' as the talloc owner. But
1469  * pointers will be returned within the original path string whenever
1470  * possible.
1471  *
1472  * Note: If 'path' is non-empty and contains no non-trailing slash,
1473  * (that is, consists of a filename with no parent directory), then
1474  * the directory returned will be an empty string. However, if 'path'
1475  * is an empty string, then both directory and basename will be
1476  * returned as NULL.
1477  */
1478 notmuch_status_t
1479 _notmuch_database_split_path (void *ctx,
1480                               const char *path,
1481                               const char **directory,
1482                               const char **basename)
1483 {
1484     const char *slash;
1485
1486     if (path == NULL || *path == '\0') {
1487         if (directory)
1488             *directory = NULL;
1489         if (basename)
1490             *basename = NULL;
1491         return NOTMUCH_STATUS_SUCCESS;
1492     }
1493
1494     /* Find the last slash (not counting a trailing slash), if any. */
1495
1496     slash = path + strlen (path) - 1;
1497
1498     /* First, skip trailing slashes. */
1499     while (slash != path) {
1500         if (*slash != '/')
1501             break;
1502
1503         --slash;
1504     }
1505
1506     /* Then, find a slash. */
1507     while (slash != path) {
1508         if (*slash == '/')
1509             break;
1510
1511         if (basename)
1512             *basename = slash;
1513
1514         --slash;
1515     }
1516
1517     /* Finally, skip multiple slashes. */
1518     while (slash != path) {
1519         if (*slash != '/')
1520             break;
1521
1522         --slash;
1523     }
1524
1525     if (slash == path) {
1526         if (directory)
1527             *directory = talloc_strdup (ctx, "");
1528         if (basename)
1529             *basename = path;
1530     } else {
1531         if (directory)
1532             *directory = talloc_strndup (ctx, path, slash - path + 1);
1533     }
1534
1535     return NOTMUCH_STATUS_SUCCESS;
1536 }
1537
1538 /* Find the document ID of the specified directory.
1539  *
1540  * If (flags & NOTMUCH_FIND_CREATE), a new directory document will be
1541  * created if one does not exist for 'path'.  Otherwise, if the
1542  * directory document does not exist, this sets *directory_id to
1543  * ((unsigned int)-1) and returns NOTMUCH_STATUS_SUCCESS.
1544  */
1545 notmuch_status_t
1546 _notmuch_database_find_directory_id (notmuch_database_t *notmuch,
1547                                      const char *path,
1548                                      notmuch_find_flags_t flags,
1549                                      unsigned int *directory_id)
1550 {
1551     notmuch_directory_t *directory;
1552     notmuch_status_t status;
1553
1554     if (path == NULL) {
1555         *directory_id = 0;
1556         return NOTMUCH_STATUS_SUCCESS;
1557     }
1558
1559     directory = _notmuch_directory_create (notmuch, path, flags, &status);
1560     if (status || !directory) {
1561         *directory_id = -1;
1562         return status;
1563     }
1564
1565     *directory_id = _notmuch_directory_get_document_id (directory);
1566
1567     notmuch_directory_destroy (directory);
1568
1569     return NOTMUCH_STATUS_SUCCESS;
1570 }
1571
1572 const char *
1573 _notmuch_database_get_directory_path (void *ctx,
1574                                       notmuch_database_t *notmuch,
1575                                       unsigned int doc_id)
1576 {
1577     Xapian::Document document;
1578
1579     document = find_document_for_doc_id (notmuch, doc_id);
1580
1581     return talloc_strdup (ctx, document.get_data ().c_str ());
1582 }
1583
1584 /* Given a legal 'filename' for the database, (either relative to
1585  * database path or absolute with initial components identical to
1586  * database path), return a new string (with 'ctx' as the talloc
1587  * owner) suitable for use as a direntry term value.
1588  *
1589  * If (flags & NOTMUCH_FIND_CREATE), the necessary directory documents
1590  * will be created in the database as needed.  Otherwise, if the
1591  * necessary directory documents do not exist, this sets
1592  * *direntry to NULL and returns NOTMUCH_STATUS_SUCCESS.
1593  */
1594 notmuch_status_t
1595 _notmuch_database_filename_to_direntry (void *ctx,
1596                                         notmuch_database_t *notmuch,
1597                                         const char *filename,
1598                                         notmuch_find_flags_t flags,
1599                                         char **direntry)
1600 {
1601     const char *relative, *directory, *basename;
1602     Xapian::docid directory_id;
1603     notmuch_status_t status;
1604
1605     relative = _notmuch_database_relative_path (notmuch, filename);
1606
1607     status = _notmuch_database_split_path (ctx, relative,
1608                                            &directory, &basename);
1609     if (status)
1610         return status;
1611
1612     status = _notmuch_database_find_directory_id (notmuch, directory, flags,
1613                                                   &directory_id);
1614     if (status || directory_id == (unsigned int)-1) {
1615         *direntry = NULL;
1616         return status;
1617     }
1618
1619     *direntry = talloc_asprintf (ctx, "%u:%s", directory_id, basename);
1620
1621     return NOTMUCH_STATUS_SUCCESS;
1622 }
1623
1624 /* Given a legal 'path' for the database, return the relative path.
1625  *
1626  * The return value will be a pointer to the original path contents,
1627  * and will be either the original string (if 'path' was relative) or
1628  * a portion of the string (if path was absolute and begins with the
1629  * database path).
1630  */
1631 const char *
1632 _notmuch_database_relative_path (notmuch_database_t *notmuch,
1633                                  const char *path)
1634 {
1635     const char *db_path, *relative;
1636     unsigned int db_path_len;
1637
1638     db_path = notmuch_database_get_path (notmuch);
1639     db_path_len = strlen (db_path);
1640
1641     relative = path;
1642
1643     if (*relative == '/') {
1644         while (*relative == '/' && *(relative+1) == '/')
1645             relative++;
1646
1647         if (strncmp (relative, db_path, db_path_len) == 0)
1648         {
1649             relative += db_path_len;
1650             while (*relative == '/')
1651                 relative++;
1652         }
1653     }
1654
1655     return relative;
1656 }
1657
1658 notmuch_status_t
1659 notmuch_database_get_directory (notmuch_database_t *notmuch,
1660                                 const char *path,
1661                                 notmuch_directory_t **directory)
1662 {
1663     notmuch_status_t status;
1664
1665     if (directory == NULL)
1666         return NOTMUCH_STATUS_NULL_POINTER;
1667     *directory = NULL;
1668
1669     try {
1670         *directory = _notmuch_directory_create (notmuch, path,
1671                                                 NOTMUCH_FIND_LOOKUP, &status);
1672     } catch (const Xapian::Error &error) {
1673         fprintf (stderr, "A Xapian exception occurred getting directory: %s.\n",
1674                  error.get_msg().c_str());
1675         notmuch->exception_reported = TRUE;
1676         status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
1677     }
1678     return status;
1679 }
1680
1681 /* Allocate a document ID that satisfies the following criteria:
1682  *
1683  * 1. The ID does not exist for any document in the Xapian database
1684  *
1685  * 2. The ID was not previously returned from this function
1686  *
1687  * 3. The ID is the smallest integer satisfying (1) and (2)
1688  *
1689  * This function will trigger an internal error if these constraints
1690  * cannot all be satisfied, (that is, the pool of available document
1691  * IDs has been exhausted).
1692  */
1693 unsigned int
1694 _notmuch_database_generate_doc_id (notmuch_database_t *notmuch)
1695 {
1696     assert (notmuch->last_doc_id >= notmuch->xapian_db->get_lastdocid ());
1697
1698     notmuch->last_doc_id++;
1699
1700     if (notmuch->last_doc_id == 0)
1701         INTERNAL_ERROR ("Xapian document IDs are exhausted.\n");
1702
1703     return notmuch->last_doc_id;
1704 }
1705
1706 static const char *
1707 _notmuch_database_generate_thread_id (notmuch_database_t *notmuch)
1708 {
1709     /* 16 bytes (+ terminator) for hexadecimal representation of
1710      * a 64-bit integer. */
1711     static char thread_id[17];
1712     Xapian::WritableDatabase *db;
1713
1714     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
1715
1716     notmuch->last_thread_id++;
1717
1718     sprintf (thread_id, "%016" PRIx64, notmuch->last_thread_id);
1719
1720     db->set_metadata ("last_thread_id", thread_id);
1721
1722     return thread_id;
1723 }
1724
1725 static char *
1726 _get_metadata_thread_id_key (void *ctx, const char *message_id)
1727 {
1728     if (strlen (message_id) > NOTMUCH_MESSAGE_ID_MAX)
1729         message_id = _message_id_compressed (ctx, message_id);
1730
1731     return talloc_asprintf (ctx, NOTMUCH_METADATA_THREAD_ID_PREFIX "%s",
1732                             message_id);
1733 }
1734
1735 /* Find the thread ID to which the message with 'message_id' belongs.
1736  *
1737  * Note: 'thread_id_ret' must not be NULL!
1738  * On success '*thread_id_ret' is set to a newly talloced string belonging to
1739  * 'ctx'.
1740  *
1741  * Note: If there is no message in the database with the given
1742  * 'message_id' then a new thread_id will be allocated for this
1743  * message and stored in the database metadata, (where this same
1744  * thread ID can be looked up if the message is added to the database
1745  * later).
1746  */
1747 static notmuch_status_t
1748 _resolve_message_id_to_thread_id (notmuch_database_t *notmuch,
1749                                   void *ctx,
1750                                   const char *message_id,
1751                                   const char **thread_id_ret)
1752 {
1753     notmuch_status_t status;
1754     notmuch_message_t *message;
1755     string thread_id_string;
1756     char *metadata_key;
1757     Xapian::WritableDatabase *db;
1758
1759     status = notmuch_database_find_message (notmuch, message_id, &message);
1760
1761     if (status)
1762         return status;
1763
1764     if (message) {
1765         *thread_id_ret = talloc_steal (ctx,
1766                                        notmuch_message_get_thread_id (message));
1767
1768         notmuch_message_destroy (message);
1769
1770         return NOTMUCH_STATUS_SUCCESS;
1771     }
1772
1773     /* Message has not been seen yet.
1774      *
1775      * We may have seen a reference to it already, in which case, we
1776      * can return the thread ID stored in the metadata. Otherwise, we
1777      * generate a new thread ID and store it there.
1778      */
1779     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
1780     metadata_key = _get_metadata_thread_id_key (ctx, message_id);
1781     thread_id_string = notmuch->xapian_db->get_metadata (metadata_key);
1782
1783     if (thread_id_string.empty()) {
1784         *thread_id_ret = talloc_strdup (ctx,
1785                                         _notmuch_database_generate_thread_id (notmuch));
1786         db->set_metadata (metadata_key, *thread_id_ret);
1787     } else {
1788         *thread_id_ret = talloc_strdup (ctx, thread_id_string.c_str());
1789     }
1790
1791     talloc_free (metadata_key);
1792
1793     return NOTMUCH_STATUS_SUCCESS;
1794 }
1795
1796 static notmuch_status_t
1797 _merge_threads (notmuch_database_t *notmuch,
1798                 const char *winner_thread_id,
1799                 const char *loser_thread_id)
1800 {
1801     Xapian::PostingIterator loser, loser_end;
1802     notmuch_message_t *message = NULL;
1803     notmuch_private_status_t private_status;
1804     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1805
1806     find_doc_ids (notmuch, "thread", loser_thread_id, &loser, &loser_end);
1807
1808     for ( ; loser != loser_end; loser++) {
1809         message = _notmuch_message_create (notmuch, notmuch,
1810                                            *loser, &private_status);
1811         if (message == NULL) {
1812             ret = COERCE_STATUS (private_status,
1813                                  "Cannot find document for doc_id from query");
1814             goto DONE;
1815         }
1816
1817         _notmuch_message_remove_term (message, "thread", loser_thread_id);
1818         _notmuch_message_add_term (message, "thread", winner_thread_id);
1819         _notmuch_message_sync (message);
1820
1821         notmuch_message_destroy (message);
1822         message = NULL;
1823     }
1824
1825   DONE:
1826     if (message)
1827         notmuch_message_destroy (message);
1828
1829     return ret;
1830 }
1831
1832 static void
1833 _my_talloc_free_for_g_hash (void *ptr)
1834 {
1835     talloc_free (ptr);
1836 }
1837
1838 static notmuch_status_t
1839 _notmuch_database_link_message_to_parents (notmuch_database_t *notmuch,
1840                                            notmuch_message_t *message,
1841                                            notmuch_message_file_t *message_file,
1842                                            const char **thread_id)
1843 {
1844     GHashTable *parents = NULL;
1845     const char *refs, *in_reply_to, *in_reply_to_message_id;
1846     const char *last_ref_message_id, *this_message_id;
1847     GList *l, *keys = NULL;
1848     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1849
1850     parents = g_hash_table_new_full (g_str_hash, g_str_equal,
1851                                      _my_talloc_free_for_g_hash, NULL);
1852     this_message_id = notmuch_message_get_message_id (message);
1853
1854     refs = _notmuch_message_file_get_header (message_file, "references");
1855     last_ref_message_id = parse_references (message,
1856                                             this_message_id,
1857                                             parents, refs);
1858
1859     in_reply_to = _notmuch_message_file_get_header (message_file, "in-reply-to");
1860     in_reply_to_message_id = parse_references (message,
1861                                                this_message_id,
1862                                                parents, in_reply_to);
1863
1864     /* For the parent of this message, use the last message ID of the
1865      * References header, if available.  If not, fall back to the
1866      * first message ID in the In-Reply-To header. */
1867     if (last_ref_message_id) {
1868         _notmuch_message_add_term (message, "replyto",
1869                                    last_ref_message_id);
1870     } else if (in_reply_to_message_id) {
1871         _notmuch_message_add_term (message, "replyto",
1872                              in_reply_to_message_id);
1873     }
1874
1875     keys = g_hash_table_get_keys (parents);
1876     for (l = keys; l; l = l->next) {
1877         char *parent_message_id;
1878         const char *parent_thread_id = NULL;
1879
1880         parent_message_id = (char *) l->data;
1881
1882         _notmuch_message_add_term (message, "reference",
1883                                    parent_message_id);
1884
1885         ret = _resolve_message_id_to_thread_id (notmuch,
1886                                                 message,
1887                                                 parent_message_id,
1888                                                 &parent_thread_id);
1889         if (ret)
1890             goto DONE;
1891
1892         if (*thread_id == NULL) {
1893             *thread_id = talloc_strdup (message, parent_thread_id);
1894             _notmuch_message_add_term (message, "thread", *thread_id);
1895         } else if (strcmp (*thread_id, parent_thread_id)) {
1896             ret = _merge_threads (notmuch, *thread_id, parent_thread_id);
1897             if (ret)
1898                 goto DONE;
1899         }
1900     }
1901
1902   DONE:
1903     if (keys)
1904         g_list_free (keys);
1905     if (parents)
1906         g_hash_table_unref (parents);
1907
1908     return ret;
1909 }
1910
1911 static notmuch_status_t
1912 _notmuch_database_link_message_to_children (notmuch_database_t *notmuch,
1913                                             notmuch_message_t *message,
1914                                             const char **thread_id)
1915 {
1916     const char *message_id = notmuch_message_get_message_id (message);
1917     Xapian::PostingIterator child, children_end;
1918     notmuch_message_t *child_message = NULL;
1919     const char *child_thread_id;
1920     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1921     notmuch_private_status_t private_status;
1922
1923     find_doc_ids (notmuch, "reference", message_id, &child, &children_end);
1924
1925     for ( ; child != children_end; child++) {
1926
1927         child_message = _notmuch_message_create (message, notmuch,
1928                                                  *child, &private_status);
1929         if (child_message == NULL) {
1930             ret = COERCE_STATUS (private_status,
1931                                  "Cannot find document for doc_id from query");
1932             goto DONE;
1933         }
1934
1935         child_thread_id = notmuch_message_get_thread_id (child_message);
1936         if (*thread_id == NULL) {
1937             *thread_id = talloc_strdup (message, child_thread_id);
1938             _notmuch_message_add_term (message, "thread", *thread_id);
1939         } else if (strcmp (*thread_id, child_thread_id)) {
1940             _notmuch_message_remove_term (child_message, "reference",
1941                                           message_id);
1942             _notmuch_message_sync (child_message);
1943             ret = _merge_threads (notmuch, *thread_id, child_thread_id);
1944             if (ret)
1945                 goto DONE;
1946         }
1947
1948         notmuch_message_destroy (child_message);
1949         child_message = NULL;
1950     }
1951
1952   DONE:
1953     if (child_message)
1954         notmuch_message_destroy (child_message);
1955
1956     return ret;
1957 }
1958
1959 /* Given a (mostly empty) 'message' and its corresponding
1960  * 'message_file' link it to existing threads in the database.
1961  *
1962  * The first check is in the metadata of the database to see if we
1963  * have pre-allocated a thread_id in advance for this message, (which
1964  * would have happened if a message was previously added that
1965  * referenced this one).
1966  *
1967  * Second, we look at 'message_file' and its link-relevant headers
1968  * (References and In-Reply-To) for message IDs.
1969  *
1970  * Finally, we look in the database for existing message that
1971  * reference 'message'.
1972  *
1973  * In all cases, we assign to the current message the first thread_id
1974  * found (through either parent or child). We will also merge any
1975  * existing, distinct threads where this message belongs to both,
1976  * (which is not uncommon when messages are processed out of order).
1977  *
1978  * Finally, if no thread ID has been found through parent or child, we
1979  * call _notmuch_message_generate_thread_id to generate a new thread
1980  * ID. This should only happen for new, top-level messages, (no
1981  * References or In-Reply-To header in this message, and no previously
1982  * added message refers to this message).
1983  */
1984 static notmuch_status_t
1985 _notmuch_database_link_message (notmuch_database_t *notmuch,
1986                                 notmuch_message_t *message,
1987                                 notmuch_message_file_t *message_file)
1988 {
1989     notmuch_status_t status;
1990     const char *message_id, *thread_id = NULL;
1991     char *metadata_key;
1992     string stored_id;
1993
1994     message_id = notmuch_message_get_message_id (message);
1995     metadata_key = _get_metadata_thread_id_key (message, message_id);
1996
1997     /* Check if we have already seen related messages to this one.
1998      * If we have then use the thread_id that we stored at that time.
1999      */
2000     stored_id = notmuch->xapian_db->get_metadata (metadata_key);
2001     if (! stored_id.empty()) {
2002         Xapian::WritableDatabase *db;
2003
2004         db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
2005
2006         /* Clear the metadata for this message ID. We don't need it
2007          * anymore. */
2008         db->set_metadata (metadata_key, "");
2009         thread_id = stored_id.c_str();
2010
2011         _notmuch_message_add_term (message, "thread", thread_id);
2012     }
2013     talloc_free (metadata_key);
2014
2015     status = _notmuch_database_link_message_to_parents (notmuch, message,
2016                                                         message_file,
2017                                                         &thread_id);
2018     if (status)
2019         return status;
2020
2021     status = _notmuch_database_link_message_to_children (notmuch, message,
2022                                                          &thread_id);
2023     if (status)
2024         return status;
2025
2026     /* If not part of any existing thread, generate a new thread ID. */
2027     if (thread_id == NULL) {
2028         thread_id = _notmuch_database_generate_thread_id (notmuch);
2029
2030         _notmuch_message_add_term (message, "thread", thread_id);
2031     }
2032
2033     return NOTMUCH_STATUS_SUCCESS;
2034 }
2035
2036 notmuch_status_t
2037 notmuch_database_add_message (notmuch_database_t *notmuch,
2038                               const char *filename,
2039                               notmuch_message_t **message_ret)
2040 {
2041     notmuch_message_file_t *message_file;
2042     notmuch_message_t *message = NULL;
2043     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS, ret2;
2044     notmuch_private_status_t private_status;
2045
2046     const char *date, *header;
2047     const char *from, *to, *subject;
2048     char *message_id = NULL;
2049
2050     if (message_ret)
2051         *message_ret = NULL;
2052
2053     ret = _notmuch_database_ensure_writable (notmuch);
2054     if (ret)
2055         return ret;
2056
2057     message_file = _notmuch_message_file_open (filename);
2058     if (message_file == NULL)
2059         return NOTMUCH_STATUS_FILE_ERROR;
2060
2061     /* Adding a message may change many documents.  Do this all
2062      * atomically. */
2063     ret = notmuch_database_begin_atomic (notmuch);
2064     if (ret)
2065         goto DONE;
2066
2067     /* Parse message up front to get better error status. */
2068     ret = _notmuch_message_file_parse (message_file);
2069     if (ret)
2070         goto DONE;
2071
2072     try {
2073         /* Before we do any real work, (especially before doing a
2074          * potential SHA-1 computation on the entire file's contents),
2075          * let's make sure that what we're looking at looks like an
2076          * actual email message.
2077          */
2078         from = _notmuch_message_file_get_header (message_file, "from");
2079         subject = _notmuch_message_file_get_header (message_file, "subject");
2080         to = _notmuch_message_file_get_header (message_file, "to");
2081
2082         if ((from == NULL || *from == '\0') &&
2083             (subject == NULL || *subject == '\0') &&
2084             (to == NULL || *to == '\0'))
2085         {
2086             ret = NOTMUCH_STATUS_FILE_NOT_EMAIL;
2087             goto DONE;
2088         }
2089
2090         /* Now that we're sure it's mail, the first order of business
2091          * is to find a message ID (or else create one ourselves). */
2092
2093         header = _notmuch_message_file_get_header (message_file, "message-id");
2094         if (header && *header != '\0') {
2095             message_id = _parse_message_id (message_file, header, NULL);
2096
2097             /* So the header value isn't RFC-compliant, but it's
2098              * better than no message-id at all. */
2099             if (message_id == NULL)
2100                 message_id = talloc_strdup (message_file, header);
2101
2102             /* If a message ID is too long, substitute its sha1 instead. */
2103             if (message_id && strlen (message_id) > NOTMUCH_MESSAGE_ID_MAX) {
2104                 char *compressed = _message_id_compressed (message_file,
2105                                                            message_id);
2106                 talloc_free (message_id);
2107                 message_id = compressed;
2108             }
2109         }
2110
2111         if (message_id == NULL ) {
2112             /* No message-id at all, let's generate one by taking a
2113              * hash over the file's contents. */
2114             char *sha1 = _notmuch_sha1_of_file (filename);
2115
2116             /* If that failed too, something is really wrong. Give up. */
2117             if (sha1 == NULL) {
2118                 ret = NOTMUCH_STATUS_FILE_ERROR;
2119                 goto DONE;
2120             }
2121
2122             message_id = talloc_asprintf (message_file,
2123                                           "notmuch-sha1-%s", sha1);
2124             free (sha1);
2125         }
2126
2127         /* Now that we have a message ID, we get a message object,
2128          * (which may or may not reference an existing document in the
2129          * database). */
2130
2131         message = _notmuch_message_create_for_message_id (notmuch,
2132                                                           message_id,
2133                                                           &private_status);
2134
2135         talloc_free (message_id);
2136
2137         if (message == NULL) {
2138             ret = COERCE_STATUS (private_status,
2139                                  "Unexpected status value from _notmuch_message_create_for_message_id");
2140             goto DONE;
2141         }
2142
2143         _notmuch_message_add_filename (message, filename);
2144
2145         /* Is this a newly created message object? */
2146         if (private_status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) {
2147             _notmuch_message_add_term (message, "type", "mail");
2148
2149             ret = _notmuch_database_link_message (notmuch, message,
2150                                                   message_file);
2151             if (ret)
2152                 goto DONE;
2153
2154             date = _notmuch_message_file_get_header (message_file, "date");
2155             _notmuch_message_set_header_values (message, date, from, subject);
2156
2157             ret = _notmuch_message_index_file (message, message_file);
2158             if (ret)
2159                 goto DONE;
2160         } else {
2161             ret = NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID;
2162         }
2163
2164         _notmuch_message_sync (message);
2165     } catch (const Xapian::Error &error) {
2166         fprintf (stderr, "A Xapian exception occurred adding message: %s.\n",
2167                  error.get_msg().c_str());
2168         notmuch->exception_reported = TRUE;
2169         ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
2170         goto DONE;
2171     }
2172
2173   DONE:
2174     if (message) {
2175         if ((ret == NOTMUCH_STATUS_SUCCESS ||
2176              ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) && message_ret)
2177             *message_ret = message;
2178         else
2179             notmuch_message_destroy (message);
2180     }
2181
2182     if (message_file)
2183         _notmuch_message_file_close (message_file);
2184
2185     ret2 = notmuch_database_end_atomic (notmuch);
2186     if ((ret == NOTMUCH_STATUS_SUCCESS ||
2187          ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) &&
2188         ret2 != NOTMUCH_STATUS_SUCCESS)
2189         ret = ret2;
2190
2191     return ret;
2192 }
2193
2194 notmuch_status_t
2195 notmuch_database_remove_message (notmuch_database_t *notmuch,
2196                                  const char *filename)
2197 {
2198     notmuch_status_t status;
2199     notmuch_message_t *message;
2200
2201     status = notmuch_database_find_message_by_filename (notmuch, filename,
2202                                                         &message);
2203
2204     if (status == NOTMUCH_STATUS_SUCCESS && message) {
2205             status = _notmuch_message_remove_filename (message, filename);
2206             if (status == NOTMUCH_STATUS_SUCCESS)
2207                 _notmuch_message_delete (message);
2208             else if (status == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID)
2209                 _notmuch_message_sync (message);
2210
2211             notmuch_message_destroy (message);
2212     }
2213
2214     return status;
2215 }
2216
2217 notmuch_status_t
2218 notmuch_database_find_message_by_filename (notmuch_database_t *notmuch,
2219                                            const char *filename,
2220                                            notmuch_message_t **message_ret)
2221 {
2222     void *local;
2223     const char *prefix = _find_prefix ("file-direntry");
2224     char *direntry, *term;
2225     Xapian::PostingIterator i, end;
2226     notmuch_status_t status;
2227
2228     if (message_ret == NULL)
2229         return NOTMUCH_STATUS_NULL_POINTER;
2230
2231     if (! (notmuch->features & NOTMUCH_FEATURE_FILE_TERMS))
2232         return NOTMUCH_STATUS_UPGRADE_REQUIRED;
2233
2234     /* return NULL on any failure */
2235     *message_ret = NULL;
2236
2237     local = talloc_new (notmuch);
2238
2239     try {
2240         status = _notmuch_database_filename_to_direntry (
2241             local, notmuch, filename, NOTMUCH_FIND_LOOKUP, &direntry);
2242         if (status || !direntry)
2243             goto DONE;
2244
2245         term = talloc_asprintf (local, "%s%s", prefix, direntry);
2246
2247         find_doc_ids_for_term (notmuch, term, &i, &end);
2248
2249         if (i != end) {
2250             notmuch_private_status_t private_status;
2251
2252             *message_ret = _notmuch_message_create (notmuch, notmuch, *i,
2253                                                     &private_status);
2254             if (*message_ret == NULL)
2255                 status = NOTMUCH_STATUS_OUT_OF_MEMORY;
2256         }
2257     } catch (const Xapian::Error &error) {
2258         fprintf (stderr, "Error: A Xapian exception occurred finding message by filename: %s\n",
2259                  error.get_msg().c_str());
2260         notmuch->exception_reported = TRUE;
2261         status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
2262     }
2263
2264   DONE:
2265     talloc_free (local);
2266
2267     if (status && *message_ret) {
2268         notmuch_message_destroy (*message_ret);
2269         *message_ret = NULL;
2270     }
2271     return status;
2272 }
2273
2274 notmuch_string_list_t *
2275 _notmuch_database_get_terms_with_prefix (void *ctx, Xapian::TermIterator &i,
2276                                          Xapian::TermIterator &end,
2277                                          const char *prefix)
2278 {
2279     int prefix_len = strlen (prefix);
2280     notmuch_string_list_t *list;
2281
2282     list = _notmuch_string_list_create (ctx);
2283     if (unlikely (list == NULL))
2284         return NULL;
2285
2286     for (i.skip_to (prefix); i != end; i++) {
2287         /* Terminate loop at first term without desired prefix. */
2288         if (strncmp ((*i).c_str (), prefix, prefix_len))
2289             break;
2290
2291         _notmuch_string_list_append (list, (*i).c_str () + prefix_len);
2292     }
2293
2294     return list;
2295 }
2296
2297 notmuch_tags_t *
2298 notmuch_database_get_all_tags (notmuch_database_t *db)
2299 {
2300     Xapian::TermIterator i, end;
2301     notmuch_string_list_t *tags;
2302
2303     try {
2304         i = db->xapian_db->allterms_begin();
2305         end = db->xapian_db->allterms_end();
2306         tags = _notmuch_database_get_terms_with_prefix (db, i, end,
2307                                                         _find_prefix ("tag"));
2308         _notmuch_string_list_sort (tags);
2309         return _notmuch_tags_create (db, tags);
2310     } catch (const Xapian::Error &error) {
2311         fprintf (stderr, "A Xapian exception occurred getting tags: %s.\n",
2312                  error.get_msg().c_str());
2313         db->exception_reported = TRUE;
2314         return NULL;
2315     }
2316 }