23ddd4ae1314b2186b7839364b06cc0d25b5a575
[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 <xapian.h>
26
27 #include <glib.h> /* g_free, GPtrArray, GHashTable */
28
29 using namespace std;
30
31 #define ARRAY_SIZE(arr) (sizeof (arr) / sizeof (arr[0]))
32
33 typedef struct {
34     const char *name;
35     const char *prefix;
36 } prefix_t;
37
38 /* Here's the current schema for our database:
39  *
40  * We currently have two different types of documents: mail and timestamps.
41  *
42  * Mail document
43  * -------------
44  * A mail document is associated with a particular email message file
45  * on disk. It is indexed with the following prefixed terms which the
46  * database uses to construct threads, etc.:
47  *
48  *    Single terms of given prefix:
49  *
50  *      type:   mail
51  *
52  *      id:     Unique ID of mail, (from Message-ID header or generated
53  *              as "notmuch-sha1-<sha1_sum_of_entire_file>.
54  *
55  *      thread: The ID of the thread to which the mail belongs
56  *
57  *      replyto: The ID from the In-Reply-To header of the mail (if any).
58  *
59  *    Multiple terms of given prefix:
60  *
61  *      reference: All message IDs from In-Reply-To and Re ferences
62  *                 headers in the message.
63  *
64  *      tag:       Any tags associated with this message by the user.
65  *
66  *    A mail document also has two values:
67  *
68  *      TIMESTAMP:      The time_t value corresponding to the message's
69  *                      Date header.
70  *
71  *      MESSAGE_ID:     The unique ID of the mail mess (see "id" above)
72  *
73  * In addition, terms from the content of the message are added with
74  * "from", "to", "attachment", and "subject" prefixes for use by the
75  * user in searching. But the database doesn't really care itself
76  * about any of these.
77  *
78  * Timestamp document
79  * ------------------
80  * A timestamp document is used by a client of the notmuch library to
81  * maintain data necessary to allow for efficient polling of mail
82  * directories. The notmuch library does no interpretation of
83  * timestamps, but merely allows the user to store and retrieve
84  * timestamps as name/value pairs.
85  *
86  * The timestamp document is indexed with a single prefixed term:
87  *
88  *      timestamp:      The user's key value (likely a directory name)
89  *
90  * and has a single value:
91  *
92  *      TIMESTAMP:      The time_t value from the user.
93  */
94
95 /* With these prefix values we follow the conventions published here:
96  *
97  * http://xapian.org/docs/omega/termprefixes.html
98  *
99  * as much as makes sense. Note that I took some liberty in matching
100  * the reserved prefix values to notmuch concepts, (for example, 'G'
101  * is documented as "newsGroup (or similar entity - e.g. a web forum
102  * name)", for which I think the thread is the closest analogue in
103  * notmuch. This in spite of the fact that we will eventually be
104  * storing mailing-list messages where 'G' for "mailing list name"
105  * might be even a closer analogue. I'm treating the single-character
106  * prefixes preferentially for core notmuch concepts (which will be
107  * nearly universal to all mail messages).
108  */
109
110 prefix_t BOOLEAN_PREFIX_INTERNAL[] = {
111     { "type", "T" },
112     { "reference", "XREFERENCE" },
113     { "replyto", "XREPLYTO" },
114     { "timestamp", "XTIMESTAMP" },
115 };
116
117 prefix_t BOOLEAN_PREFIX_EXTERNAL[] = {
118     { "thread", "G" },
119     { "tag", "K" },
120     { "id", "Q" }
121 };
122
123 prefix_t PROBABILISTIC_PREFIX[]= {
124     { "from", "XFROM" },
125     { "to", "XTO" },
126     { "attachment", "XATTACHMENT" },
127     { "subject", "XSUBJECT"}
128 };
129
130 int
131 _internal_error (const char *format, ...)
132 {
133     va_list va_args;
134
135     va_start (va_args, format);
136
137     fprintf (stderr, "Internal error: ");
138     vfprintf (stderr, format, va_args);
139
140     exit (1);
141
142     return 1;
143 }
144
145 const char *
146 _find_prefix (const char *name)
147 {
148     unsigned int i;
149
150     for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_INTERNAL); i++) {
151         if (strcmp (name, BOOLEAN_PREFIX_INTERNAL[i].name) == 0)
152             return BOOLEAN_PREFIX_INTERNAL[i].prefix;
153     }
154
155     for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) {
156         if (strcmp (name, BOOLEAN_PREFIX_EXTERNAL[i].name) == 0)
157             return BOOLEAN_PREFIX_EXTERNAL[i].prefix;
158     }
159
160     for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) {
161         if (strcmp (name, PROBABILISTIC_PREFIX[i].name) == 0)
162             return PROBABILISTIC_PREFIX[i].prefix;
163     }
164
165     INTERNAL_ERROR ("No prefix exists for '%s'\n", name);
166
167     return "";
168 }
169
170 const char *
171 notmuch_status_to_string (notmuch_status_t status)
172 {
173     switch (status) {
174     case NOTMUCH_STATUS_SUCCESS:
175         return "No error occurred";
176     case NOTMUCH_STATUS_OUT_OF_MEMORY:
177         return "Out of memory";
178     case NOTMUCH_STATUS_READONLY_DATABASE:
179         return "The database is read-only";
180     case NOTMUCH_STATUS_XAPIAN_EXCEPTION:
181         return "A Xapian exception occurred";
182     case NOTMUCH_STATUS_FILE_ERROR:
183         return "Something went wrong trying to read or write a file";
184     case NOTMUCH_STATUS_FILE_NOT_EMAIL:
185         return "File is not an email";
186     case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
187         return "Message ID is identical to a message in database";
188     case NOTMUCH_STATUS_NULL_POINTER:
189         return "Erroneous NULL pointer";
190     case NOTMUCH_STATUS_TAG_TOO_LONG:
191         return "Tag value is too long (exceeds NOTMUCH_TAG_MAX)";
192     case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW:
193         return "Unbalanced number of calls to notmuch_message_freeze/thaw";
194     default:
195     case NOTMUCH_STATUS_LAST_STATUS:
196         return "Unknown error status value";
197     }
198 }
199
200 static void
201 find_doc_ids (notmuch_database_t *notmuch,
202               const char *prefix_name,
203               const char *value,
204               Xapian::PostingIterator *begin,
205               Xapian::PostingIterator *end)
206 {
207     Xapian::PostingIterator i;
208     char *term;
209
210     term = talloc_asprintf (notmuch, "%s%s",
211                             _find_prefix (prefix_name), value);
212
213     *begin = notmuch->xapian_db->postlist_begin (term);
214
215     *end = notmuch->xapian_db->postlist_end (term);
216
217     talloc_free (term);
218 }
219
220 static notmuch_private_status_t
221 find_unique_doc_id (notmuch_database_t *notmuch,
222                     const char *prefix_name,
223                     const char *value,
224                     unsigned int *doc_id)
225 {
226     Xapian::PostingIterator i, end;
227
228     find_doc_ids (notmuch, prefix_name, value, &i, &end);
229
230     if (i == end) {
231         *doc_id = 0;
232         return NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND;
233     } else {
234         *doc_id = *i;
235         return NOTMUCH_PRIVATE_STATUS_SUCCESS;
236     }
237 }
238
239 static Xapian::Document
240 find_document_for_doc_id (notmuch_database_t *notmuch, unsigned doc_id)
241 {
242     return notmuch->xapian_db->get_document (doc_id);
243 }
244
245 static notmuch_private_status_t
246 find_unique_document (notmuch_database_t *notmuch,
247                       const char *prefix_name,
248                       const char *value,
249                       Xapian::Document *document,
250                       unsigned int *doc_id)
251 {
252     notmuch_private_status_t status;
253
254     status = find_unique_doc_id (notmuch, prefix_name, value, doc_id);
255
256     if (status) {
257         *document = Xapian::Document ();
258         return status;
259     }
260
261     *document = find_document_for_doc_id (notmuch, *doc_id);
262     return NOTMUCH_PRIVATE_STATUS_SUCCESS;
263 }
264
265 notmuch_message_t *
266 notmuch_database_find_message (notmuch_database_t *notmuch,
267                                const char *message_id)
268 {
269     notmuch_private_status_t status;
270     unsigned int doc_id;
271
272     status = find_unique_doc_id (notmuch, "id", message_id, &doc_id);
273
274     if (status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND)
275         return NULL;
276
277     return _notmuch_message_create (notmuch, notmuch, doc_id, NULL);
278 }
279
280 /* Advance 'str' past any whitespace or RFC 822 comments. A comment is
281  * a (potentially nested) parenthesized sequence with '\' used to
282  * escape any character (including parentheses).
283  *
284  * If the sequence to be skipped continues to the end of the string,
285  * then 'str' will be left pointing at the final terminating '\0'
286  * character.
287  */
288 static void
289 skip_space_and_comments (const char **str)
290 {
291     const char *s;
292
293     s = *str;
294     while (*s && (isspace (*s) || *s == '(')) {
295         while (*s && isspace (*s))
296             s++;
297         if (*s == '(') {
298             int nesting = 1;
299             s++;
300             while (*s && nesting) {
301                 if (*s == '(') {
302                     nesting++;
303                 } else if (*s == ')') {
304                     nesting--;
305                 } else if (*s == '\\') {
306                     if (*(s+1))
307                         s++;
308                 }
309                 s++;
310             }
311         }
312     }
313
314     *str = s;
315 }
316
317 /* Parse an RFC 822 message-id, discarding whitespace, any RFC 822
318  * comments, and the '<' and '>' delimeters.
319  *
320  * If not NULL, then *next will be made to point to the first character
321  * not parsed, (possibly pointing to the final '\0' terminator.
322  *
323  * Returns a newly talloc'ed string belonging to 'ctx'.
324  *
325  * Returns NULL if there is any error parsing the message-id. */
326 static char *
327 _parse_message_id (void *ctx, const char *message_id, const char **next)
328 {
329     const char *s, *end;
330     char *result;
331
332     if (message_id == NULL || *message_id == '\0')
333         return NULL;
334
335     s = message_id;
336
337     skip_space_and_comments (&s);
338
339     /* Skip any unstructured text as well. */
340     while (*s && *s != '<')
341         s++;
342
343     if (*s == '<') {
344         s++;
345     } else {
346         if (next)
347             *next = s;
348         return NULL;
349     }
350
351     skip_space_and_comments (&s);
352
353     end = s;
354     while (*end && *end != '>')
355         end++;
356     if (next) {
357         if (*end)
358             *next = end + 1;
359         else
360             *next = end;
361     }
362
363     if (end > s && *end == '>')
364         end--;
365     if (end <= s)
366         return NULL;
367
368     result = talloc_strndup (ctx, s, end - s + 1);
369
370     /* Finally, collapse any whitespace that is within the message-id
371      * itself. */
372     {
373         char *r;
374         int len;
375
376         for (r = result, len = strlen (r); *r; r++, len--)
377             if (*r == ' ' || *r == '\t')
378                 memmove (r, r+1, len);
379     }
380
381     return result;
382 }
383
384 /* Parse a References header value, putting a (talloc'ed under 'ctx')
385  * copy of each referenced message-id into 'hash'.
386  *
387  * We explicitly avoid including any reference identical to
388  * 'message_id' in the result (to avoid mass confusion when a single
389  * message references itself cyclically---and yes, mail messages are
390  * not infrequent in the wild that do this---don't ask me why).
391 */
392 static void
393 parse_references (void *ctx,
394                   const char *message_id,
395                   GHashTable *hash,
396                   const char *refs)
397 {
398     char *ref;
399
400     if (refs == NULL || *refs == '\0')
401         return;
402
403     while (*refs) {
404         ref = _parse_message_id (ctx, refs, &refs);
405
406         if (ref && strcmp (ref, message_id))
407             g_hash_table_insert (hash, ref, NULL);
408     }
409 }
410
411 notmuch_database_t *
412 notmuch_database_create (const char *path)
413 {
414     notmuch_database_t *notmuch = NULL;
415     char *notmuch_path = NULL;
416     struct stat st;
417     int err;
418
419     if (path == NULL) {
420         fprintf (stderr, "Error: Cannot create a database for a NULL path.\n");
421         goto DONE;
422     }
423
424     err = stat (path, &st);
425     if (err) {
426         fprintf (stderr, "Error: Cannot create database at %s: %s.\n",
427                  path, strerror (errno));
428         goto DONE;
429     }
430
431     if (! S_ISDIR (st.st_mode)) {
432         fprintf (stderr, "Error: Cannot create database at %s: Not a directory.\n",
433                  path);
434         goto DONE;
435     }
436
437     notmuch_path = talloc_asprintf (NULL, "%s/%s", path, ".notmuch");
438
439     err = mkdir (notmuch_path, 0755);
440
441     if (err) {
442         fprintf (stderr, "Error: Cannot create directory %s: %s.\n",
443                  notmuch_path, strerror (errno));
444         goto DONE;
445     }
446
447     notmuch = notmuch_database_open (path,
448                                      NOTMUCH_DATABASE_MODE_READ_WRITE);
449
450   DONE:
451     if (notmuch_path)
452         talloc_free (notmuch_path);
453
454     return notmuch;
455 }
456
457 notmuch_database_t *
458 notmuch_database_open (const char *path,
459                        notmuch_database_mode_t mode)
460 {
461     notmuch_database_t *notmuch = NULL;
462     char *notmuch_path = NULL, *xapian_path = NULL;
463     struct stat st;
464     int err;
465     unsigned int i;
466
467     if (asprintf (&notmuch_path, "%s/%s", path, ".notmuch") == -1) {
468         notmuch_path = NULL;
469         fprintf (stderr, "Out of memory\n");
470         goto DONE;
471     }
472
473     err = stat (notmuch_path, &st);
474     if (err) {
475         fprintf (stderr, "Error opening database at %s: %s\n",
476                  notmuch_path, strerror (errno));
477         goto DONE;
478     }
479
480     if (asprintf (&xapian_path, "%s/%s", notmuch_path, "xapian") == -1) {
481         xapian_path = NULL;
482         fprintf (stderr, "Out of memory\n");
483         goto DONE;
484     }
485
486     notmuch = talloc (NULL, notmuch_database_t);
487     notmuch->exception_reported = FALSE;
488     notmuch->path = talloc_strdup (notmuch, path);
489
490     if (notmuch->path[strlen (notmuch->path) - 1] == '/')
491         notmuch->path[strlen (notmuch->path) - 1] = '\0';
492
493     notmuch->mode = mode;
494     try {
495         if (mode == NOTMUCH_DATABASE_MODE_READ_WRITE) {
496             notmuch->xapian_db = new Xapian::WritableDatabase (xapian_path,
497                                                                Xapian::DB_CREATE_OR_OPEN);
498         } else {
499             notmuch->xapian_db = new Xapian::Database (xapian_path);
500         }
501         notmuch->query_parser = new Xapian::QueryParser;
502         notmuch->term_gen = new Xapian::TermGenerator;
503         notmuch->term_gen->set_stemmer (Xapian::Stem ("english"));
504         notmuch->value_range_processor = new Xapian::NumberValueRangeProcessor (NOTMUCH_VALUE_TIMESTAMP);
505
506         notmuch->query_parser->set_default_op (Xapian::Query::OP_AND);
507         notmuch->query_parser->set_database (*notmuch->xapian_db);
508         notmuch->query_parser->set_stemmer (Xapian::Stem ("english"));
509         notmuch->query_parser->set_stemming_strategy (Xapian::QueryParser::STEM_SOME);
510         notmuch->query_parser->add_valuerangeprocessor (notmuch->value_range_processor);
511
512         for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) {
513             prefix_t *prefix = &BOOLEAN_PREFIX_EXTERNAL[i];
514             notmuch->query_parser->add_boolean_prefix (prefix->name,
515                                                        prefix->prefix);
516         }
517
518         for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) {
519             prefix_t *prefix = &PROBABILISTIC_PREFIX[i];
520             notmuch->query_parser->add_prefix (prefix->name, prefix->prefix);
521         }
522     } catch (const Xapian::Error &error) {
523         fprintf (stderr, "A Xapian exception occurred opening database: %s\n",
524                  error.get_msg().c_str());
525         notmuch = NULL;
526     }
527
528   DONE:
529     if (notmuch_path)
530         free (notmuch_path);
531     if (xapian_path)
532         free (xapian_path);
533
534     return notmuch;
535 }
536
537 void
538 notmuch_database_close (notmuch_database_t *notmuch)
539 {
540     try {
541         if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_WRITE)
542             (static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db))->flush ();
543     } catch (const Xapian::Error &error) {
544         if (! notmuch->exception_reported) {
545             fprintf (stderr, "Error: A Xapian exception occurred flushing database: %s\n",
546                      error.get_msg().c_str());
547         }
548     }
549
550     delete notmuch->term_gen;
551     delete notmuch->query_parser;
552     delete notmuch->xapian_db;
553     delete notmuch->value_range_processor;
554     talloc_free (notmuch);
555 }
556
557 const char *
558 notmuch_database_get_path (notmuch_database_t *notmuch)
559 {
560     return notmuch->path;
561 }
562
563 static notmuch_private_status_t
564 find_timestamp_document (notmuch_database_t *notmuch, const char *db_key,
565                          Xapian::Document *doc, unsigned int *doc_id)
566 {
567     return find_unique_document (notmuch, "timestamp", db_key, doc, doc_id);
568 }
569
570 /* We allow the user to use arbitrarily long keys for timestamps,
571  * (they're for filesystem paths after all, which have no limit we
572  * know about). But we have a term-length limit. So if we exceed that,
573  * we'll use the SHA-1 of the user's key as the actual key for
574  * constructing a database term.
575  *
576  * Caution: This function returns a newly allocated string which the
577  * caller should free() when finished.
578  */
579 static char *
580 timestamp_db_key (const char *key)
581 {
582     int term_len = strlen (_find_prefix ("timestamp")) + strlen (key);
583
584     if (term_len > NOTMUCH_TERM_MAX)
585         return notmuch_sha1_of_string (key);
586     else
587         return strdup (key);
588 }
589
590 notmuch_status_t
591 notmuch_database_set_timestamp (notmuch_database_t *notmuch,
592                                 const char *key, time_t timestamp)
593 {
594     Xapian::Document doc;
595     Xapian::WritableDatabase *db;
596     unsigned int doc_id;
597     notmuch_private_status_t status;
598     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
599     char *db_key = NULL;
600
601     if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY) {
602         fprintf (stderr, "Attempted to update a read-only database.\n");
603         return NOTMUCH_STATUS_READONLY_DATABASE;
604     }
605
606     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
607     db_key = timestamp_db_key (key);
608
609     try {
610         status = find_timestamp_document (notmuch, db_key, &doc, &doc_id);
611
612         doc.add_value (NOTMUCH_VALUE_TIMESTAMP,
613                        Xapian::sortable_serialise (timestamp));
614
615         if (status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) {
616             char *term = talloc_asprintf (NULL, "%s%s",
617                                           _find_prefix ("timestamp"), db_key);
618             doc.add_term (term);
619             talloc_free (term);
620
621             db->add_document (doc);
622         } else {
623             db->replace_document (doc_id, doc);
624         }
625
626     } catch (const Xapian::Error &error) {
627         fprintf (stderr, "A Xapian exception occurred setting timestamp: %s.\n",
628                  error.get_msg().c_str());
629         notmuch->exception_reported = TRUE;
630         ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
631     }
632
633     if (db_key)
634         free (db_key);
635
636     return ret;
637 }
638
639 time_t
640 notmuch_database_get_timestamp (notmuch_database_t *notmuch, const char *key)
641 {
642     Xapian::Document doc;
643     unsigned int doc_id;
644     notmuch_private_status_t status;
645     char *db_key = NULL;
646     time_t ret = 0;
647
648     db_key = timestamp_db_key (key);
649
650     try {
651         status = find_timestamp_document (notmuch, db_key, &doc, &doc_id);
652
653         if (status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND)
654             goto DONE;
655
656         ret =  Xapian::sortable_unserialise (doc.get_value (NOTMUCH_VALUE_TIMESTAMP));
657     } catch (Xapian::Error &error) {
658         ret = 0;
659         goto DONE;
660     }
661
662   DONE:
663     if (db_key)
664         free (db_key);
665
666     return ret;
667 }
668
669 /* Find the thread ID to which the message with 'message_id' belongs.
670  *
671  * Returns NULL if no message with message ID 'message_id' is in the
672  * database.
673  *
674  * Otherwise, returns a newly talloced string belonging to 'ctx'.
675  */
676 static const char *
677 _resolve_message_id_to_thread_id (notmuch_database_t *notmuch,
678                                   void *ctx,
679                                   const char *message_id)
680 {
681     notmuch_message_t *message;
682     const char *ret = NULL;
683
684     message = notmuch_database_find_message (notmuch, message_id);
685     if (message == NULL)
686         goto DONE;
687
688     ret = talloc_steal (ctx, notmuch_message_get_thread_id (message));
689
690   DONE:
691     if (message)
692         notmuch_message_destroy (message);
693
694     return ret;
695 }
696
697 static notmuch_status_t
698 _merge_threads (notmuch_database_t *notmuch,
699                 const char *winner_thread_id,
700                 const char *loser_thread_id)
701 {
702     Xapian::PostingIterator loser, loser_end;
703     notmuch_message_t *message = NULL;
704     notmuch_private_status_t private_status;
705     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
706
707     find_doc_ids (notmuch, "thread", loser_thread_id, &loser, &loser_end);
708
709     for ( ; loser != loser_end; loser++) {
710         message = _notmuch_message_create (notmuch, notmuch,
711                                            *loser, &private_status);
712         if (message == NULL) {
713             ret = COERCE_STATUS (private_status,
714                                  "Cannot find document for doc_id from query");
715             goto DONE;
716         }
717
718         _notmuch_message_remove_term (message, "thread", loser_thread_id);
719         _notmuch_message_add_term (message, "thread", winner_thread_id);
720         _notmuch_message_sync (message);
721
722         notmuch_message_destroy (message);
723         message = NULL;
724     }
725
726   DONE:
727     if (message)
728         notmuch_message_destroy (message);
729
730     return ret;
731 }
732
733 static void
734 _my_talloc_free_for_g_hash (void *ptr)
735 {
736     talloc_free (ptr);
737 }
738
739 static notmuch_status_t
740 _notmuch_database_link_message_to_parents (notmuch_database_t *notmuch,
741                                            notmuch_message_t *message,
742                                            notmuch_message_file_t *message_file,
743                                            const char **thread_id)
744 {
745     GHashTable *parents = NULL;
746     const char *refs, *in_reply_to, *in_reply_to_message_id;
747     GList *l, *keys = NULL;
748     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
749
750     parents = g_hash_table_new_full (g_str_hash, g_str_equal,
751                                      _my_talloc_free_for_g_hash, NULL);
752
753     refs = notmuch_message_file_get_header (message_file, "references");
754     parse_references (message, notmuch_message_get_message_id (message),
755                       parents, refs);
756
757     in_reply_to = notmuch_message_file_get_header (message_file, "in-reply-to");
758     parse_references (message, notmuch_message_get_message_id (message),
759                       parents, in_reply_to);
760
761     /* Carefully avoid adding any self-referential in-reply-to term. */
762     in_reply_to_message_id = _parse_message_id (message, in_reply_to, NULL);
763     if (in_reply_to_message_id &&
764         strcmp (in_reply_to_message_id,
765                 notmuch_message_get_message_id (message)))
766     {
767         _notmuch_message_add_term (message, "replyto",
768                              _parse_message_id (message, in_reply_to, NULL));
769     }
770
771     keys = g_hash_table_get_keys (parents);
772     for (l = keys; l; l = l->next) {
773         char *parent_message_id;
774         const char *parent_thread_id;
775
776         parent_message_id = (char *) l->data;
777         parent_thread_id = _resolve_message_id_to_thread_id (notmuch,
778                                                              message,
779                                                              parent_message_id);
780
781         if (parent_thread_id == NULL) {
782             _notmuch_message_add_term (message, "reference",
783                                        parent_message_id);
784         } else {
785             if (*thread_id == NULL) {
786                 *thread_id = talloc_strdup (message, parent_thread_id);
787                 _notmuch_message_add_term (message, "thread", *thread_id);
788             } else if (strcmp (*thread_id, parent_thread_id)) {
789                 ret = _merge_threads (notmuch, *thread_id, parent_thread_id);
790                 if (ret)
791                     goto DONE;
792             }
793         }
794     }
795
796   DONE:
797     if (keys)
798         g_list_free (keys);
799     if (parents)
800         g_hash_table_unref (parents);
801
802     return ret;
803 }
804
805 static notmuch_status_t
806 _notmuch_database_link_message_to_children (notmuch_database_t *notmuch,
807                                             notmuch_message_t *message,
808                                             const char **thread_id)
809 {
810     const char *message_id = notmuch_message_get_message_id (message);
811     Xapian::PostingIterator child, children_end;
812     notmuch_message_t *child_message = NULL;
813     const char *child_thread_id;
814     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
815     notmuch_private_status_t private_status;
816
817     find_doc_ids (notmuch, "reference", message_id, &child, &children_end);
818
819     for ( ; child != children_end; child++) {
820
821         child_message = _notmuch_message_create (message, notmuch,
822                                                  *child, &private_status);
823         if (child_message == NULL) {
824             ret = COERCE_STATUS (private_status,
825                                  "Cannot find document for doc_id from query");
826             goto DONE;
827         }
828
829         child_thread_id = notmuch_message_get_thread_id (child_message);
830         if (*thread_id == NULL) {
831             *thread_id = talloc_strdup (message, child_thread_id);
832             _notmuch_message_add_term (message, "thread", *thread_id);
833         } else if (strcmp (*thread_id, child_thread_id)) {
834             _notmuch_message_remove_term (child_message, "reference",
835                                           message_id);
836             _notmuch_message_sync (child_message);
837             ret = _merge_threads (notmuch, *thread_id, child_thread_id);
838             if (ret)
839                 goto DONE;
840         }
841
842         notmuch_message_destroy (child_message);
843         child_message = NULL;
844     }
845
846   DONE:
847     if (child_message)
848         notmuch_message_destroy (child_message);
849
850     return ret;
851 }
852
853 /* Given a (mostly empty) 'message' and its corresponding
854  * 'message_file' link it to existing threads in the database.
855  *
856  * We first look at 'message_file' and its link-relevant headers
857  * (References and In-Reply-To) for message IDs. We also look in the
858  * database for existing message that reference 'message'.p
859  *
860  * The end result is to call _notmuch_message_add_thread_id with one
861  * or more thread IDs to which this message belongs, (including
862  * generating a new thread ID if necessary if the message doesn't
863  * connect to any existing threads).
864  */
865 static notmuch_status_t
866 _notmuch_database_link_message (notmuch_database_t *notmuch,
867                                 notmuch_message_t *message,
868                                 notmuch_message_file_t *message_file)
869 {
870     notmuch_status_t status;
871     const char *thread_id = NULL;
872
873     status = _notmuch_database_link_message_to_parents (notmuch, message,
874                                                         message_file,
875                                                         &thread_id);
876     if (status)
877         return status;
878
879     status = _notmuch_database_link_message_to_children (notmuch, message,
880                                                          &thread_id);
881     if (status)
882         return status;
883
884     if (thread_id == NULL)
885         _notmuch_message_ensure_thread_id (message);
886
887     return NOTMUCH_STATUS_SUCCESS;
888 }
889
890 notmuch_status_t
891 notmuch_database_add_message (notmuch_database_t *notmuch,
892                               const char *filename,
893                               notmuch_message_t **message_ret)
894 {
895     notmuch_message_file_t *message_file;
896     notmuch_message_t *message = NULL;
897     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
898     notmuch_private_status_t private_status;
899
900     const char *date, *header;
901     const char *from, *to, *subject;
902     char *message_id = NULL;
903
904     if (message_ret)
905         *message_ret = NULL;
906
907     message_file = notmuch_message_file_open (filename);
908     if (message_file == NULL) {
909         ret = NOTMUCH_STATUS_FILE_ERROR;
910         goto DONE;
911     }
912
913     notmuch_message_file_restrict_headers (message_file,
914                                            "date",
915                                            "from",
916                                            "in-reply-to",
917                                            "message-id",
918                                            "references",
919                                            "subject",
920                                            "to",
921                                            (char *) NULL);
922
923     try {
924         /* Before we do any real work, (especially before doing a
925          * potential SHA-1 computation on the entire file's contents),
926          * let's make sure that what we're looking at looks like an
927          * actual email message.
928          */
929         from = notmuch_message_file_get_header (message_file, "from");
930         subject = notmuch_message_file_get_header (message_file, "subject");
931         to = notmuch_message_file_get_header (message_file, "to");
932
933         if ((from == NULL || *from == '\0') &&
934             (subject == NULL || *subject == '\0') &&
935             (to == NULL || *to == '\0'))
936         {
937             ret = NOTMUCH_STATUS_FILE_NOT_EMAIL;
938             goto DONE;
939         }
940
941         /* Now that we're sure it's mail, the first order of business
942          * is to find a message ID (or else create one ourselves). */
943
944         header = notmuch_message_file_get_header (message_file, "message-id");
945         if (header && *header != '\0') {
946             message_id = _parse_message_id (message_file, header, NULL);
947
948             /* So the header value isn't RFC-compliant, but it's
949              * better than no message-id at all. */
950             if (message_id == NULL)
951                 message_id = talloc_strdup (message_file, header);
952
953             /* Reject a Message ID that's too long. */
954             if (message_id && strlen (message_id) + 1 > NOTMUCH_TERM_MAX) {
955                 talloc_free (message_id);
956                 message_id = NULL;
957             }
958         }
959
960         if (message_id == NULL ) {
961             /* No message-id at all, let's generate one by taking a
962              * hash over the file's contents. */
963             char *sha1 = notmuch_sha1_of_file (filename);
964
965             /* If that failed too, something is really wrong. Give up. */
966             if (sha1 == NULL) {
967                 ret = NOTMUCH_STATUS_FILE_ERROR;
968                 goto DONE;
969             }
970
971             message_id = talloc_asprintf (message_file,
972                                           "notmuch-sha1-%s", sha1);
973             free (sha1);
974         }
975
976         /* Now that we have a message ID, we get a message object,
977          * (which may or may not reference an existing document in the
978          * database). */
979
980         message = _notmuch_message_create_for_message_id (notmuch,
981                                                           message_id,
982                                                           &private_status);
983
984         talloc_free (message_id);
985
986         if (message == NULL) {
987             ret = COERCE_STATUS (private_status,
988                                  "Unexpected status value from _notmuch_message_create_for_message_id");
989             goto DONE;
990         }
991
992         /* Is this a newly created message object? */
993         if (private_status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) {
994             _notmuch_message_set_filename (message, filename);
995             _notmuch_message_add_term (message, "type", "mail");
996         } else {
997             ret = NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID;
998             goto DONE;
999         }
1000
1001         ret = _notmuch_database_link_message (notmuch, message, message_file);
1002         if (ret)
1003             goto DONE;
1004
1005         date = notmuch_message_file_get_header (message_file, "date");
1006         _notmuch_message_set_date (message, date);
1007
1008         _notmuch_message_index_file (message, filename);
1009
1010         _notmuch_message_sync (message);
1011     } catch (const Xapian::Error &error) {
1012         fprintf (stderr, "A Xapian exception occurred adding message: %s.\n",
1013                  error.get_description().c_str());
1014         notmuch->exception_reported = TRUE;
1015         ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
1016         goto DONE;
1017     }
1018
1019   DONE:
1020     if (message) {
1021         if (ret == NOTMUCH_STATUS_SUCCESS && message_ret)
1022             *message_ret = message;
1023         else
1024             notmuch_message_destroy (message);
1025     }
1026
1027     if (message_file)
1028         notmuch_message_file_close (message_file);
1029
1030     return ret;
1031 }
1032
1033 notmuch_tags_t *
1034 _notmuch_convert_tags (void *ctx, Xapian::TermIterator &i,
1035                        Xapian::TermIterator &end)
1036 {
1037     const char *prefix = _find_prefix ("tag");
1038     notmuch_tags_t *tags;
1039     std::string tag;
1040
1041     /* Currently this iteration is written with the assumption that
1042      * "tag" has a single-character prefix. */
1043     assert (strlen (prefix) == 1);
1044
1045     tags = _notmuch_tags_create (ctx);
1046     if (unlikely (tags == NULL))
1047         return NULL;
1048
1049     i.skip_to (prefix);
1050
1051     while (i != end) {
1052         tag = *i;
1053
1054         if (tag.empty () || tag[0] != *prefix)
1055             break;
1056
1057         _notmuch_tags_add_tag (tags, tag.c_str () + 1);
1058
1059         i++;
1060     }
1061
1062     _notmuch_tags_prepare_iterator (tags);
1063
1064     return tags;
1065 }
1066
1067 notmuch_tags_t *
1068 notmuch_database_get_all_tags (notmuch_database_t *db)
1069 {
1070     Xapian::TermIterator i, end;
1071     i = db->xapian_db->allterms_begin();
1072     end = db->xapian_db->allterms_end();
1073     return _notmuch_convert_tags(db, i, end);
1074 }