Fix printf for when uint64_t != unsigned long long int
[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
23 #include <iostream>
24
25 #include <sys/time.h>
26 #include <signal.h>
27 #include <xapian.h>
28
29 #include <glib.h> /* g_free, GPtrArray, GHashTable */
30
31 using namespace std;
32
33 #define ARRAY_SIZE(arr) (sizeof (arr) / sizeof (arr[0]))
34
35 typedef struct {
36     const char *name;
37     const char *prefix;
38 } prefix_t;
39
40 #define NOTMUCH_DATABASE_VERSION 1
41
42 #define STRINGIFY(s) _SUB_STRINGIFY(s)
43 #define _SUB_STRINGIFY(s) #s
44
45 /* Here's the current schema for our database (for NOTMUCH_DATABASE_VERSION):
46  *
47  * We currently have two different types of documents: mail and directory.
48  *
49  * Mail document
50  * -------------
51  * A mail document is associated with a particular email message file
52  * on disk. It is indexed with the following prefixed terms which the
53  * database uses to construct threads, etc.:
54  *
55  *    Single terms of given prefix:
56  *
57  *      type:   mail
58  *
59  *      id:     Unique ID of mail, (from Message-ID header or generated
60  *              as "notmuch-sha1-<sha1_sum_of_entire_file>.
61  *
62  *      thread: The ID of the thread to which the mail belongs
63  *
64  *      replyto: The ID from the In-Reply-To header of the mail (if any).
65  *
66  *    Multiple terms of given prefix:
67  *
68  *      reference: All message IDs from In-Reply-To and Re ferences
69  *                 headers in the message.
70  *
71  *      tag:       Any tags associated with this message by the user.
72  *
73  *      file-direntry:  A colon-separated pair of values
74  *                      (INTEGER:STRING), where INTEGER is the
75  *                      document ID of a directory document, and
76  *                      STRING is the name of a file within that
77  *                      directory for this mail message.
78  *
79  *    A mail document also has two values:
80  *
81  *      TIMESTAMP:      The time_t value corresponding to the message's
82  *                      Date header.
83  *
84  *      MESSAGE_ID:     The unique ID of the mail mess (see "id" above)
85  *
86  * In addition, terms from the content of the message are added with
87  * "from", "to", "attachment", and "subject" prefixes for use by the
88  * user in searching. But the database doesn't really care itself
89  * about any of these.
90  *
91  * The data portion of a mail document is empty.
92  *
93  * Directory document
94  * ------------------
95  * A directory document is used by a client of the notmuch library to
96  * maintain data necessary to allow for efficient polling of mail
97  * directories.
98  *
99  * All directory documents contain one term:
100  *
101  *      directory:      The directory path (relative to the database path)
102  *                      Or the SHA1 sum of the directory path (if the
103  *                      path itself is too long to fit in a Xapian
104  *                      term).
105  *
106  * And all directory documents for directories other than top-level
107  * directories also contain the following term:
108  *
109  *      directory-direntry: A colon-separated pair of values
110  *                          (INTEGER:STRING), where INTEGER is the
111  *                          document ID of the parent directory
112  *                          document, and STRING is the name of this
113  *                          directory within that parent.
114  *
115  * All directory documents have a single value:
116  *
117  *      TIMESTAMP:      The mtime of the directory (at last scan)
118  *
119  * The data portion of a directory document contains the path of the
120  * directory (relative to the database path).
121  */
122
123 /* With these prefix values we follow the conventions published here:
124  *
125  * http://xapian.org/docs/omega/termprefixes.html
126  *
127  * as much as makes sense. Note that I took some liberty in matching
128  * the reserved prefix values to notmuch concepts, (for example, 'G'
129  * is documented as "newsGroup (or similar entity - e.g. a web forum
130  * name)", for which I think the thread is the closest analogue in
131  * notmuch. This in spite of the fact that we will eventually be
132  * storing mailing-list messages where 'G' for "mailing list name"
133  * might be even a closer analogue. I'm treating the single-character
134  * prefixes preferentially for core notmuch concepts (which will be
135  * nearly universal to all mail messages).
136  */
137
138 prefix_t BOOLEAN_PREFIX_INTERNAL[] = {
139     { "type",                   "T" },
140     { "reference",              "XREFERENCE" },
141     { "replyto",                "XREPLYTO" },
142     { "directory",              "XDIRECTORY" },
143     { "file-direntry",          "XFDIRENTRY" },
144     { "directory-direntry",     "XDDIRENTRY" },
145 };
146
147 prefix_t BOOLEAN_PREFIX_EXTERNAL[] = {
148     { "thread",                 "G" },
149     { "tag",                    "K" },
150     { "id",                     "Q" }
151 };
152
153 prefix_t PROBABILISTIC_PREFIX[]= {
154     { "from",                   "XFROM" },
155     { "to",                     "XTO" },
156     { "attachment",             "XATTACHMENT" },
157     { "subject",                "XSUBJECT"}
158 };
159
160 int
161 _internal_error (const char *format, ...)
162 {
163     va_list va_args;
164
165     va_start (va_args, format);
166
167     fprintf (stderr, "Internal error: ");
168     vfprintf (stderr, format, va_args);
169
170     exit (1);
171
172     return 1;
173 }
174
175 const char *
176 _find_prefix (const char *name)
177 {
178     unsigned int i;
179
180     for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_INTERNAL); i++) {
181         if (strcmp (name, BOOLEAN_PREFIX_INTERNAL[i].name) == 0)
182             return BOOLEAN_PREFIX_INTERNAL[i].prefix;
183     }
184
185     for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) {
186         if (strcmp (name, BOOLEAN_PREFIX_EXTERNAL[i].name) == 0)
187             return BOOLEAN_PREFIX_EXTERNAL[i].prefix;
188     }
189
190     for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) {
191         if (strcmp (name, PROBABILISTIC_PREFIX[i].name) == 0)
192             return PROBABILISTIC_PREFIX[i].prefix;
193     }
194
195     INTERNAL_ERROR ("No prefix exists for '%s'\n", name);
196
197     return "";
198 }
199
200 const char *
201 notmuch_status_to_string (notmuch_status_t status)
202 {
203     switch (status) {
204     case NOTMUCH_STATUS_SUCCESS:
205         return "No error occurred";
206     case NOTMUCH_STATUS_OUT_OF_MEMORY:
207         return "Out of memory";
208     case NOTMUCH_STATUS_READ_ONLY_DATABASE:
209         return "Attempt to write to a read-only database";
210     case NOTMUCH_STATUS_XAPIAN_EXCEPTION:
211         return "A Xapian exception occurred";
212     case NOTMUCH_STATUS_FILE_ERROR:
213         return "Something went wrong trying to read or write a file";
214     case NOTMUCH_STATUS_FILE_NOT_EMAIL:
215         return "File is not an email";
216     case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
217         return "Message ID is identical to a message in database";
218     case NOTMUCH_STATUS_NULL_POINTER:
219         return "Erroneous NULL pointer";
220     case NOTMUCH_STATUS_TAG_TOO_LONG:
221         return "Tag value is too long (exceeds NOTMUCH_TAG_MAX)";
222     case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW:
223         return "Unbalanced number of calls to notmuch_message_freeze/thaw";
224     default:
225     case NOTMUCH_STATUS_LAST_STATUS:
226         return "Unknown error status value";
227     }
228 }
229
230 static void
231 find_doc_ids_for_term (notmuch_database_t *notmuch,
232                        const char *term,
233                        Xapian::PostingIterator *begin,
234                        Xapian::PostingIterator *end)
235 {
236     *begin = notmuch->xapian_db->postlist_begin (term);
237
238     *end = notmuch->xapian_db->postlist_end (term);
239 }
240
241 static void
242 find_doc_ids (notmuch_database_t *notmuch,
243               const char *prefix_name,
244               const char *value,
245               Xapian::PostingIterator *begin,
246               Xapian::PostingIterator *end)
247 {
248     char *term;
249
250     term = talloc_asprintf (notmuch, "%s%s",
251                             _find_prefix (prefix_name), value);
252
253     find_doc_ids_for_term (notmuch, term, begin, end);
254
255     talloc_free (term);
256 }
257
258 notmuch_private_status_t
259 _notmuch_database_find_unique_doc_id (notmuch_database_t *notmuch,
260                                       const char *prefix_name,
261                                       const char *value,
262                                       unsigned int *doc_id)
263 {
264     Xapian::PostingIterator i, end;
265
266     find_doc_ids (notmuch, prefix_name, value, &i, &end);
267
268     if (i == end) {
269         *doc_id = 0;
270         return NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND;
271     }
272
273     *doc_id = *i;
274
275 #if DEBUG_DATABASE_SANITY
276     i++;
277
278     if (i != end)
279         INTERNAL_ERROR ("Term %s:%s is not unique as expected.\n",
280                         prefix_name, value);
281 #endif
282
283     return NOTMUCH_PRIVATE_STATUS_SUCCESS;
284 }
285
286 static Xapian::Document
287 find_document_for_doc_id (notmuch_database_t *notmuch, unsigned doc_id)
288 {
289     return notmuch->xapian_db->get_document (doc_id);
290 }
291
292 notmuch_message_t *
293 notmuch_database_find_message (notmuch_database_t *notmuch,
294                                const char *message_id)
295 {
296     notmuch_private_status_t status;
297     unsigned int doc_id;
298
299     status = _notmuch_database_find_unique_doc_id (notmuch, "id",
300                                                    message_id, &doc_id);
301
302     if (status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND)
303         return NULL;
304
305     return _notmuch_message_create (notmuch, notmuch, doc_id, NULL);
306 }
307
308 /* Advance 'str' past any whitespace or RFC 822 comments. A comment is
309  * a (potentially nested) parenthesized sequence with '\' used to
310  * escape any character (including parentheses).
311  *
312  * If the sequence to be skipped continues to the end of the string,
313  * then 'str' will be left pointing at the final terminating '\0'
314  * character.
315  */
316 static void
317 skip_space_and_comments (const char **str)
318 {
319     const char *s;
320
321     s = *str;
322     while (*s && (isspace (*s) || *s == '(')) {
323         while (*s && isspace (*s))
324             s++;
325         if (*s == '(') {
326             int nesting = 1;
327             s++;
328             while (*s && nesting) {
329                 if (*s == '(') {
330                     nesting++;
331                 } else if (*s == ')') {
332                     nesting--;
333                 } else if (*s == '\\') {
334                     if (*(s+1))
335                         s++;
336                 }
337                 s++;
338             }
339         }
340     }
341
342     *str = s;
343 }
344
345 /* Parse an RFC 822 message-id, discarding whitespace, any RFC 822
346  * comments, and the '<' and '>' delimeters.
347  *
348  * If not NULL, then *next will be made to point to the first character
349  * not parsed, (possibly pointing to the final '\0' terminator.
350  *
351  * Returns a newly talloc'ed string belonging to 'ctx'.
352  *
353  * Returns NULL if there is any error parsing the message-id. */
354 static char *
355 _parse_message_id (void *ctx, const char *message_id, const char **next)
356 {
357     const char *s, *end;
358     char *result;
359
360     if (message_id == NULL || *message_id == '\0')
361         return NULL;
362
363     s = message_id;
364
365     skip_space_and_comments (&s);
366
367     /* Skip any unstructured text as well. */
368     while (*s && *s != '<')
369         s++;
370
371     if (*s == '<') {
372         s++;
373     } else {
374         if (next)
375             *next = s;
376         return NULL;
377     }
378
379     skip_space_and_comments (&s);
380
381     end = s;
382     while (*end && *end != '>')
383         end++;
384     if (next) {
385         if (*end)
386             *next = end + 1;
387         else
388             *next = end;
389     }
390
391     if (end > s && *end == '>')
392         end--;
393     if (end <= s)
394         return NULL;
395
396     result = talloc_strndup (ctx, s, end - s + 1);
397
398     /* Finally, collapse any whitespace that is within the message-id
399      * itself. */
400     {
401         char *r;
402         int len;
403
404         for (r = result, len = strlen (r); *r; r++, len--)
405             if (*r == ' ' || *r == '\t')
406                 memmove (r, r+1, len);
407     }
408
409     return result;
410 }
411
412 /* Parse a References header value, putting a (talloc'ed under 'ctx')
413  * copy of each referenced message-id into 'hash'.
414  *
415  * We explicitly avoid including any reference identical to
416  * 'message_id' in the result (to avoid mass confusion when a single
417  * message references itself cyclically---and yes, mail messages are
418  * not infrequent in the wild that do this---don't ask me why).
419 */
420 static void
421 parse_references (void *ctx,
422                   const char *message_id,
423                   GHashTable *hash,
424                   const char *refs)
425 {
426     char *ref;
427
428     if (refs == NULL || *refs == '\0')
429         return;
430
431     while (*refs) {
432         ref = _parse_message_id (ctx, refs, &refs);
433
434         if (ref && strcmp (ref, message_id))
435             g_hash_table_insert (hash, ref, NULL);
436     }
437 }
438
439 notmuch_database_t *
440 notmuch_database_create (const char *path)
441 {
442     notmuch_database_t *notmuch = NULL;
443     char *notmuch_path = NULL;
444     struct stat st;
445     int err;
446
447     if (path == NULL) {
448         fprintf (stderr, "Error: Cannot create a database for a NULL path.\n");
449         goto DONE;
450     }
451
452     err = stat (path, &st);
453     if (err) {
454         fprintf (stderr, "Error: Cannot create database at %s: %s.\n",
455                  path, strerror (errno));
456         goto DONE;
457     }
458
459     if (! S_ISDIR (st.st_mode)) {
460         fprintf (stderr, "Error: Cannot create database at %s: Not a directory.\n",
461                  path);
462         goto DONE;
463     }
464
465     notmuch_path = talloc_asprintf (NULL, "%s/%s", path, ".notmuch");
466
467     err = mkdir (notmuch_path, 0755);
468
469     if (err) {
470         fprintf (stderr, "Error: Cannot create directory %s: %s.\n",
471                  notmuch_path, strerror (errno));
472         goto DONE;
473     }
474
475     notmuch = notmuch_database_open (path,
476                                      NOTMUCH_DATABASE_MODE_READ_WRITE);
477     notmuch_database_upgrade (notmuch, NULL, NULL);
478
479   DONE:
480     if (notmuch_path)
481         talloc_free (notmuch_path);
482
483     return notmuch;
484 }
485
486 notmuch_status_t
487 _notmuch_database_ensure_writable (notmuch_database_t *notmuch)
488 {
489     if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY) {
490         fprintf (stderr, "Cannot write to a read-only database.\n");
491         return NOTMUCH_STATUS_READ_ONLY_DATABASE;
492     }
493
494     return NOTMUCH_STATUS_SUCCESS;
495 }
496
497 notmuch_database_t *
498 notmuch_database_open (const char *path,
499                        notmuch_database_mode_t mode)
500 {
501     notmuch_database_t *notmuch = NULL;
502     char *notmuch_path = NULL, *xapian_path = NULL;
503     struct stat st;
504     int err;
505     unsigned int i, version;
506
507     if (asprintf (&notmuch_path, "%s/%s", path, ".notmuch") == -1) {
508         notmuch_path = NULL;
509         fprintf (stderr, "Out of memory\n");
510         goto DONE;
511     }
512
513     err = stat (notmuch_path, &st);
514     if (err) {
515         fprintf (stderr, "Error opening database at %s: %s\n",
516                  notmuch_path, strerror (errno));
517         goto DONE;
518     }
519
520     if (asprintf (&xapian_path, "%s/%s", notmuch_path, "xapian") == -1) {
521         xapian_path = NULL;
522         fprintf (stderr, "Out of memory\n");
523         goto DONE;
524     }
525
526     notmuch = talloc (NULL, notmuch_database_t);
527     notmuch->exception_reported = FALSE;
528     notmuch->path = talloc_strdup (notmuch, path);
529
530     if (notmuch->path[strlen (notmuch->path) - 1] == '/')
531         notmuch->path[strlen (notmuch->path) - 1] = '\0';
532
533     notmuch->needs_upgrade = FALSE;
534     notmuch->mode = mode;
535     try {
536         string last_thread_id;
537
538         if (mode == NOTMUCH_DATABASE_MODE_READ_WRITE) {
539             notmuch->xapian_db = new Xapian::WritableDatabase (xapian_path,
540                                                                Xapian::DB_CREATE_OR_OPEN);
541             version = notmuch_database_get_version (notmuch);
542
543             if (version > NOTMUCH_DATABASE_VERSION) {
544                 fprintf (stderr,
545                          "Error: Notmuch database at %s\n"
546                          "       has a newer database format version (%u) than supported by this\n"
547                          "       version of notmuch (%u). Refusing to open this database in\n"
548                          "       read-write mode.\n",
549                          notmuch_path, version, NOTMUCH_DATABASE_VERSION);
550                 notmuch->mode = NOTMUCH_DATABASE_MODE_READ_ONLY;
551                 notmuch_database_close (notmuch);
552                 notmuch = NULL;
553                 goto DONE;
554             }
555
556             if (version < NOTMUCH_DATABASE_VERSION)
557                 notmuch->needs_upgrade = TRUE;
558         } else {
559             notmuch->xapian_db = new Xapian::Database (xapian_path);
560             version = notmuch_database_get_version (notmuch);
561             if (version > NOTMUCH_DATABASE_VERSION)
562             {
563                 fprintf (stderr,
564                          "Warning: Notmuch database at %s\n"
565                          "         has a newer database format version (%u) than supported by this\n"
566                          "         version of notmuch (%u). Some operations may behave incorrectly,\n"
567                          "         (but the database will not be harmed since it is being opened\n"
568                          "         in read-only mode).\n",
569                          notmuch_path, version, NOTMUCH_DATABASE_VERSION);
570             }
571         }
572
573         last_thread_id = notmuch->xapian_db->get_metadata ("last_thread_id");
574         if (last_thread_id.empty ()) {
575             notmuch->last_thread_id = 0;
576         } else {
577             const char *str;
578             char *end;
579
580             str = last_thread_id.c_str ();
581             notmuch->last_thread_id = strtoull (str, &end, 16);
582             if (*end != '\0')
583                 INTERNAL_ERROR ("Malformed database last_thread_id: %s", str);
584         }
585
586         notmuch->query_parser = new Xapian::QueryParser;
587         notmuch->term_gen = new Xapian::TermGenerator;
588         notmuch->term_gen->set_stemmer (Xapian::Stem ("english"));
589         notmuch->value_range_processor = new Xapian::NumberValueRangeProcessor (NOTMUCH_VALUE_TIMESTAMP);
590
591         notmuch->query_parser->set_default_op (Xapian::Query::OP_AND);
592         notmuch->query_parser->set_database (*notmuch->xapian_db);
593         notmuch->query_parser->set_stemmer (Xapian::Stem ("english"));
594         notmuch->query_parser->set_stemming_strategy (Xapian::QueryParser::STEM_SOME);
595         notmuch->query_parser->add_valuerangeprocessor (notmuch->value_range_processor);
596
597         for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) {
598             prefix_t *prefix = &BOOLEAN_PREFIX_EXTERNAL[i];
599             notmuch->query_parser->add_boolean_prefix (prefix->name,
600                                                        prefix->prefix);
601         }
602
603         for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) {
604             prefix_t *prefix = &PROBABILISTIC_PREFIX[i];
605             notmuch->query_parser->add_prefix (prefix->name, prefix->prefix);
606         }
607     } catch (const Xapian::Error &error) {
608         fprintf (stderr, "A Xapian exception occurred opening database: %s\n",
609                  error.get_msg().c_str());
610         notmuch = NULL;
611     }
612
613   DONE:
614     if (notmuch_path)
615         free (notmuch_path);
616     if (xapian_path)
617         free (xapian_path);
618
619     return notmuch;
620 }
621
622 void
623 notmuch_database_close (notmuch_database_t *notmuch)
624 {
625     try {
626         if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_WRITE)
627             (static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db))->flush ();
628     } catch (const Xapian::Error &error) {
629         if (! notmuch->exception_reported) {
630             fprintf (stderr, "Error: A Xapian exception occurred flushing database: %s\n",
631                      error.get_msg().c_str());
632         }
633     }
634
635     delete notmuch->term_gen;
636     delete notmuch->query_parser;
637     delete notmuch->xapian_db;
638     delete notmuch->value_range_processor;
639     talloc_free (notmuch);
640 }
641
642 const char *
643 notmuch_database_get_path (notmuch_database_t *notmuch)
644 {
645     return notmuch->path;
646 }
647
648 unsigned int
649 notmuch_database_get_version (notmuch_database_t *notmuch)
650 {
651     unsigned int version;
652     string version_string;
653     const char *str;
654     char *end;
655
656     version_string = notmuch->xapian_db->get_metadata ("version");
657     if (version_string.empty ())
658         return 0;
659
660     str = version_string.c_str ();
661     if (str == NULL || *str == '\0')
662         return 0;
663
664     version = strtoul (str, &end, 10);
665     if (*end != '\0')
666         INTERNAL_ERROR ("Malformed database version: %s", str);
667
668     return version;
669 }
670
671 notmuch_bool_t
672 notmuch_database_needs_upgrade (notmuch_database_t *notmuch)
673 {
674     return notmuch->needs_upgrade;
675 }
676
677 static volatile sig_atomic_t do_progress_notify = 0;
678
679 static void
680 handle_sigalrm (unused (int signal))
681 {
682     do_progress_notify = 1;
683 }
684
685 /* Upgrade the current database.
686  *
687  * After opening a database in read-write mode, the client should
688  * check if an upgrade is needed (notmuch_database_needs_upgrade) and
689  * if so, upgrade with this function before making any modifications.
690  *
691  * The optional progress_notify callback can be used by the caller to
692  * provide progress indication to the user. If non-NULL it will be
693  * called periodically with 'count' as the number of messages upgraded
694  * so far and 'total' the overall number of messages that will be
695  * converted.
696  */
697 notmuch_status_t
698 notmuch_database_upgrade (notmuch_database_t *notmuch,
699                           void (*progress_notify) (void *closure,
700                                                    double progress),
701                           void *closure)
702 {
703     Xapian::WritableDatabase *db;
704     struct sigaction action;
705     struct itimerval timerval;
706     notmuch_bool_t timer_is_active = FALSE;
707     unsigned int version;
708     notmuch_status_t status;
709     unsigned int count = 0, total = 0;
710
711     status = _notmuch_database_ensure_writable (notmuch);
712     if (status)
713         return status;
714
715     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
716
717     version = notmuch_database_get_version (notmuch);
718
719     if (version >= NOTMUCH_DATABASE_VERSION)
720         return NOTMUCH_STATUS_SUCCESS;
721
722     if (progress_notify) {
723         /* Setup our handler for SIGALRM */
724         memset (&action, 0, sizeof (struct sigaction));
725         action.sa_handler = handle_sigalrm;
726         sigemptyset (&action.sa_mask);
727         action.sa_flags = SA_RESTART;
728         sigaction (SIGALRM, &action, NULL);
729
730         /* Then start a timer to send SIGALRM once per second. */
731         timerval.it_interval.tv_sec = 1;
732         timerval.it_interval.tv_usec = 0;
733         timerval.it_value.tv_sec = 1;
734         timerval.it_value.tv_usec = 0;
735         setitimer (ITIMER_REAL, &timerval, NULL);
736
737         timer_is_active = TRUE;
738     }
739
740     /* Before version 1, each message document had its filename in the
741      * data field. Copy that into the new format by calling
742      * notmuch_message_add_filename.
743      */
744     if (version < 1) {
745         notmuch_query_t *query = notmuch_query_create (notmuch, "");
746         notmuch_messages_t *messages;
747         notmuch_message_t *message;
748         char *filename;
749         Xapian::TermIterator t, t_end;
750
751         total = notmuch_query_count_messages (query);
752
753         for (messages = notmuch_query_search_messages (query);
754              notmuch_messages_has_more (messages);
755              notmuch_messages_advance (messages))
756         {
757             if (do_progress_notify) {
758                 progress_notify (closure, (double) count / total);
759                 do_progress_notify = 0;
760             }
761
762             message = notmuch_messages_get (messages);
763
764             filename = _notmuch_message_talloc_copy_data (message);
765             if (filename && *filename != '\0') {
766                 _notmuch_message_add_filename (message, filename);
767                 _notmuch_message_sync (message);
768             }
769             talloc_free (filename);
770
771             notmuch_message_destroy (message);
772
773             count++;
774         }
775
776         notmuch_query_destroy (query);
777
778         /* Also, before version 1 we stored directory timestamps in
779          * XTIMESTAMP documents instead of the current XDIRECTORY
780          * documents. So copy those as well. */
781
782         t_end = notmuch->xapian_db->allterms_end ("XTIMESTAMP");
783
784         for (t = notmuch->xapian_db->allterms_begin ("XTIMESTAMP");
785              t != t_end;
786              t++)
787         {
788             Xapian::PostingIterator p, p_end;
789             std::string term = *t;
790
791             p_end = notmuch->xapian_db->postlist_end (term);
792
793             for (p = notmuch->xapian_db->postlist_begin (term);
794                  p != p_end;
795                  p++)
796             {
797                 Xapian::Document document;
798                 time_t mtime;
799                 notmuch_directory_t *directory;
800
801                 if (do_progress_notify) {
802                     progress_notify (closure, (double) count / total);
803                     do_progress_notify = 0;
804                 }
805
806                 document = find_document_for_doc_id (notmuch, *p);
807                 mtime = Xapian::sortable_unserialise (
808                     document.get_value (NOTMUCH_VALUE_TIMESTAMP));
809
810                 directory = notmuch_database_get_directory (notmuch,
811                                                             term.c_str() + 10);
812                 notmuch_directory_set_mtime (directory, mtime);
813                 notmuch_directory_destroy (directory);
814             }
815         }
816     }
817
818     db->set_metadata ("version", STRINGIFY (NOTMUCH_DATABASE_VERSION));
819     db->flush ();
820
821     /* Now that the upgrade is complete we can remove the old data
822      * and documents that are no longer needed. */
823     if (version < 1) {
824         notmuch_query_t *query = notmuch_query_create (notmuch, "");
825         notmuch_messages_t *messages;
826         notmuch_message_t *message;
827         char *filename;
828
829         for (messages = notmuch_query_search_messages (query);
830              notmuch_messages_has_more (messages);
831              notmuch_messages_advance (messages))
832         {
833             if (do_progress_notify) {
834                 progress_notify (closure, (double) count / total);
835                 do_progress_notify = 0;
836             }
837
838             message = notmuch_messages_get (messages);
839
840             filename = _notmuch_message_talloc_copy_data (message);
841             if (filename && *filename != '\0') {
842                 _notmuch_message_clear_data (message);
843                 _notmuch_message_sync (message);
844             }
845             talloc_free (filename);
846
847             notmuch_message_destroy (message);
848         }
849
850         notmuch_query_destroy (query);
851     }
852
853     if (version < 1) {
854         Xapian::TermIterator t, t_end;
855
856         t_end = notmuch->xapian_db->allterms_end ("XTIMESTAMP");
857
858         for (t = notmuch->xapian_db->allterms_begin ("XTIMESTAMP");
859              t != t_end;
860              t++)
861         {
862             Xapian::PostingIterator p, p_end;
863             std::string term = *t;
864
865             p_end = notmuch->xapian_db->postlist_end (term);
866
867             for (p = notmuch->xapian_db->postlist_begin (term);
868                  p != p_end;
869                  p++)
870             {
871                 if (do_progress_notify) {
872                     progress_notify (closure, (double) count / total);
873                     do_progress_notify = 0;
874                 }
875
876                 db->delete_document (*p);
877             }
878         }
879     }
880
881     if (timer_is_active) {
882         /* Now stop the timer. */
883         timerval.it_interval.tv_sec = 0;
884         timerval.it_interval.tv_usec = 0;
885         timerval.it_value.tv_sec = 0;
886         timerval.it_value.tv_usec = 0;
887         setitimer (ITIMER_REAL, &timerval, NULL);
888
889         /* And disable the signal handler. */
890         action.sa_handler = SIG_IGN;
891         sigaction (SIGALRM, &action, NULL);
892     }
893
894     return NOTMUCH_STATUS_SUCCESS;
895 }
896
897 /* We allow the user to use arbitrarily long paths for directories. But
898  * we have a term-length limit. So if we exceed that, we'll use the
899  * SHA-1 of the path for the database term.
900  *
901  * Note: This function may return the original value of 'path'. If it
902  * does not, then the caller is responsible to free() the returned
903  * value.
904  */
905 const char *
906 _notmuch_database_get_directory_db_path (const char *path)
907 {
908     int term_len = strlen (_find_prefix ("directory")) + strlen (path);
909
910     if (term_len > NOTMUCH_TERM_MAX)
911         return notmuch_sha1_of_string (path);
912     else
913         return path;
914 }
915
916 /* Given a path, split it into two parts: the directory part is all
917  * components except for the last, and the basename is that last
918  * component. Getting the return-value for either part is optional
919  * (the caller can pass NULL).
920  *
921  * The original 'path' can represent either a regular file or a
922  * directory---the splitting will be carried out in the same way in
923  * either case. Trailing slashes on 'path' will be ignored, and any
924  * cases of multiple '/' characters appearing in series will be
925  * treated as a single '/'.
926  *
927  * Allocation (if any) will have 'ctx' as the talloc owner. But
928  * pointers will be returned within the original path string whenever
929  * possible.
930  *
931  * Note: If 'path' is non-empty and contains no non-trailing slash,
932  * (that is, consists of a filename with no parent directory), then
933  * the directory returned will be an empty string. However, if 'path'
934  * is an empty string, then both directory and basename will be
935  * returned as NULL.
936  */
937 notmuch_status_t
938 _notmuch_database_split_path (void *ctx,
939                               const char *path,
940                               const char **directory,
941                               const char **basename)
942 {
943     const char *slash;
944
945     if (path == NULL || *path == '\0') {
946         if (directory)
947             *directory = NULL;
948         if (basename)
949             *basename = NULL;
950         return NOTMUCH_STATUS_SUCCESS;
951     }
952
953     /* Find the last slash (not counting a trailing slash), if any. */
954
955     slash = path + strlen (path) - 1;
956
957     /* First, skip trailing slashes. */
958     while (slash != path) {
959         if (*slash != '/')
960             break;
961
962         --slash;
963     }
964
965     /* Then, find a slash. */
966     while (slash != path) {
967         if (*slash == '/')
968             break;
969
970         if (basename)
971             *basename = slash;
972
973         --slash;
974     }
975
976     /* Finally, skip multiple slashes. */
977     while (slash != path) {
978         if (*slash != '/')
979             break;
980
981         --slash;
982     }
983
984     if (slash == path) {
985         if (directory)
986             *directory = talloc_strdup (ctx, "");
987         if (basename)
988             *basename = path;
989     } else {
990         if (directory)
991             *directory = talloc_strndup (ctx, path, slash - path + 1);
992     }
993
994     return NOTMUCH_STATUS_SUCCESS;
995 }
996
997 notmuch_status_t
998 _notmuch_database_find_directory_id (notmuch_database_t *notmuch,
999                                      const char *path,
1000                                      unsigned int *directory_id)
1001 {
1002     notmuch_directory_t *directory;
1003     notmuch_status_t status;
1004
1005     if (path == NULL) {
1006         *directory_id = 0;
1007         return NOTMUCH_STATUS_SUCCESS;
1008     }
1009
1010     directory = _notmuch_directory_create (notmuch, path, &status);
1011     if (status) {
1012         *directory_id = -1;
1013         return status;
1014     }
1015
1016     *directory_id = _notmuch_directory_get_document_id (directory);
1017
1018     notmuch_directory_destroy (directory);
1019
1020     return NOTMUCH_STATUS_SUCCESS;
1021 }
1022
1023 const char *
1024 _notmuch_database_get_directory_path (void *ctx,
1025                                       notmuch_database_t *notmuch,
1026                                       unsigned int doc_id)
1027 {
1028     Xapian::Document document;
1029
1030     document = find_document_for_doc_id (notmuch, doc_id);
1031
1032     return talloc_strdup (ctx, document.get_data ().c_str ());
1033 }
1034
1035 /* Given a legal 'filename' for the database, (either relative to
1036  * database path or absolute with initial components identical to
1037  * database path), return a new string (with 'ctx' as the talloc
1038  * owner) suitable for use as a direntry term value.
1039  *
1040  * The necessary directory documents will be created in the database
1041  * as needed.
1042  */
1043 notmuch_status_t
1044 _notmuch_database_filename_to_direntry (void *ctx,
1045                                         notmuch_database_t *notmuch,
1046                                         const char *filename,
1047                                         char **direntry)
1048 {
1049     const char *relative, *directory, *basename;
1050     Xapian::docid directory_id;
1051     notmuch_status_t status;
1052
1053     relative = _notmuch_database_relative_path (notmuch, filename);
1054
1055     status = _notmuch_database_split_path (ctx, relative,
1056                                            &directory, &basename);
1057     if (status)
1058         return status;
1059
1060     status = _notmuch_database_find_directory_id (notmuch, directory,
1061                                                   &directory_id);
1062     if (status)
1063         return status;
1064
1065     *direntry = talloc_asprintf (ctx, "%u:%s", directory_id, basename);
1066
1067     return NOTMUCH_STATUS_SUCCESS;
1068 }
1069
1070 /* Given a legal 'path' for the database, return the relative path.
1071  *
1072  * The return value will be a pointer to the originl path contents,
1073  * and will be either the original string (if 'path' was relative) or
1074  * a portion of the string (if path was absolute and begins with the
1075  * database path).
1076  */
1077 const char *
1078 _notmuch_database_relative_path (notmuch_database_t *notmuch,
1079                                  const char *path)
1080 {
1081     const char *db_path, *relative;
1082     unsigned int db_path_len;
1083
1084     db_path = notmuch_database_get_path (notmuch);
1085     db_path_len = strlen (db_path);
1086
1087     relative = path;
1088
1089     if (*relative == '/') {
1090         while (*relative == '/' && *(relative+1) == '/')
1091             relative++;
1092
1093         if (strncmp (relative, db_path, db_path_len) == 0)
1094         {
1095             relative += db_path_len;
1096             while (*relative == '/')
1097                 relative++;
1098         }
1099     }
1100
1101     return relative;
1102 }
1103
1104 notmuch_directory_t *
1105 notmuch_database_get_directory (notmuch_database_t *notmuch,
1106                                 const char *path)
1107 {
1108     notmuch_status_t status;
1109
1110     return _notmuch_directory_create (notmuch, path, &status);
1111 }
1112
1113 /* Find the thread ID to which the message with 'message_id' belongs.
1114  *
1115  * Returns NULL if no message with message ID 'message_id' is in the
1116  * database.
1117  *
1118  * Otherwise, returns a newly talloced string belonging to 'ctx'.
1119  */
1120 static const char *
1121 _resolve_message_id_to_thread_id (notmuch_database_t *notmuch,
1122                                   void *ctx,
1123                                   const char *message_id)
1124 {
1125     notmuch_message_t *message;
1126     const char *ret = NULL;
1127
1128     message = notmuch_database_find_message (notmuch, message_id);
1129     if (message == NULL)
1130         goto DONE;
1131
1132     ret = talloc_steal (ctx, notmuch_message_get_thread_id (message));
1133
1134   DONE:
1135     if (message)
1136         notmuch_message_destroy (message);
1137
1138     return ret;
1139 }
1140
1141 static notmuch_status_t
1142 _merge_threads (notmuch_database_t *notmuch,
1143                 const char *winner_thread_id,
1144                 const char *loser_thread_id)
1145 {
1146     Xapian::PostingIterator loser, loser_end;
1147     notmuch_message_t *message = NULL;
1148     notmuch_private_status_t private_status;
1149     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1150
1151     find_doc_ids (notmuch, "thread", loser_thread_id, &loser, &loser_end);
1152
1153     for ( ; loser != loser_end; loser++) {
1154         message = _notmuch_message_create (notmuch, notmuch,
1155                                            *loser, &private_status);
1156         if (message == NULL) {
1157             ret = COERCE_STATUS (private_status,
1158                                  "Cannot find document for doc_id from query");
1159             goto DONE;
1160         }
1161
1162         _notmuch_message_remove_term (message, "thread", loser_thread_id);
1163         _notmuch_message_add_term (message, "thread", winner_thread_id);
1164         _notmuch_message_sync (message);
1165
1166         notmuch_message_destroy (message);
1167         message = NULL;
1168     }
1169
1170   DONE:
1171     if (message)
1172         notmuch_message_destroy (message);
1173
1174     return ret;
1175 }
1176
1177 static void
1178 _my_talloc_free_for_g_hash (void *ptr)
1179 {
1180     talloc_free (ptr);
1181 }
1182
1183 static notmuch_status_t
1184 _notmuch_database_link_message_to_parents (notmuch_database_t *notmuch,
1185                                            notmuch_message_t *message,
1186                                            notmuch_message_file_t *message_file,
1187                                            const char **thread_id)
1188 {
1189     GHashTable *parents = NULL;
1190     const char *refs, *in_reply_to, *in_reply_to_message_id;
1191     GList *l, *keys = NULL;
1192     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1193
1194     parents = g_hash_table_new_full (g_str_hash, g_str_equal,
1195                                      _my_talloc_free_for_g_hash, NULL);
1196
1197     refs = notmuch_message_file_get_header (message_file, "references");
1198     parse_references (message, notmuch_message_get_message_id (message),
1199                       parents, refs);
1200
1201     in_reply_to = notmuch_message_file_get_header (message_file, "in-reply-to");
1202     parse_references (message, notmuch_message_get_message_id (message),
1203                       parents, in_reply_to);
1204
1205     /* Carefully avoid adding any self-referential in-reply-to term. */
1206     in_reply_to_message_id = _parse_message_id (message, in_reply_to, NULL);
1207     if (in_reply_to_message_id &&
1208         strcmp (in_reply_to_message_id,
1209                 notmuch_message_get_message_id (message)))
1210     {
1211         _notmuch_message_add_term (message, "replyto",
1212                              _parse_message_id (message, in_reply_to, NULL));
1213     }
1214
1215     keys = g_hash_table_get_keys (parents);
1216     for (l = keys; l; l = l->next) {
1217         char *parent_message_id;
1218         const char *parent_thread_id;
1219
1220         parent_message_id = (char *) l->data;
1221         parent_thread_id = _resolve_message_id_to_thread_id (notmuch,
1222                                                              message,
1223                                                              parent_message_id);
1224
1225         if (parent_thread_id == NULL) {
1226             _notmuch_message_add_term (message, "reference",
1227                                        parent_message_id);
1228         } else {
1229             if (*thread_id == NULL) {
1230                 *thread_id = talloc_strdup (message, parent_thread_id);
1231                 _notmuch_message_add_term (message, "thread", *thread_id);
1232             } else if (strcmp (*thread_id, parent_thread_id)) {
1233                 ret = _merge_threads (notmuch, *thread_id, parent_thread_id);
1234                 if (ret)
1235                     goto DONE;
1236             }
1237         }
1238     }
1239
1240   DONE:
1241     if (keys)
1242         g_list_free (keys);
1243     if (parents)
1244         g_hash_table_unref (parents);
1245
1246     return ret;
1247 }
1248
1249 static notmuch_status_t
1250 _notmuch_database_link_message_to_children (notmuch_database_t *notmuch,
1251                                             notmuch_message_t *message,
1252                                             const char **thread_id)
1253 {
1254     const char *message_id = notmuch_message_get_message_id (message);
1255     Xapian::PostingIterator child, children_end;
1256     notmuch_message_t *child_message = NULL;
1257     const char *child_thread_id;
1258     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1259     notmuch_private_status_t private_status;
1260
1261     find_doc_ids (notmuch, "reference", message_id, &child, &children_end);
1262
1263     for ( ; child != children_end; child++) {
1264
1265         child_message = _notmuch_message_create (message, notmuch,
1266                                                  *child, &private_status);
1267         if (child_message == NULL) {
1268             ret = COERCE_STATUS (private_status,
1269                                  "Cannot find document for doc_id from query");
1270             goto DONE;
1271         }
1272
1273         child_thread_id = notmuch_message_get_thread_id (child_message);
1274         if (*thread_id == NULL) {
1275             *thread_id = talloc_strdup (message, child_thread_id);
1276             _notmuch_message_add_term (message, "thread", *thread_id);
1277         } else if (strcmp (*thread_id, child_thread_id)) {
1278             _notmuch_message_remove_term (child_message, "reference",
1279                                           message_id);
1280             _notmuch_message_sync (child_message);
1281             ret = _merge_threads (notmuch, *thread_id, child_thread_id);
1282             if (ret)
1283                 goto DONE;
1284         }
1285
1286         notmuch_message_destroy (child_message);
1287         child_message = NULL;
1288     }
1289
1290   DONE:
1291     if (child_message)
1292         notmuch_message_destroy (child_message);
1293
1294     return ret;
1295 }
1296
1297 static const char *
1298 _notmuch_database_generate_thread_id (notmuch_database_t *notmuch)
1299 {
1300     /* 16 bytes (+ terminator) for hexadecimal representation of
1301      * a 64-bit integer. */
1302     static char thread_id[17];
1303     Xapian::WritableDatabase *db;
1304
1305     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
1306
1307     notmuch->last_thread_id++;
1308
1309     sprintf (thread_id, "%016" PRIx64, notmuch->last_thread_id);
1310
1311     db->set_metadata ("last_thread_id", thread_id);
1312
1313     return thread_id;
1314 }
1315
1316 /* Given a (mostly empty) 'message' and its corresponding
1317  * 'message_file' link it to existing threads in the database.
1318  *
1319  * We first look at 'message_file' and its link-relevant headers
1320  * (References and In-Reply-To) for message IDs. We also look in the
1321  * database for existing message that reference 'message'. In either
1322  * case, we will assign to the current message the first thread_id
1323  * found (through either parent or child). We will also merge any
1324  * existing, distinct threads where this message belongs to both,
1325  * (which is not uncommon when mesages are processed out of order).
1326  *
1327  * Finally, if not thread ID has been found through parent or child,
1328  * we call _notmuch_message_generate_thread_id to generate a new
1329  * generates a new thread ID if the message doesn't connect to any
1330  * existing threads.
1331  */
1332 static notmuch_status_t
1333 _notmuch_database_link_message (notmuch_database_t *notmuch,
1334                                 notmuch_message_t *message,
1335                                 notmuch_message_file_t *message_file)
1336 {
1337     notmuch_status_t status;
1338     const char *thread_id = NULL;
1339
1340     status = _notmuch_database_link_message_to_parents (notmuch, message,
1341                                                         message_file,
1342                                                         &thread_id);
1343     if (status)
1344         return status;
1345
1346     status = _notmuch_database_link_message_to_children (notmuch, message,
1347                                                          &thread_id);
1348     if (status)
1349         return status;
1350
1351     /* If not part of any existing thread, generate a new thread ID. */
1352     if (thread_id == NULL) {
1353         thread_id = _notmuch_database_generate_thread_id (notmuch);
1354
1355         _notmuch_message_add_term (message, "thread", thread_id);
1356     }
1357
1358     return NOTMUCH_STATUS_SUCCESS;
1359 }
1360
1361 notmuch_status_t
1362 notmuch_database_add_message (notmuch_database_t *notmuch,
1363                               const char *filename,
1364                               notmuch_message_t **message_ret)
1365 {
1366     notmuch_message_file_t *message_file;
1367     notmuch_message_t *message = NULL;
1368     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1369     notmuch_private_status_t private_status;
1370
1371     const char *date, *header;
1372     const char *from, *to, *subject;
1373     char *message_id = NULL;
1374
1375     if (message_ret)
1376         *message_ret = NULL;
1377
1378     ret = _notmuch_database_ensure_writable (notmuch);
1379     if (ret)
1380         return ret;
1381
1382     message_file = notmuch_message_file_open (filename);
1383     if (message_file == NULL)
1384         return NOTMUCH_STATUS_FILE_ERROR;
1385
1386     notmuch_message_file_restrict_headers (message_file,
1387                                            "date",
1388                                            "from",
1389                                            "in-reply-to",
1390                                            "message-id",
1391                                            "references",
1392                                            "subject",
1393                                            "to",
1394                                            (char *) NULL);
1395
1396     try {
1397         /* Before we do any real work, (especially before doing a
1398          * potential SHA-1 computation on the entire file's contents),
1399          * let's make sure that what we're looking at looks like an
1400          * actual email message.
1401          */
1402         from = notmuch_message_file_get_header (message_file, "from");
1403         subject = notmuch_message_file_get_header (message_file, "subject");
1404         to = notmuch_message_file_get_header (message_file, "to");
1405
1406         if ((from == NULL || *from == '\0') &&
1407             (subject == NULL || *subject == '\0') &&
1408             (to == NULL || *to == '\0'))
1409         {
1410             ret = NOTMUCH_STATUS_FILE_NOT_EMAIL;
1411             goto DONE;
1412         }
1413
1414         /* Now that we're sure it's mail, the first order of business
1415          * is to find a message ID (or else create one ourselves). */
1416
1417         header = notmuch_message_file_get_header (message_file, "message-id");
1418         if (header && *header != '\0') {
1419             message_id = _parse_message_id (message_file, header, NULL);
1420
1421             /* So the header value isn't RFC-compliant, but it's
1422              * better than no message-id at all. */
1423             if (message_id == NULL)
1424                 message_id = talloc_strdup (message_file, header);
1425
1426             /* Reject a Message ID that's too long. */
1427             if (message_id && strlen (message_id) + 1 > NOTMUCH_TERM_MAX) {
1428                 talloc_free (message_id);
1429                 message_id = NULL;
1430             }
1431         }
1432
1433         if (message_id == NULL ) {
1434             /* No message-id at all, let's generate one by taking a
1435              * hash over the file's contents. */
1436             char *sha1 = notmuch_sha1_of_file (filename);
1437
1438             /* If that failed too, something is really wrong. Give up. */
1439             if (sha1 == NULL) {
1440                 ret = NOTMUCH_STATUS_FILE_ERROR;
1441                 goto DONE;
1442             }
1443
1444             message_id = talloc_asprintf (message_file,
1445                                           "notmuch-sha1-%s", sha1);
1446             free (sha1);
1447         }
1448
1449         /* Now that we have a message ID, we get a message object,
1450          * (which may or may not reference an existing document in the
1451          * database). */
1452
1453         message = _notmuch_message_create_for_message_id (notmuch,
1454                                                           message_id,
1455                                                           &private_status);
1456
1457         talloc_free (message_id);
1458
1459         if (message == NULL) {
1460             ret = COERCE_STATUS (private_status,
1461                                  "Unexpected status value from _notmuch_message_create_for_message_id");
1462             goto DONE;
1463         }
1464
1465         _notmuch_message_add_filename (message, filename);
1466
1467         /* Is this a newly created message object? */
1468         if (private_status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) {
1469             _notmuch_message_add_term (message, "type", "mail");
1470
1471             ret = _notmuch_database_link_message (notmuch, message,
1472                                                   message_file);
1473             if (ret)
1474                 goto DONE;
1475
1476             date = notmuch_message_file_get_header (message_file, "date");
1477             _notmuch_message_set_date (message, date);
1478
1479             _notmuch_message_index_file (message, filename);
1480         } else {
1481             ret = NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID;
1482         }
1483
1484         _notmuch_message_sync (message);
1485     } catch (const Xapian::Error &error) {
1486         fprintf (stderr, "A Xapian exception occurred adding message: %s.\n",
1487                  error.get_description().c_str());
1488         notmuch->exception_reported = TRUE;
1489         ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
1490         goto DONE;
1491     }
1492
1493   DONE:
1494     if (message) {
1495         if (ret == NOTMUCH_STATUS_SUCCESS && message_ret)
1496             *message_ret = message;
1497         else
1498             notmuch_message_destroy (message);
1499     }
1500
1501     if (message_file)
1502         notmuch_message_file_close (message_file);
1503
1504     return ret;
1505 }
1506
1507 notmuch_status_t
1508 notmuch_database_remove_message (notmuch_database_t *notmuch,
1509                                  const char *filename)
1510 {
1511     Xapian::WritableDatabase *db;
1512     void *local = talloc_new (notmuch);
1513     const char *prefix = _find_prefix ("file-direntry");
1514     char *direntry, *term;
1515     Xapian::PostingIterator i, end;
1516     Xapian::Document document;
1517     notmuch_status_t status;
1518
1519     status = _notmuch_database_ensure_writable (notmuch);
1520     if (status)
1521         return status;
1522
1523     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
1524
1525     status = _notmuch_database_filename_to_direntry (local, notmuch,
1526                                                      filename, &direntry);
1527     if (status)
1528         return status;
1529
1530     term = talloc_asprintf (notmuch, "%s%s", prefix, direntry);
1531
1532     find_doc_ids_for_term (notmuch, term, &i, &end);
1533
1534     for ( ; i != end; i++) {
1535         Xapian::TermIterator j;
1536
1537         document = find_document_for_doc_id (notmuch, *i);
1538
1539         document.remove_term (term);
1540
1541         j = document.termlist_begin ();
1542         j.skip_to (prefix);
1543
1544         /* Was this the last file-direntry in the message? */
1545         if (j == document.termlist_end () ||
1546             strncmp ((*j).c_str (), prefix, strlen (prefix)))
1547         {
1548             db->delete_document (document.get_docid ());
1549             status = NOTMUCH_STATUS_SUCCESS;
1550         } else {
1551             db->replace_document (document.get_docid (), document);
1552             status = NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID;
1553         }
1554     }
1555
1556     talloc_free (local);
1557
1558     return status;
1559 }
1560
1561 notmuch_tags_t *
1562 _notmuch_convert_tags (void *ctx, Xapian::TermIterator &i,
1563                        Xapian::TermIterator &end)
1564 {
1565     const char *prefix = _find_prefix ("tag");
1566     notmuch_tags_t *tags;
1567     std::string tag;
1568
1569     /* Currently this iteration is written with the assumption that
1570      * "tag" has a single-character prefix. */
1571     assert (strlen (prefix) == 1);
1572
1573     tags = _notmuch_tags_create (ctx);
1574     if (unlikely (tags == NULL))
1575         return NULL;
1576
1577     i.skip_to (prefix);
1578
1579     while (i != end) {
1580         tag = *i;
1581
1582         if (tag.empty () || tag[0] != *prefix)
1583             break;
1584
1585         _notmuch_tags_add_tag (tags, tag.c_str () + 1);
1586
1587         i++;
1588     }
1589
1590     _notmuch_tags_prepare_iterator (tags);
1591
1592     return tags;
1593 }
1594
1595 notmuch_tags_t *
1596 notmuch_database_get_all_tags (notmuch_database_t *db)
1597 {
1598     Xapian::TermIterator i, end;
1599     i = db->xapian_db->allterms_begin();
1600     end = db->xapian_db->allterms_end();
1601     return _notmuch_convert_tags(db, i, end);
1602 }