git.notmuchmail.org Git - notmuch/blob - lib/database.cc

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