git.notmuchmail.org Git - notmuch/blob - 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_strdup_printf, g_free, GPtrArray, GHashTable */
  28
  29 using namespace std;
  30
  31 const char *
  32 notmuch_status_to_string (notmuch_status_t status)
  33 {
  34     switch (status) {
  35     case NOTMUCH_STATUS_SUCCESS:
  36         return "No error occurred";
  37     case NOTMUCH_STATUS_XAPIAN_EXCEPTION:
  38         return "A Xapian exception occurred";
  39     case NOTMUCH_STATUS_FILE_ERROR:
  40         return "Something went wrong trying to read or write a file";
  41     case NOTMUCH_STATUS_FILE_NOT_EMAIL:
  42         return "File is not an email";
  43     case NOTMUCH_STATUS_NULL_POINTER:
  44         return "Erroneous NULL pointer";
  45     case NOTMUCH_STATUS_TAG_TOO_LONG:
  46         return "Tag value is too long";
  47     default:
  48     case NOTMUCH_STATUS_LAST_STATUS:
  49         return "Unknown error status value";
  50     }
  51 }
  52
  53 /* XXX: We should drop this function and convert all callers to call
  54  * _notmuch_message_add_term instead. */
  55 static void
  56 add_term (Xapian::Document doc,
  57           const char *prefix_name,
  58           const char *value)
  59 {
  60     const char *prefix;
  61     char *term;
  62
  63     if (value == NULL)
  64         return;
  65
  66     prefix = _find_prefix (prefix_name);
  67
  68     term = g_strdup_printf ("%s%s", prefix, value);
  69
  70     if (strlen (term) <= NOTMUCH_TERM_MAX)
  71         doc.add_term (term);
  72
  73     g_free (term);
  74 }
  75
  76 static void
  77 find_messages_by_term (Xapian::Database *db,
  78                        const char *prefix_name,
  79                        const char *value,
  80                        Xapian::PostingIterator *begin,
  81                        Xapian::PostingIterator *end)
  82 {
  83     Xapian::PostingIterator i;
  84     char *term;
  85
  86     term = g_strdup_printf ("%s%s", _find_prefix (prefix_name), value);
  87
  88     *begin = db->postlist_begin (term);
  89
  90     if (end)
  91         *end = db->postlist_end (term);
  92
  93     free (term);
  94 }
  95
  96 Xapian::Document
  97 find_message_by_docid (Xapian::Database *db, Xapian::docid docid)
  98 {
  99     return db->get_document (docid);
 100 }
 101
 102 static void
 103 insert_thread_id (GHashTable *thread_ids, Xapian::Document doc)
 104 {
 105     string value_string;
 106     const char *value, *id, *comma;
 107
 108     value_string = doc.get_value (NOTMUCH_VALUE_THREAD);
 109     value = value_string.c_str();
 110     if (strlen (value)) {
 111         id = value;
 112         while (*id) {
 113             comma = strchr (id, ',');
 114             if (comma == NULL)
 115                 comma = id + strlen (id);
 116             g_hash_table_insert (thread_ids,
 117                                  strndup (id, comma - id), NULL);
 118             id = comma;
 119             if (*id)
 120                 id++;
 121         }
 122     }
 123 }
 124
 125 notmuch_message_t *
 126 notmuch_database_find_message (notmuch_database_t *notmuch,
 127                                const char *message_id)
 128 {
 129     Xapian::PostingIterator i, end;
 130
 131     find_messages_by_term (notmuch->xapian_db,
 132                            "msgid", message_id, &i, &end);
 133
 134     if (i == end)
 135         return NULL;
 136
 137     return _notmuch_message_create (notmuch, notmuch, *i);
 138 }
 139
 140 /* Return one or more thread_ids, (as a GPtrArray of strings), for the
 141  * given message based on looking into the database for any messages
 142  * referenced in parents, and also for any messages in the database
 143  * referencing message_id.
 144  *
 145  * Caller should free all strings in the array and the array itself,
 146  * (g_ptr_array_free) when done. */
 147 static GPtrArray *
 148 find_thread_ids (notmuch_database_t *notmuch,
 149                  GPtrArray *parents,
 150                  const char *message_id)
 151 {
 152     Xapian::WritableDatabase *db = notmuch->xapian_db;
 153     Xapian::PostingIterator child, children_end;
 154     Xapian::Document doc;
 155     GHashTable *thread_ids;
 156     GList *keys, *l;
 157     unsigned int i;
 158     const char *parent_message_id;
 159     GPtrArray *result;
 160
 161     thread_ids = g_hash_table_new_full (g_str_hash, g_str_equal,
 162                                         free, NULL);
 163
 164     find_messages_by_term (db, "ref", message_id, &child, &children_end);
 165     for ( ; child != children_end; child++) {
 166         doc = find_message_by_docid (db, *child);
 167         insert_thread_id (thread_ids, doc);
 168     }
 169
 170     for (i = 0; i < parents->len; i++) {
 171         notmuch_message_t *parent;
 172         notmuch_thread_ids_t *ids;
 173
 174         parent_message_id = (char *) g_ptr_array_index (parents, i);
 175         parent = notmuch_database_find_message (notmuch, parent_message_id);
 176         if (parent == NULL)
 177             continue;
 178
 179         for (ids = notmuch_message_get_thread_ids (parent);
 180              notmuch_thread_ids_has_more (ids);
 181              notmuch_thread_ids_advance (ids))
 182         {
 183             const char *id;
 184
 185             id = notmuch_thread_ids_get (ids);
 186             g_hash_table_insert (thread_ids, strdup (id), NULL);
 187         }
 188
 189         notmuch_message_destroy (parent);
 190     }
 191
 192     result = g_ptr_array_new ();
 193
 194     keys = g_hash_table_get_keys (thread_ids);
 195     for (l = keys; l; l = l->next) {
 196         char *id = (char *) l->data;
 197         g_ptr_array_add (result, id);
 198     }
 199     g_list_free (keys);
 200
 201     /* We're done with the hash table, but we've taken the pointers to
 202      * the allocated strings and put them into our result array, so
 203      * tell the hash not to free them on its way out. */
 204     g_hash_table_steal_all (thread_ids);
 205     g_hash_table_unref (thread_ids);
 206
 207     return result;
 208 }
 209
 210 /* Advance 'str' past any whitespace or RFC 822 comments. A comment is
 211  * a (potentially nested) parenthesized sequence with '\' used to
 212  * escape any character (including parentheses).
 213  *
 214  * If the sequence to be skipped continues to the end of the string,
 215  * then 'str' will be left pointing at the final terminating '\0'
 216  * character.
 217  */
 218 static void
 219 skip_space_and_comments (const char **str)
 220 {
 221     const char *s;
 222
 223     s = *str;
 224     while (*s && (isspace (*s) || *s == '(')) {
 225         while (*s && isspace (*s))
 226             s++;
 227         if (*s == '(') {
 228             int nesting = 1;
 229             s++;
 230             while (*s && nesting) {
 231                 if (*s == '(')
 232                     nesting++;
 233                 else if (*s == ')')
 234                     nesting--;
 235                 else if (*s == '\\')
 236                     if (*(s+1))
 237                         s++;
 238                 s++;
 239             }
 240         }
 241     }
 242
 243     *str = s;
 244 }
 245
 246 /* Parse an RFC 822 message-id, discarding whitespace, any RFC 822
 247  * comments, and the '<' and '>' delimeters.
 248  *
 249  * If not NULL, then *next will be made to point to the first character
 250  * not parsed, (possibly pointing to the final '\0' terminator.
 251  *
 252  * Returns a newly allocated string which the caller should free()
 253  * when done with it.
 254  *
 255  * Returns NULL if there is any error parsing the message-id. */
 256 static char *
 257 parse_message_id (const char *message_id, const char **next)
 258 {
 259     const char *s, *end;
 260     char *result;
 261
 262     if (message_id == NULL)
 263         return NULL;
 264
 265     s = message_id;
 266
 267     skip_space_and_comments (&s);
 268
 269     /* Skip any unstructured text as well. */
 270     while (*s && *s != '<')
 271         s++;
 272
 273     if (*s == '<') {
 274         s++;
 275     } else {
 276         if (next)
 277             *next = s;
 278         return NULL;
 279     }
 280
 281     skip_space_and_comments (&s);
 282
 283     end = s;
 284     while (*end && *end != '>')
 285         end++;
 286     if (next) {
 287         if (*end)
 288             *next = end + 1;
 289         else
 290             *next = end;
 291     }
 292
 293     if (end > s && *end == '>')
 294         end--;
 295     if (end <= s)
 296         return NULL;
 297
 298     result = strndup (s, end - s + 1);
 299
 300     /* Finally, collapse any whitespace that is within the message-id
 301      * itself. */
 302     {
 303         char *r;
 304         int len;
 305
 306         for (r = result, len = strlen (r); *r; r++, len--)
 307             if (*r == ' ' || *r == '\t')
 308                 memmove (r, r+1, len);
 309     }
 310
 311     return result;
 312 }
 313
 314 /* Parse a References header value, putting a copy of each referenced
 315  * message-id into 'array'. */
 316 static void
 317 parse_references (GPtrArray *array,
 318                   const char *refs)
 319 {
 320     char *ref;
 321
 322     if (refs == NULL)
 323         return;
 324
 325     while (*refs) {
 326         ref = parse_message_id (refs, &refs);
 327
 328         if (ref)
 329             g_ptr_array_add (array, ref);
 330     }
 331 }
 332
 333 char *
 334 notmuch_database_default_path (void)
 335 {
 336     if (getenv ("NOTMUCH_BASE"))
 337         return strdup (getenv ("NOTMUCH_BASE"));
 338
 339     return g_strdup_printf ("%s/mail", getenv ("HOME"));
 340 }
 341
 342 notmuch_database_t *
 343 notmuch_database_create (const char *path)
 344 {
 345     notmuch_database_t *notmuch = NULL;
 346     char *notmuch_path = NULL;
 347     struct stat st;
 348     int err;
 349     char *local_path = NULL;
 350
 351     if (path == NULL)
 352         path = local_path = notmuch_database_default_path ();
 353
 354     err = stat (path, &st);
 355     if (err) {
 356         fprintf (stderr, "Error: Cannot create database at %s: %s.\n",
 357                  path, strerror (errno));
 358         goto DONE;
 359     }
 360
 361     if (! S_ISDIR (st.st_mode)) {
 362         fprintf (stderr, "Error: Cannot create database at %s: Not a directory.\n",
 363                  path);
 364         goto DONE;
 365     }
 366
 367     notmuch_path = g_strdup_printf ("%s/%s", path, ".notmuch");
 368
 369     err = mkdir (notmuch_path, 0755);
 370
 371     if (err) {
 372         fprintf (stderr, "Error: Cannot create directory %s: %s.\n",
 373                  notmuch_path, strerror (errno));
 374         goto DONE;
 375     }
 376
 377     notmuch = notmuch_database_open (path);
 378
 379   DONE:
 380     if (notmuch_path)
 381         free (notmuch_path);
 382     if (local_path)
 383         free (local_path);
 384
 385     return notmuch;
 386 }
 387
 388 notmuch_database_t *
 389 notmuch_database_open (const char *path)
 390 {
 391     notmuch_database_t *notmuch = NULL;
 392     char *notmuch_path = NULL, *xapian_path = NULL;
 393     struct stat st;
 394     int err;
 395     char *local_path = NULL;
 396
 397     if (path == NULL)
 398         path = local_path = notmuch_database_default_path ();
 399
 400     notmuch_path = g_strdup_printf ("%s/%s", path, ".notmuch");
 401
 402     err = stat (notmuch_path, &st);
 403     if (err) {
 404         fprintf (stderr, "Error opening database at %s: %s\n",
 405                  notmuch_path, strerror (errno));
 406         goto DONE;
 407     }
 408
 409     xapian_path = g_strdup_printf ("%s/%s", notmuch_path, "xapian");
 410
 411     notmuch = talloc (NULL, notmuch_database_t);
 412     notmuch->path = talloc_strdup (notmuch, path);
 413
 414     try {
 415         notmuch->xapian_db = new Xapian::WritableDatabase (xapian_path,
 416                                                            Xapian::DB_CREATE_OR_OPEN);
 417         notmuch->query_parser = new Xapian::QueryParser;
 418         notmuch->query_parser->set_default_op (Xapian::Query::OP_AND);
 419         notmuch->query_parser->set_database (*notmuch->xapian_db);
 420     } catch (const Xapian::Error &error) {
 421         fprintf (stderr, "A Xapian exception occurred: %s\n",
 422                  error.get_msg().c_str());
 423     }
 424
 425   DONE:
 426     if (local_path)
 427         free (local_path);
 428     if (notmuch_path)
 429         free (notmuch_path);
 430     if (xapian_path)
 431         free (xapian_path);
 432
 433     return notmuch;
 434 }
 435
 436 void
 437 notmuch_database_close (notmuch_database_t *notmuch)
 438 {
 439     delete notmuch->query_parser;
 440     delete notmuch->xapian_db;
 441     talloc_free (notmuch);
 442 }
 443
 444 const char *
 445 notmuch_database_get_path (notmuch_database_t *notmuch)
 446 {
 447     return notmuch->path;
 448 }
 449
 450 notmuch_status_t
 451 notmuch_database_add_message (notmuch_database_t *notmuch,
 452                               const char *filename)
 453 {
 454     notmuch_message_file_t *message_file;
 455     notmuch_message_t *message;
 456     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
 457
 458     GPtrArray *parents, *thread_ids;
 459
 460     const char *refs, *in_reply_to, *date, *header;
 461     const char *from, *to, *subject, *old_filename;
 462     char *message_id;
 463
 464     unsigned int i;
 465
 466     message_file = notmuch_message_file_open (filename);
 467     if (message_file == NULL) {
 468         ret = NOTMUCH_STATUS_FILE_ERROR;
 469         goto DONE;
 470     }
 471
 472     notmuch_message_file_restrict_headers (message_file,
 473                                            "date",
 474                                            "from",
 475                                            "in-reply-to",
 476                                            "message-id",
 477                                            "references",
 478                                            "subject",
 479                                            "to",
 480                                            (char *) NULL);
 481
 482     try {
 483         /* The first order of business is to find/create a message ID. */
 484
 485         header = notmuch_message_file_get_header (message_file, "message-id");
 486         if (header) {
 487             message_id = parse_message_id (header, NULL);
 488             /* So the header value isn't RFC-compliant, but it's
 489              * better than no message-id at all. */
 490             if (message_id == NULL)
 491                 message_id = xstrdup (header);
 492         } else {
 493             /* No message-id at all, let's generate one by taking a
 494              * hash over the file's contents. */
 495             char *sha1 = notmuch_sha1_of_file (filename);
 496
 497             /* If that failed too, something is really wrong. Give up. */
 498             if (sha1 == NULL) {
 499                 ret = NOTMUCH_STATUS_FILE_ERROR;
 500                 goto DONE;
 501             }
 502
 503             message_id = g_strdup_printf ("notmuch-sha1-%s", sha1);
 504             free (sha1);
 505         }
 506
 507         /* Now that we have a message ID, we get a message object,
 508          * (which may or may not reference an existing document in the
 509          * database). */
 510
 511         /* Use NULL for owner since we want to free this locally. */
 512
 513         /* XXX: This call can fail by either out-of-memory or an
 514          * "impossible" Xapian exception. We should rewrite it to
 515          * allow us to propagate the error status. */
 516         message = _notmuch_message_create_for_message_id (NULL, notmuch,
 517                                                           message_id);
 518         if (message == NULL) {
 519             fprintf (stderr, "Internal error. This shouldn't happen.\n\n");
 520             fprintf (stderr, "I mean, it's possible you ran out of memory, but then this code path is still an internal error since it should have detected that and propagated the status value up the stack.\n");
 521             exit (1);
 522         }
 523
 524         /* Has a message previously been added with the same ID? */
 525         old_filename = notmuch_message_get_filename (message);
 526         if (old_filename && strlen (old_filename)) {
 527             /* XXX: This is too noisy to actually print, and what do we
 528              * really expect the user to do? Go manually delete a
 529              * redundant message or merge two similar messages?
 530              * Instead we should handle this transparently.
 531              *
 532              * What we likely want to move to is adding both filenames
 533              * to the database so that subsequent indexing will pick up
 534              * terms from both files.
 535              */
 536 #if 0
 537             fprintf (stderr,
 538                      "Note: Attempting to add a message with a duplicate message ID:\n"
 539                      "Old: %s\n"   "New: %s\n",
 540                      old_filename, filename);
 541             fprintf (stderr, "The old filename will be used, but any new terms\n"
 542                      "from the new message will added to the database.\n");
 543 #endif
 544         } else {
 545             _notmuch_message_set_filename (message, filename);
 546             _notmuch_message_add_term (message, "type", "mail");
 547         }
 548
 549         /* Next, find the thread(s) to which this message belongs. */
 550         parents = g_ptr_array_new ();
 551
 552         refs = notmuch_message_file_get_header (message_file, "references");
 553         parse_references (parents, refs);
 554
 555         in_reply_to = notmuch_message_file_get_header (message_file, "in-reply-to");
 556         parse_references (parents, in_reply_to);
 557
 558         for (i = 0; i < parents->len; i++)
 559             _notmuch_message_add_term (message, "ref",
 560                                        (char *) g_ptr_array_index (parents, i));
 561
 562         thread_ids = find_thread_ids (notmuch, parents, message_id);
 563
 564         free (message_id);
 565
 566         for (i = 0; i < parents->len; i++)
 567             g_free (g_ptr_array_index (parents, i));
 568         g_ptr_array_free (parents, TRUE);
 569
 570         if (thread_ids->len) {
 571             unsigned int i;
 572             GString *thread_id;
 573             char *id;
 574
 575             for (i = 0; i < thread_ids->len; i++) {
 576                 id = (char *) thread_ids->pdata[i];
 577                 _notmuch_message_add_thread_id (message, id);
 578                 if (i == 0)
 579                     thread_id = g_string_new (id);
 580                 else
 581                     g_string_append_printf (thread_id, ",%s", id);
 582
 583                 free (id);
 584             }
 585             g_string_free (thread_id, TRUE);
 586         } else {
 587             _notmuch_message_ensure_thread_id (message);
 588         }
 589
 590         g_ptr_array_free (thread_ids, TRUE);
 591
 592         date = notmuch_message_file_get_header (message_file, "date");
 593         _notmuch_message_set_date (message, date);
 594
 595         from = notmuch_message_file_get_header (message_file, "from");
 596         subject = notmuch_message_file_get_header (message_file, "subject");
 597         to = notmuch_message_file_get_header (message_file, "to");
 598
 599         if (from == NULL &&
 600             subject == NULL &&
 601             to == NULL)
 602         {
 603             ret = NOTMUCH_STATUS_FILE_NOT_EMAIL;
 604             goto DONE;
 605         } else {
 606             _notmuch_message_sync (message);
 607         }
 608     } catch (const Xapian::Error &error) {
 609         fprintf (stderr, "A Xapian exception occurred: %s.\n",
 610                  error.get_msg().c_str());
 611         ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 612         goto DONE;
 613     }
 614
 615   DONE:
 616     if (message)
 617         notmuch_message_destroy (message);
 618     if (message_file)
 619         notmuch_message_file_close (message_file);
 620
 621     return ret;
 622 }