notmuch: Start actually adding messages to the index.
[notmuch] / 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 "notmuch-private.h"
22
23 #include <stdio.h>
24 #include <errno.h>
25 #include <time.h>
26 #include <unistd.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <sys/time.h>
30
31 #include <iostream>
32
33 #include <gmime/gmime.h>
34
35 #include <xapian.h>
36
37 using namespace std;
38
39 struct _notmuch_database {
40     char *path;
41     Xapian::WritableDatabase *xapian_db;
42     Xapian::TermGenerator *term_gen;
43 };
44
45 #define ARRAY_SIZE(arr) (sizeof (arr) / sizeof (arr[0]))
46
47 /* Xapian complains if we provide a term longer than this. */
48 #define NOTMUCH_MAX_TERM 245
49
50 /* These prefix values are specifically chosen to be compatible
51  * with sup, (http://sup.rubyforge.org), written by
52  * William Morgan <wmorgan-sup@masanjin.net>, and released
53  * under the GNU GPL v2.
54  */
55
56 typedef struct {
57     const char *name;
58     const char *prefix;
59 } prefix_t;
60
61 prefix_t NORMAL_PREFIX[] = {
62     { "subject", "S" },
63     { "body", "B" },
64     { "from_name", "FN" },
65     { "to_name", "TN" },
66     { "name", "N" },
67     { "attachment", "A" }
68 };
69
70 prefix_t BOOLEAN_PREFIX[] = {
71     { "type", "K" },
72     { "from_email", "FE" },
73     { "to_email", "TE" },
74     { "email", "E" },
75     { "date", "D" },
76     { "label", "L" },
77     { "source_id", "I" },
78     { "attachment_extension", "O" },
79     { "msgid", "Q" },
80     { "thread", "H" },
81     { "ref", "R" }
82 };
83
84 /* Similarly, these value numbers are also chosen to be sup
85  * compatible. */
86
87 typedef enum {
88     NOTMUCH_VALUE_MESSAGE_ID = 0,
89     NOTMUCH_VALUE_THREAD = 1,
90     NOTMUCH_VALUE_DATE = 2
91 } notmuch_value_t;
92
93 static const char *
94 find_prefix (const char *name)
95 {
96     unsigned int i;
97
98     for (i = 0; i < ARRAY_SIZE (NORMAL_PREFIX); i++)
99         if (strcmp (name, NORMAL_PREFIX[i].name) == 0)
100             return NORMAL_PREFIX[i].prefix;
101
102     for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX); i++)
103         if (strcmp (name, BOOLEAN_PREFIX[i].name) == 0)
104             return BOOLEAN_PREFIX[i].prefix;
105
106     return "";
107 }
108
109 /* "128 bits of thread-id ought to be enough for anybody" */
110 #define NOTMUCH_THREAD_ID_BITS   128
111 #define NOTMUCH_THREAD_ID_DIGITS (NOTMUCH_THREAD_ID_BITS / 4)
112 typedef struct _thread_id {
113     char str[NOTMUCH_THREAD_ID_DIGITS + 1];
114 } thread_id_t;
115
116 static void
117 thread_id_generate (thread_id_t *thread_id)
118 {
119     static int seeded = 0;
120     FILE *dev_random;
121     uint32_t value;
122     char *s;
123     int i;
124
125     if (! seeded) {
126         dev_random = fopen ("/dev/random", "r");
127         if (dev_random == NULL) {
128             srand (time (NULL));
129         } else {
130             fread ((void *) &value, sizeof (value), 1, dev_random);
131             srand (value);
132             fclose (dev_random);
133         }
134         seeded = 1;
135     }
136
137     s = thread_id->str;
138     for (i = 0; i < NOTMUCH_THREAD_ID_DIGITS; i += 8) {
139         value = rand ();
140         sprintf (s, "%08x", value);
141         s += 8;
142     }
143 }
144
145 static void
146 add_term (Xapian::Document doc,
147           const char *prefix_name,
148           const char *value)
149 {
150     const char *prefix;
151     char *term;
152
153     if (value == NULL)
154         return;
155
156     prefix = find_prefix (prefix_name);
157
158     term = g_strdup_printf ("%s%s", prefix, value);
159
160     if (strlen (term) <= NOTMUCH_MAX_TERM)
161         doc.add_term (term);
162
163     g_free (term);
164 }
165
166 static void
167 find_messages_by_term (Xapian::Database *db,
168                        const char *prefix_name,
169                        const char *value,
170                        Xapian::PostingIterator *begin,
171                        Xapian::PostingIterator *end)
172 {
173     Xapian::PostingIterator i;
174     char *term;
175
176     term = g_strdup_printf ("%s%s", find_prefix (prefix_name), value);
177
178     *begin = db->postlist_begin (term);
179
180     if (end)
181         *end = db->postlist_end (term);
182
183     free (term);
184 }
185
186 Xapian::Document
187 find_message_by_docid (Xapian::Database *db, Xapian::docid docid)
188 {
189     return db->get_document (docid);
190 }
191
192 Xapian::Document
193 find_message_by_message_id (Xapian::Database *db, const char *message_id)
194 {
195     Xapian::PostingIterator i, end;
196
197     find_messages_by_term (db, "msgid", message_id, &i, &end);
198
199     if (i != end)
200         return find_message_by_docid (db, *i);
201     else
202         return Xapian::Document ();
203 }
204
205 static void
206 insert_thread_id (GHashTable *thread_ids, Xapian::Document doc)
207 {
208     string value_string;
209     const char *value, *id, *comma;
210
211     value_string = doc.get_value (NOTMUCH_VALUE_THREAD);
212     value = value_string.c_str();
213     if (strlen (value)) {
214         id = value;
215         while (*id) {
216             comma = strchr (id, ',');
217             if (comma == NULL)
218                 comma = id + strlen (id);
219             g_hash_table_insert (thread_ids,
220                                  strndup (id, comma - id), NULL);
221             id = comma;
222             if (*id)
223                 id++;
224         }
225     }
226 }
227
228 /* Return one or more thread_ids, (as a GPtrArray of strings), for the
229  * given message based on looking into the database for any messages
230  * referenced in parents, and also for any messages in the database
231  * referencing message_id.
232  *
233  * Caller should free all strings in the array and the array itself,
234  * (g_ptr_array_free) when done. */
235 static GPtrArray *
236 find_thread_ids (Xapian::Database *db,
237                  GPtrArray *parents,
238                  const char *message_id)
239 {
240     Xapian::PostingIterator child, children_end;
241     Xapian::Document doc;
242     GHashTable *thread_ids;
243     GList *keys, *l;
244     unsigned int i;
245     const char *parent_message_id;
246     GPtrArray *result;
247
248     thread_ids = g_hash_table_new_full (g_str_hash, g_str_equal,
249                                         free, NULL);
250
251     find_messages_by_term (db, "ref", message_id, &child, &children_end);
252     for ( ; child != children_end; child++) {
253         doc = find_message_by_docid (db, *child);
254         insert_thread_id (thread_ids, doc);
255     }
256
257     for (i = 0; i < parents->len; i++) {
258         parent_message_id = (char *) g_ptr_array_index (parents, i);
259         doc = find_message_by_message_id (db, parent_message_id);
260         insert_thread_id (thread_ids, doc);
261     }
262
263     result = g_ptr_array_new ();
264
265     keys = g_hash_table_get_keys (thread_ids);
266     for (l = keys; l; l = l->next) {
267         char *id = (char *) l->data;
268         g_ptr_array_add (result, id);
269     }
270     g_list_free (keys);
271
272     /* We're done with the hash table, but we've taken the pointers to
273      * the allocated strings and put them into our result array, so
274      * tell the hash not to free them on its way out. */
275     g_hash_table_steal_all (thread_ids);
276     g_hash_table_unref (thread_ids);
277
278     return result;
279 }
280
281 /* Add a term for each message-id in the References header of the
282  * message. */
283 static void
284 parse_references (GPtrArray *array,
285                   const char *refs_str)
286 {
287     GMimeReferences *refs, *r;
288     const char *message_id;
289
290     if (refs_str == NULL)
291         return;
292
293     refs = g_mime_references_decode (refs_str);
294
295     for (r = refs; r; r = r->next) {
296         message_id = g_mime_references_get_message_id (r);
297         g_ptr_array_add (array, g_strdup (message_id));
298     }
299
300     g_mime_references_free (refs);
301 }
302
303 notmuch_database_t *
304 notmuch_database_create (const char *path)
305 {
306     char *notmuch_path;
307     struct stat st;
308     int err;
309
310     err = stat (path, &st);
311     if (err) {
312         fprintf (stderr, "Error: Cannot create database at %s: %s.\n",
313                  path, strerror (errno));
314         return NULL;
315     }
316
317     if (! S_ISDIR (st.st_mode)) {
318         fprintf (stderr, "Error: Cannot create database at %s: Not a directory.\n",
319                  path);
320         return NULL;
321     }
322
323     notmuch_path = g_strdup_printf ("%s/%s", path, ".notmuch");
324
325     err = mkdir (notmuch_path, 0755);
326
327     if (err) {
328         fprintf (stderr, "Error: Cannot create directory %s: %s.\n",
329                  notmuch_path, strerror (errno));
330         free (notmuch_path);
331         return NULL;
332     }
333
334     free (notmuch_path);
335
336     return notmuch_database_open (path);
337 }
338
339 notmuch_database_t *
340 notmuch_database_open (const char *path)
341 {
342     notmuch_database_t *notmuch;
343     char *notmuch_path, *xapian_path;
344     struct stat st;
345     int err;
346
347     g_mime_init (0);
348
349     notmuch_path = g_strdup_printf ("%s/%s", path, ".notmuch");
350
351     err = stat (notmuch_path, &st);
352     if (err) {
353         fprintf (stderr, "Error: Cannot stat %s: %s\n",
354                  notmuch_path, strerror (err));
355         free (notmuch_path);
356         return NULL;
357     }
358
359     xapian_path = g_strdup_printf ("%s/%s", notmuch_path, "xapian");
360     free (notmuch_path);
361
362     /* C++ is so nasty in requiring these casts. I'm almost tempted to
363      * write a C wrapper for Xapian... */
364     notmuch = (notmuch_database_t *) xmalloc (sizeof (notmuch_database_t));
365     notmuch->path = xstrdup (path);
366
367     try {
368         notmuch->xapian_db = new Xapian::WritableDatabase (xapian_path,
369                                                            Xapian::DB_CREATE_OR_OPEN);
370     } catch (const Xapian::Error &error) {
371         fprintf (stderr, "A Xapian exception occurred: %s\n",
372                  error.get_msg().c_str());
373     }
374     
375     free (xapian_path);
376
377     return notmuch;
378 }
379
380 void
381 notmuch_database_close (notmuch_database_t *notmuch)
382 {
383     delete notmuch->xapian_db;
384     free (notmuch->path);
385     free (notmuch);
386 }
387
388 const char *
389 notmuch_database_get_path (notmuch_database_t *notmuch)
390 {
391     return notmuch->path;
392 }
393
394 notmuch_status_t
395 notmuch_database_add_message (notmuch_database_t *notmuch,
396                               const char *filename)
397 {
398     Xapian::WritableDatabase *db = notmuch->xapian_db;
399     Xapian::Document doc;
400
401     GMimeStream *stream;
402     GMimeParser *parser;
403     GMimeMessage *message;
404     GPtrArray *parents, *thread_ids;
405
406     FILE *file;
407
408     const char *refs, *in_reply_to;
409     const char *message_id;
410
411     time_t time;
412     unsigned int i;
413
414     file = fopen (filename, "r");
415     if (! file) {
416         fprintf (stderr, "Error opening %s: %s\n", filename, strerror (errno));
417         exit (1);
418     }
419
420     stream = g_mime_stream_file_new (file);
421
422     parser = g_mime_parser_new_with_stream (stream);
423
424     message = g_mime_parser_construct_message (parser);
425
426     try {
427         doc = Xapian::Document ();
428
429         doc.set_data (filename);
430
431         parents = g_ptr_array_new ();
432
433         refs = g_mime_object_get_header (GMIME_OBJECT (message), "references");
434         parse_references (parents, refs);
435
436         in_reply_to = g_mime_object_get_header (GMIME_OBJECT (message),
437                                                 "in-reply-to");
438         parse_references (parents, in_reply_to);
439         for (i = 0; i < parents->len; i++)
440             add_term (doc, "ref", (char *) g_ptr_array_index (parents, i));
441
442         message_id = g_mime_message_get_message_id (message);
443
444         thread_ids = find_thread_ids (db, parents, message_id);
445
446         for (i = 0; i < parents->len; i++)
447             g_free (g_ptr_array_index (parents, i));
448         g_ptr_array_free (parents, TRUE);
449         if (message_id) {
450             add_term (doc, "msgid", message_id);
451             doc.add_value (NOTMUCH_VALUE_MESSAGE_ID, message_id);
452         }
453
454         if (thread_ids->len) {
455             unsigned int i;
456             GString *thread_id;
457             char *id;
458
459             for (i = 0; i < thread_ids->len; i++) {
460                 id = (char *) thread_ids->pdata[i];
461                 add_term (doc, "thread", id);
462                 if (i == 0)
463                     thread_id = g_string_new (id);
464                 else
465                     g_string_append_printf (thread_id, ",%s", id);
466
467                 free (id);
468             }
469             g_ptr_array_free (thread_ids, TRUE);
470             doc.add_value (NOTMUCH_VALUE_THREAD, thread_id->str);
471             g_string_free (thread_id, TRUE);
472         } else if (message_id) {
473             /* If not part of any existing thread, generate a new thread_id. */
474             thread_id_t thread_id;
475
476             thread_id_generate (&thread_id);
477             add_term (doc, "thread", thread_id.str);
478             doc.add_value (NOTMUCH_VALUE_THREAD, thread_id.str);
479         }
480
481         g_mime_message_get_date (message, &time, NULL);
482         doc.add_value (NOTMUCH_VALUE_DATE, Xapian::sortable_serialise (time));
483
484         db->add_document (doc);
485     } catch (const Xapian::Error &error) {
486         fprintf (stderr, "A Xapian exception occurred: %s.\n",
487                  error.get_msg().c_str());
488         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
489     }
490
491     g_object_unref (message);
492     g_object_unref (parser);
493     g_object_unref (stream);
494
495     return NOTMUCH_STATUS_SUCCESS;
496 }