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 char *
 394 _notmuch_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 = _notmuch_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     /* Many Xapian objects (and thus notmuch objects) hold references to
 907      * the database, so merely deleting the database may not suffice to
 908      * close it.  Thus, we explicitly close it here. */
 909     if (notmuch->xapian_db != NULL) {
 910         try {
 911             /* If there's an outstanding transaction, it's unclear if
 912              * closing the Xapian database commits everything up to
 913              * that transaction, or may discard committed (but
 914              * unflushed) transactions.  To be certain, explicitly
 915              * cancel any outstanding transaction before closing. */
 916             if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_WRITE &&
 917                 notmuch->atomic_nesting)
 918                 (static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db))
 919                     ->cancel_transaction ();
 920
 921             /* Close the database.  This implicitly flushes
 922              * outstanding changes. */
 923             notmuch->xapian_db->close();
 924         } catch (const Xapian::Error &error) {
 925             status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 926             if (! notmuch->exception_reported) {
 927                 fprintf (stderr, "Error: A Xapian exception occurred closing database: %s\n",
 928                          error.get_msg().c_str());
 929             }
 930         }
 931     }
 932
 933     delete notmuch->term_gen;
 934     notmuch->term_gen = NULL;
 935     delete notmuch->query_parser;
 936     notmuch->query_parser = NULL;
 937     delete notmuch->xapian_db;
 938     notmuch->xapian_db = NULL;
 939     delete notmuch->value_range_processor;
 940     notmuch->value_range_processor = NULL;
 941     delete notmuch->date_range_processor;
 942     notmuch->date_range_processor = NULL;
 943
 944     return status;
 945 }
 946
 947 #if HAVE_XAPIAN_COMPACT
 948 static int
 949 unlink_cb (const char *path,
 950            unused (const struct stat *sb),
 951            unused (int type),
 952            unused (struct FTW *ftw))
 953 {
 954     return remove (path);
 955 }
 956
 957 static int
 958 rmtree (const char *path)
 959 {
 960     return nftw (path, unlink_cb, 64, FTW_DEPTH | FTW_PHYS);
 961 }
 962
 963 class NotmuchCompactor : public Xapian::Compactor
 964 {
 965     notmuch_compact_status_cb_t status_cb;
 966     void *status_closure;
 967
 968 public:
 969     NotmuchCompactor(notmuch_compact_status_cb_t cb, void *closure) :
 970         status_cb (cb), status_closure (closure) { }
 971
 972     virtual void
 973     set_status (const std::string &table, const std::string &status)
 974     {
 975         char *msg;
 976
 977         if (status_cb == NULL)
 978             return;
 979
 980         if (status.length () == 0)
 981             msg = talloc_asprintf (NULL, "compacting table %s", table.c_str());
 982         else
 983             msg = talloc_asprintf (NULL, "     %s", status.c_str());
 984
 985         if (msg == NULL) {
 986             return;
 987         }
 988
 989         status_cb (msg, status_closure);
 990         talloc_free (msg);
 991     }
 992 };
 993
 994 /* Compacts the given database, optionally saving the original database
 995  * in backup_path. Additionally, a callback function can be provided to
 996  * give the user feedback on the progress of the (likely long-lived)
 997  * compaction process.
 998  *
 999  * The backup path must point to a directory on the same volume as the
1000  * original database. Passing a NULL backup_path will result in the
1001  * uncompacted database being deleted after compaction has finished.
1002  * Note that the database write lock will be held during the
1003  * compaction process to protect data integrity.
1004  */
1005 notmuch_status_t
1006 notmuch_database_compact (const char *path,
1007                           const char *backup_path,
1008                           notmuch_compact_status_cb_t status_cb,
1009                           void *closure)
1010 {
1011     void *local;
1012     char *notmuch_path, *xapian_path, *compact_xapian_path;
1013     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1014     notmuch_database_t *notmuch = NULL;
1015     struct stat statbuf;
1016     notmuch_bool_t keep_backup;
1017
1018     local = talloc_new (NULL);
1019     if (! local)
1020         return NOTMUCH_STATUS_OUT_OF_MEMORY;
1021
1022     ret = notmuch_database_open (path, NOTMUCH_DATABASE_MODE_READ_WRITE, &notmuch);
1023     if (ret) {
1024         goto DONE;
1025     }
1026
1027     if (! (notmuch_path = talloc_asprintf (local, "%s/%s", path, ".notmuch"))) {
1028         ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
1029         goto DONE;
1030     }
1031
1032     if (! (xapian_path = talloc_asprintf (local, "%s/%s", notmuch_path, "xapian"))) {
1033         ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
1034         goto DONE;
1035     }
1036
1037     if (! (compact_xapian_path = talloc_asprintf (local, "%s.compact", xapian_path))) {
1038         ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
1039         goto DONE;
1040     }
1041
1042     if (backup_path == NULL) {
1043         if (! (backup_path = talloc_asprintf (local, "%s.old", xapian_path))) {
1044             ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
1045             goto DONE;
1046         }
1047         keep_backup = FALSE;
1048     }
1049     else {
1050         keep_backup = TRUE;
1051     }
1052
1053     if (stat (backup_path, &statbuf) != -1) {
1054         fprintf (stderr, "Path already exists: %s\n", backup_path);
1055         ret = NOTMUCH_STATUS_FILE_ERROR;
1056         goto DONE;
1057     }
1058     if (errno != ENOENT) {
1059         fprintf (stderr, "Unknown error while stat()ing path: %s\n",
1060                  strerror (errno));
1061         ret = NOTMUCH_STATUS_FILE_ERROR;
1062         goto DONE;
1063     }
1064
1065     /* Unconditionally attempt to remove old work-in-progress database (if
1066      * any). This is "protected" by database lock. If this fails due to write
1067      * errors (etc), the following code will fail and provide error message.
1068      */
1069     (void) rmtree (compact_xapian_path);
1070
1071     try {
1072         NotmuchCompactor compactor (status_cb, closure);
1073
1074         compactor.set_renumber (false);
1075         compactor.add_source (xapian_path);
1076         compactor.set_destdir (compact_xapian_path);
1077         compactor.compact ();
1078     } catch (const Xapian::Error &error) {
1079         fprintf (stderr, "Error while compacting: %s\n", error.get_msg().c_str());
1080         ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
1081         goto DONE;
1082     }
1083
1084     if (rename (xapian_path, backup_path)) {
1085         fprintf (stderr, "Error moving %s to %s: %s\n",
1086                  xapian_path, backup_path, strerror (errno));
1087         ret = NOTMUCH_STATUS_FILE_ERROR;
1088         goto DONE;
1089     }
1090
1091     if (rename (compact_xapian_path, xapian_path)) {
1092         fprintf (stderr, "Error moving %s to %s: %s\n",
1093                  compact_xapian_path, xapian_path, strerror (errno));
1094         ret = NOTMUCH_STATUS_FILE_ERROR;
1095         goto DONE;
1096     }
1097
1098     if (! keep_backup) {
1099         if (rmtree (backup_path)) {
1100             fprintf (stderr, "Error removing old database %s: %s\n",
1101                      backup_path, strerror (errno));
1102             ret = NOTMUCH_STATUS_FILE_ERROR;
1103             goto DONE;
1104         }
1105     }
1106
1107   DONE:
1108     if (notmuch) {
1109         notmuch_status_t ret2;
1110
1111         ret2 = notmuch_database_destroy (notmuch);
1112
1113         /* don't clobber previous error status */
1114         if (ret == NOTMUCH_STATUS_SUCCESS && ret2 != NOTMUCH_STATUS_SUCCESS)
1115             ret = ret2;
1116     }
1117
1118     talloc_free (local);
1119
1120     return ret;
1121 }
1122 #else
1123 notmuch_status_t
1124 notmuch_database_compact (unused (const char *path),
1125                           unused (const char *backup_path),
1126                           unused (notmuch_compact_status_cb_t status_cb),
1127                           unused (void *closure))
1128 {
1129     fprintf (stderr, "notmuch was compiled against a xapian version lacking compaction support.\n");
1130     return NOTMUCH_STATUS_UNSUPPORTED_OPERATION;
1131 }
1132 #endif
1133
1134 notmuch_status_t
1135 notmuch_database_destroy (notmuch_database_t *notmuch)
1136 {
1137     notmuch_status_t status;
1138
1139     status = notmuch_database_close (notmuch);
1140     talloc_free (notmuch);
1141
1142     return status;
1143 }
1144
1145 const char *
1146 notmuch_database_get_path (notmuch_database_t *notmuch)
1147 {
1148     return notmuch->path;
1149 }
1150
1151 unsigned int
1152 notmuch_database_get_version (notmuch_database_t *notmuch)
1153 {
1154     unsigned int version;
1155     string version_string;
1156     const char *str;
1157     char *end;
1158
1159     version_string = notmuch->xapian_db->get_metadata ("version");
1160     if (version_string.empty ())
1161         return 0;
1162
1163     str = version_string.c_str ();
1164     if (str == NULL || *str == '\0')
1165         return 0;
1166
1167     version = strtoul (str, &end, 10);
1168     if (*end != '\0')
1169         INTERNAL_ERROR ("Malformed database version: %s", str);
1170
1171     return version;
1172 }
1173
1174 notmuch_bool_t
1175 notmuch_database_needs_upgrade (notmuch_database_t *notmuch)
1176 {
1177     return notmuch->mode == NOTMUCH_DATABASE_MODE_READ_WRITE &&
1178         ((NOTMUCH_FEATURES_CURRENT & ~notmuch->features) ||
1179          (notmuch_database_get_version (notmuch) < NOTMUCH_DATABASE_VERSION));
1180 }
1181
1182 static volatile sig_atomic_t do_progress_notify = 0;
1183
1184 static void
1185 handle_sigalrm (unused (int signal))
1186 {
1187     do_progress_notify = 1;
1188 }
1189
1190 /* Upgrade the current database.
1191  *
1192  * After opening a database in read-write mode, the client should
1193  * check if an upgrade is needed (notmuch_database_needs_upgrade) and
1194  * if so, upgrade with this function before making any modifications.
1195  *
1196  * The optional progress_notify callback can be used by the caller to
1197  * provide progress indication to the user. If non-NULL it will be
1198  * called periodically with 'count' as the number of messages upgraded
1199  * so far and 'total' the overall number of messages that will be
1200  * converted.
1201  */
1202 notmuch_status_t
1203 notmuch_database_upgrade (notmuch_database_t *notmuch,
1204                           void (*progress_notify) (void *closure,
1205                                                    double progress),
1206                           void *closure)
1207 {
1208     void *local = talloc_new (NULL);
1209     Xapian::TermIterator t, t_end;
1210     Xapian::WritableDatabase *db;
1211     struct sigaction action;
1212     struct itimerval timerval;
1213     notmuch_bool_t timer_is_active = FALSE;
1214     enum _notmuch_features target_features, new_features;
1215     notmuch_status_t status;
1216     unsigned int count = 0, total = 0;
1217
1218     status = _notmuch_database_ensure_writable (notmuch);
1219     if (status)
1220         return status;
1221
1222     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
1223
1224     target_features = notmuch->features | NOTMUCH_FEATURES_CURRENT;
1225     new_features = NOTMUCH_FEATURES_CURRENT & ~notmuch->features;
1226
1227     if (! notmuch_database_needs_upgrade (notmuch))
1228         return NOTMUCH_STATUS_SUCCESS;
1229
1230     if (progress_notify) {
1231         /* Setup our handler for SIGALRM */
1232         memset (&action, 0, sizeof (struct sigaction));
1233         action.sa_handler = handle_sigalrm;
1234         sigemptyset (&action.sa_mask);
1235         action.sa_flags = SA_RESTART;
1236         sigaction (SIGALRM, &action, NULL);
1237
1238         /* Then start a timer to send SIGALRM once per second. */
1239         timerval.it_interval.tv_sec = 1;
1240         timerval.it_interval.tv_usec = 0;
1241         timerval.it_value.tv_sec = 1;
1242         timerval.it_value.tv_usec = 0;
1243         setitimer (ITIMER_REAL, &timerval, NULL);
1244
1245         timer_is_active = TRUE;
1246     }
1247
1248     /* Figure out how much total work we need to do. */
1249     if (new_features &
1250         (NOTMUCH_FEATURE_FILE_TERMS | NOTMUCH_FEATURE_BOOL_FOLDER)) {
1251         notmuch_query_t *query = notmuch_query_create (notmuch, "");
1252         total += notmuch_query_count_messages (query);
1253         notmuch_query_destroy (query);
1254     }
1255     if (new_features & NOTMUCH_FEATURE_DIRECTORY_DOCS) {
1256         t_end = db->allterms_end ("XTIMESTAMP");
1257         for (t = db->allterms_begin ("XTIMESTAMP"); t != t_end; t++)
1258             ++total;
1259     }
1260
1261     /* Perform the upgrade in a transaction. */
1262     db->begin_transaction (true);
1263
1264     /* Set the target features so we write out changes in the desired
1265      * format. */
1266     notmuch->features = target_features;
1267
1268     /* Perform per-message upgrades. */
1269     if (new_features &
1270         (NOTMUCH_FEATURE_FILE_TERMS | NOTMUCH_FEATURE_BOOL_FOLDER)) {
1271         notmuch_query_t *query = notmuch_query_create (notmuch, "");
1272         notmuch_messages_t *messages;
1273         notmuch_message_t *message;
1274         char *filename;
1275
1276         for (messages = notmuch_query_search_messages (query);
1277              notmuch_messages_valid (messages);
1278              notmuch_messages_move_to_next (messages))
1279         {
1280             if (do_progress_notify) {
1281                 progress_notify (closure, (double) count / total);
1282                 do_progress_notify = 0;
1283             }
1284
1285             message = notmuch_messages_get (messages);
1286
1287             /* Before version 1, each message document had its
1288              * filename in the data field. Copy that into the new
1289              * format by calling notmuch_message_add_filename.
1290              */
1291             if (new_features & NOTMUCH_FEATURE_FILE_TERMS) {
1292                 filename = _notmuch_message_talloc_copy_data (message);
1293                 if (filename && *filename != '\0') {
1294                     _notmuch_message_add_filename (message, filename);
1295                     _notmuch_message_clear_data (message);
1296                 }
1297                 talloc_free (filename);
1298             }
1299
1300             /* Prior to version 2, the "folder:" prefix was
1301              * probabilistic and stemmed. Change it to the current
1302              * boolean prefix. Add "path:" prefixes while at it.
1303              */
1304             if (new_features & NOTMUCH_FEATURE_BOOL_FOLDER)
1305                 _notmuch_message_upgrade_folder (message);
1306
1307             _notmuch_message_sync (message);
1308
1309             notmuch_message_destroy (message);
1310
1311             count++;
1312         }
1313
1314         notmuch_query_destroy (query);
1315     }
1316
1317     /* Perform per-directory upgrades. */
1318
1319     /* Before version 1 we stored directory timestamps in
1320      * XTIMESTAMP documents instead of the current XDIRECTORY
1321      * documents. So copy those as well. */
1322     if (new_features & NOTMUCH_FEATURE_DIRECTORY_DOCS) {
1323         t_end = notmuch->xapian_db->allterms_end ("XTIMESTAMP");
1324
1325         for (t = notmuch->xapian_db->allterms_begin ("XTIMESTAMP");
1326              t != t_end;
1327              t++)
1328         {
1329             Xapian::PostingIterator p, p_end;
1330             std::string term = *t;
1331
1332             p_end = notmuch->xapian_db->postlist_end (term);
1333
1334             for (p = notmuch->xapian_db->postlist_begin (term);
1335                  p != p_end;
1336                  p++)
1337             {
1338                 Xapian::Document document;
1339                 time_t mtime;
1340                 notmuch_directory_t *directory;
1341
1342                 if (do_progress_notify) {
1343                     progress_notify (closure, (double) count / total);
1344                     do_progress_notify = 0;
1345                 }
1346
1347                 document = find_document_for_doc_id (notmuch, *p);
1348                 mtime = Xapian::sortable_unserialise (
1349                     document.get_value (NOTMUCH_VALUE_TIMESTAMP));
1350
1351                 directory = _notmuch_directory_create (notmuch, term.c_str() + 10,
1352                                                        NOTMUCH_FIND_CREATE, &status);
1353                 notmuch_directory_set_mtime (directory, mtime);
1354                 notmuch_directory_destroy (directory);
1355
1356                 db->delete_document (*p);
1357             }
1358
1359             ++count;
1360         }
1361     }
1362
1363     db->set_metadata ("features", _print_features (local, notmuch->features));
1364     db->set_metadata ("version", STRINGIFY (NOTMUCH_DATABASE_VERSION));
1365
1366     db->commit_transaction ();
1367
1368     if (timer_is_active) {
1369         /* Now stop the timer. */
1370         timerval.it_interval.tv_sec = 0;
1371         timerval.it_interval.tv_usec = 0;
1372         timerval.it_value.tv_sec = 0;
1373         timerval.it_value.tv_usec = 0;
1374         setitimer (ITIMER_REAL, &timerval, NULL);
1375
1376         /* And disable the signal handler. */
1377         action.sa_handler = SIG_IGN;
1378         sigaction (SIGALRM, &action, NULL);
1379     }
1380
1381     talloc_free (local);
1382     return NOTMUCH_STATUS_SUCCESS;
1383 }
1384
1385 notmuch_status_t
1386 notmuch_database_begin_atomic (notmuch_database_t *notmuch)
1387 {
1388     if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY ||
1389         notmuch->atomic_nesting > 0)
1390         goto DONE;
1391
1392     try {
1393         (static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db))->begin_transaction (false);
1394     } catch (const Xapian::Error &error) {
1395         fprintf (stderr, "A Xapian exception occurred beginning transaction: %s.\n",
1396                  error.get_msg().c_str());
1397         notmuch->exception_reported = TRUE;
1398         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
1399     }
1400
1401 DONE:
1402     notmuch->atomic_nesting++;
1403     return NOTMUCH_STATUS_SUCCESS;
1404 }
1405
1406 notmuch_status_t
1407 notmuch_database_end_atomic (notmuch_database_t *notmuch)
1408 {
1409     Xapian::WritableDatabase *db;
1410
1411     if (notmuch->atomic_nesting == 0)
1412         return NOTMUCH_STATUS_UNBALANCED_ATOMIC;
1413
1414     if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY ||
1415         notmuch->atomic_nesting > 1)
1416         goto DONE;
1417
1418     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
1419     try {
1420         db->commit_transaction ();
1421
1422         /* This is a hack for testing.  Xapian never flushes on a
1423          * non-flushed commit, even if the flush threshold is 1.
1424          * However, we rely on flushing to test atomicity. */
1425         const char *thresh = getenv ("XAPIAN_FLUSH_THRESHOLD");
1426         if (thresh && atoi (thresh) == 1)
1427             db->flush ();
1428     } catch (const Xapian::Error &error) {
1429         fprintf (stderr, "A Xapian exception occurred committing transaction: %s.\n",
1430                  error.get_msg().c_str());
1431         notmuch->exception_reported = TRUE;
1432         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
1433     }
1434
1435 DONE:
1436     notmuch->atomic_nesting--;
1437     return NOTMUCH_STATUS_SUCCESS;
1438 }
1439
1440 /* We allow the user to use arbitrarily long paths for directories. But
1441  * we have a term-length limit. So if we exceed that, we'll use the
1442  * SHA-1 of the path for the database term.
1443  *
1444  * Note: This function may return the original value of 'path'. If it
1445  * does not, then the caller is responsible to free() the returned
1446  * value.
1447  */
1448 const char *
1449 _notmuch_database_get_directory_db_path (const char *path)
1450 {
1451     int term_len = strlen (_find_prefix ("directory")) + strlen (path);
1452
1453     if (term_len > NOTMUCH_TERM_MAX)
1454         return _notmuch_sha1_of_string (path);
1455     else
1456         return path;
1457 }
1458
1459 /* Given a path, split it into two parts: the directory part is all
1460  * components except for the last, and the basename is that last
1461  * component. Getting the return-value for either part is optional
1462  * (the caller can pass NULL).
1463  *
1464  * The original 'path' can represent either a regular file or a
1465  * directory---the splitting will be carried out in the same way in
1466  * either case. Trailing slashes on 'path' will be ignored, and any
1467  * cases of multiple '/' characters appearing in series will be
1468  * treated as a single '/'.
1469  *
1470  * Allocation (if any) will have 'ctx' as the talloc owner. But
1471  * pointers will be returned within the original path string whenever
1472  * possible.
1473  *
1474  * Note: If 'path' is non-empty and contains no non-trailing slash,
1475  * (that is, consists of a filename with no parent directory), then
1476  * the directory returned will be an empty string. However, if 'path'
1477  * is an empty string, then both directory and basename will be
1478  * returned as NULL.
1479  */
1480 notmuch_status_t
1481 _notmuch_database_split_path (void *ctx,
1482                               const char *path,
1483                               const char **directory,
1484                               const char **basename)
1485 {
1486     const char *slash;
1487
1488     if (path == NULL || *path == '\0') {
1489         if (directory)
1490             *directory = NULL;
1491         if (basename)
1492             *basename = NULL;
1493         return NOTMUCH_STATUS_SUCCESS;
1494     }
1495
1496     /* Find the last slash (not counting a trailing slash), if any. */
1497
1498     slash = path + strlen (path) - 1;
1499
1500     /* First, skip trailing slashes. */
1501     while (slash != path) {
1502         if (*slash != '/')
1503             break;
1504
1505         --slash;
1506     }
1507
1508     /* Then, find a slash. */
1509     while (slash != path) {
1510         if (*slash == '/')
1511             break;
1512
1513         if (basename)
1514             *basename = slash;
1515
1516         --slash;
1517     }
1518
1519     /* Finally, skip multiple slashes. */
1520     while (slash != path) {
1521         if (*slash != '/')
1522             break;
1523
1524         --slash;
1525     }
1526
1527     if (slash == path) {
1528         if (directory)
1529             *directory = talloc_strdup (ctx, "");
1530         if (basename)
1531             *basename = path;
1532     } else {
1533         if (directory)
1534             *directory = talloc_strndup (ctx, path, slash - path + 1);
1535     }
1536
1537     return NOTMUCH_STATUS_SUCCESS;
1538 }
1539
1540 /* Find the document ID of the specified directory.
1541  *
1542  * If (flags & NOTMUCH_FIND_CREATE), a new directory document will be
1543  * created if one does not exist for 'path'.  Otherwise, if the
1544  * directory document does not exist, this sets *directory_id to
1545  * ((unsigned int)-1) and returns NOTMUCH_STATUS_SUCCESS.
1546  */
1547 notmuch_status_t
1548 _notmuch_database_find_directory_id (notmuch_database_t *notmuch,
1549                                      const char *path,
1550                                      notmuch_find_flags_t flags,
1551                                      unsigned int *directory_id)
1552 {
1553     notmuch_directory_t *directory;
1554     notmuch_status_t status;
1555
1556     if (path == NULL) {
1557         *directory_id = 0;
1558         return NOTMUCH_STATUS_SUCCESS;
1559     }
1560
1561     directory = _notmuch_directory_create (notmuch, path, flags, &status);
1562     if (status || !directory) {
1563         *directory_id = -1;
1564         return status;
1565     }
1566
1567     *directory_id = _notmuch_directory_get_document_id (directory);
1568
1569     notmuch_directory_destroy (directory);
1570
1571     return NOTMUCH_STATUS_SUCCESS;
1572 }
1573
1574 const char *
1575 _notmuch_database_get_directory_path (void *ctx,
1576                                       notmuch_database_t *notmuch,
1577                                       unsigned int doc_id)
1578 {
1579     Xapian::Document document;
1580
1581     document = find_document_for_doc_id (notmuch, doc_id);
1582
1583     return talloc_strdup (ctx, document.get_data ().c_str ());
1584 }
1585
1586 /* Given a legal 'filename' for the database, (either relative to
1587  * database path or absolute with initial components identical to
1588  * database path), return a new string (with 'ctx' as the talloc
1589  * owner) suitable for use as a direntry term value.
1590  *
1591  * If (flags & NOTMUCH_FIND_CREATE), the necessary directory documents
1592  * will be created in the database as needed.  Otherwise, if the
1593  * necessary directory documents do not exist, this sets
1594  * *direntry to NULL and returns NOTMUCH_STATUS_SUCCESS.
1595  */
1596 notmuch_status_t
1597 _notmuch_database_filename_to_direntry (void *ctx,
1598                                         notmuch_database_t *notmuch,
1599                                         const char *filename,
1600                                         notmuch_find_flags_t flags,
1601                                         char **direntry)
1602 {
1603     const char *relative, *directory, *basename;
1604     Xapian::docid directory_id;
1605     notmuch_status_t status;
1606
1607     relative = _notmuch_database_relative_path (notmuch, filename);
1608
1609     status = _notmuch_database_split_path (ctx, relative,
1610                                            &directory, &basename);
1611     if (status)
1612         return status;
1613
1614     status = _notmuch_database_find_directory_id (notmuch, directory, flags,
1615                                                   &directory_id);
1616     if (status || directory_id == (unsigned int)-1) {
1617         *direntry = NULL;
1618         return status;
1619     }
1620
1621     *direntry = talloc_asprintf (ctx, "%u:%s", directory_id, basename);
1622
1623     return NOTMUCH_STATUS_SUCCESS;
1624 }
1625
1626 /* Given a legal 'path' for the database, return the relative path.
1627  *
1628  * The return value will be a pointer to the original path contents,
1629  * and will be either the original string (if 'path' was relative) or
1630  * a portion of the string (if path was absolute and begins with the
1631  * database path).
1632  */
1633 const char *
1634 _notmuch_database_relative_path (notmuch_database_t *notmuch,
1635                                  const char *path)
1636 {
1637     const char *db_path, *relative;
1638     unsigned int db_path_len;
1639
1640     db_path = notmuch_database_get_path (notmuch);
1641     db_path_len = strlen (db_path);
1642
1643     relative = path;
1644
1645     if (*relative == '/') {
1646         while (*relative == '/' && *(relative+1) == '/')
1647             relative++;
1648
1649         if (strncmp (relative, db_path, db_path_len) == 0)
1650         {
1651             relative += db_path_len;
1652             while (*relative == '/')
1653                 relative++;
1654         }
1655     }
1656
1657     return relative;
1658 }
1659
1660 notmuch_status_t
1661 notmuch_database_get_directory (notmuch_database_t *notmuch,
1662                                 const char *path,
1663                                 notmuch_directory_t **directory)
1664 {
1665     notmuch_status_t status;
1666
1667     if (directory == NULL)
1668         return NOTMUCH_STATUS_NULL_POINTER;
1669     *directory = NULL;
1670
1671     try {
1672         *directory = _notmuch_directory_create (notmuch, path,
1673                                                 NOTMUCH_FIND_LOOKUP, &status);
1674     } catch (const Xapian::Error &error) {
1675         fprintf (stderr, "A Xapian exception occurred getting directory: %s.\n",
1676                  error.get_msg().c_str());
1677         notmuch->exception_reported = TRUE;
1678         status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
1679     }
1680     return status;
1681 }
1682
1683 /* Allocate a document ID that satisfies the following criteria:
1684  *
1685  * 1. The ID does not exist for any document in the Xapian database
1686  *
1687  * 2. The ID was not previously returned from this function
1688  *
1689  * 3. The ID is the smallest integer satisfying (1) and (2)
1690  *
1691  * This function will trigger an internal error if these constraints
1692  * cannot all be satisfied, (that is, the pool of available document
1693  * IDs has been exhausted).
1694  */
1695 unsigned int
1696 _notmuch_database_generate_doc_id (notmuch_database_t *notmuch)
1697 {
1698     assert (notmuch->last_doc_id >= notmuch->xapian_db->get_lastdocid ());
1699
1700     notmuch->last_doc_id++;
1701
1702     if (notmuch->last_doc_id == 0)
1703         INTERNAL_ERROR ("Xapian document IDs are exhausted.\n");
1704
1705     return notmuch->last_doc_id;
1706 }
1707
1708 static const char *
1709 _notmuch_database_generate_thread_id (notmuch_database_t *notmuch)
1710 {
1711     /* 16 bytes (+ terminator) for hexadecimal representation of
1712      * a 64-bit integer. */
1713     static char thread_id[17];
1714     Xapian::WritableDatabase *db;
1715
1716     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
1717
1718     notmuch->last_thread_id++;
1719
1720     sprintf (thread_id, "%016" PRIx64, notmuch->last_thread_id);
1721
1722     db->set_metadata ("last_thread_id", thread_id);
1723
1724     return thread_id;
1725 }
1726
1727 static char *
1728 _get_metadata_thread_id_key (void *ctx, const char *message_id)
1729 {
1730     if (strlen (message_id) > NOTMUCH_MESSAGE_ID_MAX)
1731         message_id = _notmuch_message_id_compressed (ctx, message_id);
1732
1733     return talloc_asprintf (ctx, NOTMUCH_METADATA_THREAD_ID_PREFIX "%s",
1734                             message_id);
1735 }
1736
1737 /* Find the thread ID to which the message with 'message_id' belongs.
1738  *
1739  * Note: 'thread_id_ret' must not be NULL!
1740  * On success '*thread_id_ret' is set to a newly talloced string belonging to
1741  * 'ctx'.
1742  *
1743  * Note: If there is no message in the database with the given
1744  * 'message_id' then a new thread_id will be allocated for this
1745  * message and stored in the database metadata, (where this same
1746  * thread ID can be looked up if the message is added to the database
1747  * later).
1748  */
1749 static notmuch_status_t
1750 _resolve_message_id_to_thread_id (notmuch_database_t *notmuch,
1751                                   void *ctx,
1752                                   const char *message_id,
1753                                   const char **thread_id_ret)
1754 {
1755     notmuch_status_t status;
1756     notmuch_message_t *message;
1757     string thread_id_string;
1758     char *metadata_key;
1759     Xapian::WritableDatabase *db;
1760
1761     status = notmuch_database_find_message (notmuch, message_id, &message);
1762
1763     if (status)
1764         return status;
1765
1766     if (message) {
1767         *thread_id_ret = talloc_steal (ctx,
1768                                        notmuch_message_get_thread_id (message));
1769
1770         notmuch_message_destroy (message);
1771
1772         return NOTMUCH_STATUS_SUCCESS;
1773     }
1774
1775     /* Message has not been seen yet.
1776      *
1777      * We may have seen a reference to it already, in which case, we
1778      * can return the thread ID stored in the metadata. Otherwise, we
1779      * generate a new thread ID and store it there.
1780      */
1781     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
1782     metadata_key = _get_metadata_thread_id_key (ctx, message_id);
1783     thread_id_string = notmuch->xapian_db->get_metadata (metadata_key);
1784
1785     if (thread_id_string.empty()) {
1786         *thread_id_ret = talloc_strdup (ctx,
1787                                         _notmuch_database_generate_thread_id (notmuch));
1788         db->set_metadata (metadata_key, *thread_id_ret);
1789     } else {
1790         *thread_id_ret = talloc_strdup (ctx, thread_id_string.c_str());
1791     }
1792
1793     talloc_free (metadata_key);
1794
1795     return NOTMUCH_STATUS_SUCCESS;
1796 }
1797
1798 static notmuch_status_t
1799 _merge_threads (notmuch_database_t *notmuch,
1800                 const char *winner_thread_id,
1801                 const char *loser_thread_id)
1802 {
1803     Xapian::PostingIterator loser, loser_end;
1804     notmuch_message_t *message = NULL;
1805     notmuch_private_status_t private_status;
1806     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1807
1808     find_doc_ids (notmuch, "thread", loser_thread_id, &loser, &loser_end);
1809
1810     for ( ; loser != loser_end; loser++) {
1811         message = _notmuch_message_create (notmuch, notmuch,
1812                                            *loser, &private_status);
1813         if (message == NULL) {
1814             ret = COERCE_STATUS (private_status,
1815                                  "Cannot find document for doc_id from query");
1816             goto DONE;
1817         }
1818
1819         _notmuch_message_remove_term (message, "thread", loser_thread_id);
1820         _notmuch_message_add_term (message, "thread", winner_thread_id);
1821         _notmuch_message_sync (message);
1822
1823         notmuch_message_destroy (message);
1824         message = NULL;
1825     }
1826
1827   DONE:
1828     if (message)
1829         notmuch_message_destroy (message);
1830
1831     return ret;
1832 }
1833
1834 static void
1835 _my_talloc_free_for_g_hash (void *ptr)
1836 {
1837     talloc_free (ptr);
1838 }
1839
1840 static notmuch_status_t
1841 _notmuch_database_link_message_to_parents (notmuch_database_t *notmuch,
1842                                            notmuch_message_t *message,
1843                                            notmuch_message_file_t *message_file,
1844                                            const char **thread_id)
1845 {
1846     GHashTable *parents = NULL;
1847     const char *refs, *in_reply_to, *in_reply_to_message_id;
1848     const char *last_ref_message_id, *this_message_id;
1849     GList *l, *keys = NULL;
1850     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1851
1852     parents = g_hash_table_new_full (g_str_hash, g_str_equal,
1853                                      _my_talloc_free_for_g_hash, NULL);
1854     this_message_id = notmuch_message_get_message_id (message);
1855
1856     refs = _notmuch_message_file_get_header (message_file, "references");
1857     last_ref_message_id = parse_references (message,
1858                                             this_message_id,
1859                                             parents, refs);
1860
1861     in_reply_to = _notmuch_message_file_get_header (message_file, "in-reply-to");
1862     in_reply_to_message_id = parse_references (message,
1863                                                this_message_id,
1864                                                parents, in_reply_to);
1865
1866     /* For the parent of this message, use the last message ID of the
1867      * References header, if available.  If not, fall back to the
1868      * first message ID in the In-Reply-To header. */
1869     if (last_ref_message_id) {
1870         _notmuch_message_add_term (message, "replyto",
1871                                    last_ref_message_id);
1872     } else if (in_reply_to_message_id) {
1873         _notmuch_message_add_term (message, "replyto",
1874                              in_reply_to_message_id);
1875     }
1876
1877     keys = g_hash_table_get_keys (parents);
1878     for (l = keys; l; l = l->next) {
1879         char *parent_message_id;
1880         const char *parent_thread_id = NULL;
1881
1882         parent_message_id = (char *) l->data;
1883
1884         _notmuch_message_add_term (message, "reference",
1885                                    parent_message_id);
1886
1887         ret = _resolve_message_id_to_thread_id (notmuch,
1888                                                 message,
1889                                                 parent_message_id,
1890                                                 &parent_thread_id);
1891         if (ret)
1892             goto DONE;
1893
1894         if (*thread_id == NULL) {
1895             *thread_id = talloc_strdup (message, parent_thread_id);
1896             _notmuch_message_add_term (message, "thread", *thread_id);
1897         } else if (strcmp (*thread_id, parent_thread_id)) {
1898             ret = _merge_threads (notmuch, *thread_id, parent_thread_id);
1899             if (ret)
1900                 goto DONE;
1901         }
1902     }
1903
1904   DONE:
1905     if (keys)
1906         g_list_free (keys);
1907     if (parents)
1908         g_hash_table_unref (parents);
1909
1910     return ret;
1911 }
1912
1913 static notmuch_status_t
1914 _notmuch_database_link_message_to_children (notmuch_database_t *notmuch,
1915                                             notmuch_message_t *message,
1916                                             const char **thread_id)
1917 {
1918     const char *message_id = notmuch_message_get_message_id (message);
1919     Xapian::PostingIterator child, children_end;
1920     notmuch_message_t *child_message = NULL;
1921     const char *child_thread_id;
1922     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
1923     notmuch_private_status_t private_status;
1924
1925     find_doc_ids (notmuch, "reference", message_id, &child, &children_end);
1926
1927     for ( ; child != children_end; child++) {
1928
1929         child_message = _notmuch_message_create (message, notmuch,
1930                                                  *child, &private_status);
1931         if (child_message == NULL) {
1932             ret = COERCE_STATUS (private_status,
1933                                  "Cannot find document for doc_id from query");
1934             goto DONE;
1935         }
1936
1937         child_thread_id = notmuch_message_get_thread_id (child_message);
1938         if (*thread_id == NULL) {
1939             *thread_id = talloc_strdup (message, child_thread_id);
1940             _notmuch_message_add_term (message, "thread", *thread_id);
1941         } else if (strcmp (*thread_id, child_thread_id)) {
1942             _notmuch_message_remove_term (child_message, "reference",
1943                                           message_id);
1944             _notmuch_message_sync (child_message);
1945             ret = _merge_threads (notmuch, *thread_id, child_thread_id);
1946             if (ret)
1947                 goto DONE;
1948         }
1949
1950         notmuch_message_destroy (child_message);
1951         child_message = NULL;
1952     }
1953
1954   DONE:
1955     if (child_message)
1956         notmuch_message_destroy (child_message);
1957
1958     return ret;
1959 }
1960
1961 /* Fetch and clear the stored thread_id for message, or NULL if none. */
1962 static char *
1963 _consume_metadata_thread_id (void *ctx, notmuch_database_t *notmuch,
1964                              notmuch_message_t *message)
1965 {
1966     const char *message_id;
1967     string stored_id;
1968     char *metadata_key;
1969
1970     message_id = notmuch_message_get_message_id (message);
1971     metadata_key = _get_metadata_thread_id_key (ctx, message_id);
1972
1973     /* Check if we have already seen related messages to this one.
1974      * If we have then use the thread_id that we stored at that time.
1975      */
1976     stored_id = notmuch->xapian_db->get_metadata (metadata_key);
1977     if (stored_id.empty ()) {
1978         return NULL;
1979     } else {
1980         Xapian::WritableDatabase *db;
1981
1982         db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
1983
1984         /* Clear the metadata for this message ID. We don't need it
1985          * anymore. */
1986         db->set_metadata (metadata_key, "");
1987
1988         return talloc_strdup (ctx, stored_id.c_str ());
1989     }
1990 }
1991
1992 /* Given a (mostly empty) 'message' and its corresponding
1993  * 'message_file' link it to existing threads in the database.
1994  *
1995  * The first check is in the metadata of the database to see if we
1996  * have pre-allocated a thread_id in advance for this message, (which
1997  * would have happened if a message was previously added that
1998  * referenced this one).
1999  *
2000  * Second, we look at 'message_file' and its link-relevant headers
2001  * (References and In-Reply-To) for message IDs.
2002  *
2003  * Finally, we look in the database for existing message that
2004  * reference 'message'.
2005  *
2006  * In all cases, we assign to the current message the first thread_id
2007  * found (through either parent or child). We will also merge any
2008  * existing, distinct threads where this message belongs to both,
2009  * (which is not uncommon when messages are processed out of order).
2010  *
2011  * Finally, if no thread ID has been found through parent or child, we
2012  * call _notmuch_message_generate_thread_id to generate a new thread
2013  * ID. This should only happen for new, top-level messages, (no
2014  * References or In-Reply-To header in this message, and no previously
2015  * added message refers to this message).
2016  */
2017 static notmuch_status_t
2018 _notmuch_database_link_message (notmuch_database_t *notmuch,
2019                                 notmuch_message_t *message,
2020                                 notmuch_message_file_t *message_file)
2021 {
2022     void *local = talloc_new (NULL);
2023     notmuch_status_t status;
2024     const char *thread_id;
2025
2026     /* Check if the message already had a thread ID */
2027     thread_id = _consume_metadata_thread_id (local, notmuch, message);
2028     if (thread_id)
2029         _notmuch_message_add_term (message, "thread", thread_id);
2030
2031     status = _notmuch_database_link_message_to_parents (notmuch, message,
2032                                                         message_file,
2033                                                         &thread_id);
2034     if (status)
2035         goto DONE;
2036
2037     status = _notmuch_database_link_message_to_children (notmuch, message,
2038                                                          &thread_id);
2039     if (status)
2040         goto DONE;
2041
2042     /* If not part of any existing thread, generate a new thread ID. */
2043     if (thread_id == NULL) {
2044         thread_id = _notmuch_database_generate_thread_id (notmuch);
2045
2046         _notmuch_message_add_term (message, "thread", thread_id);
2047     }
2048
2049  DONE:
2050     talloc_free (local);
2051
2052     return status;
2053 }
2054
2055 notmuch_status_t
2056 notmuch_database_add_message (notmuch_database_t *notmuch,
2057                               const char *filename,
2058                               notmuch_message_t **message_ret)
2059 {
2060     notmuch_message_file_t *message_file;
2061     notmuch_message_t *message = NULL;
2062     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS, ret2;
2063     notmuch_private_status_t private_status;
2064
2065     const char *date, *header;
2066     const char *from, *to, *subject;
2067     char *message_id = NULL;
2068
2069     if (message_ret)
2070         *message_ret = NULL;
2071
2072     ret = _notmuch_database_ensure_writable (notmuch);
2073     if (ret)
2074         return ret;
2075
2076     message_file = _notmuch_message_file_open (filename);
2077     if (message_file == NULL)
2078         return NOTMUCH_STATUS_FILE_ERROR;
2079
2080     /* Adding a message may change many documents.  Do this all
2081      * atomically. */
2082     ret = notmuch_database_begin_atomic (notmuch);
2083     if (ret)
2084         goto DONE;
2085
2086     /* Parse message up front to get better error status. */
2087     ret = _notmuch_message_file_parse (message_file);
2088     if (ret)
2089         goto DONE;
2090
2091     try {
2092         /* Before we do any real work, (especially before doing a
2093          * potential SHA-1 computation on the entire file's contents),
2094          * let's make sure that what we're looking at looks like an
2095          * actual email message.
2096          */
2097         from = _notmuch_message_file_get_header (message_file, "from");
2098         subject = _notmuch_message_file_get_header (message_file, "subject");
2099         to = _notmuch_message_file_get_header (message_file, "to");
2100
2101         if ((from == NULL || *from == '\0') &&
2102             (subject == NULL || *subject == '\0') &&
2103             (to == NULL || *to == '\0'))
2104         {
2105             ret = NOTMUCH_STATUS_FILE_NOT_EMAIL;
2106             goto DONE;
2107         }
2108
2109         /* Now that we're sure it's mail, the first order of business
2110          * is to find a message ID (or else create one ourselves). */
2111
2112         header = _notmuch_message_file_get_header (message_file, "message-id");
2113         if (header && *header != '\0') {
2114             message_id = _parse_message_id (message_file, header, NULL);
2115
2116             /* So the header value isn't RFC-compliant, but it's
2117              * better than no message-id at all. */
2118             if (message_id == NULL)
2119                 message_id = talloc_strdup (message_file, header);
2120         }
2121
2122         if (message_id == NULL ) {
2123             /* No message-id at all, let's generate one by taking a
2124              * hash over the file's contents. */
2125             char *sha1 = _notmuch_sha1_of_file (filename);
2126
2127             /* If that failed too, something is really wrong. Give up. */
2128             if (sha1 == NULL) {
2129                 ret = NOTMUCH_STATUS_FILE_ERROR;
2130                 goto DONE;
2131             }
2132
2133             message_id = talloc_asprintf (message_file,
2134                                           "notmuch-sha1-%s", sha1);
2135             free (sha1);
2136         }
2137
2138         /* Now that we have a message ID, we get a message object,
2139          * (which may or may not reference an existing document in the
2140          * database). */
2141
2142         message = _notmuch_message_create_for_message_id (notmuch,
2143                                                           message_id,
2144                                                           &private_status);
2145
2146         talloc_free (message_id);
2147
2148         if (message == NULL) {
2149             ret = COERCE_STATUS (private_status,
2150                                  "Unexpected status value from _notmuch_message_create_for_message_id");
2151             goto DONE;
2152         }
2153
2154         _notmuch_message_add_filename (message, filename);
2155
2156         /* Is this a newly created message object? */
2157         if (private_status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) {
2158             _notmuch_message_add_term (message, "type", "mail");
2159
2160             ret = _notmuch_database_link_message (notmuch, message,
2161                                                   message_file);
2162             if (ret)
2163                 goto DONE;
2164
2165             date = _notmuch_message_file_get_header (message_file, "date");
2166             _notmuch_message_set_header_values (message, date, from, subject);
2167
2168             ret = _notmuch_message_index_file (message, message_file);
2169             if (ret)
2170                 goto DONE;
2171         } else {
2172             ret = NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID;
2173         }
2174
2175         _notmuch_message_sync (message);
2176     } catch (const Xapian::Error &error) {
2177         fprintf (stderr, "A Xapian exception occurred adding message: %s.\n",
2178                  error.get_msg().c_str());
2179         notmuch->exception_reported = TRUE;
2180         ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
2181         goto DONE;
2182     }
2183
2184   DONE:
2185     if (message) {
2186         if ((ret == NOTMUCH_STATUS_SUCCESS ||
2187              ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) && message_ret)
2188             *message_ret = message;
2189         else
2190             notmuch_message_destroy (message);
2191     }
2192
2193     if (message_file)
2194         _notmuch_message_file_close (message_file);
2195
2196     ret2 = notmuch_database_end_atomic (notmuch);
2197     if ((ret == NOTMUCH_STATUS_SUCCESS ||
2198          ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) &&
2199         ret2 != NOTMUCH_STATUS_SUCCESS)
2200         ret = ret2;
2201
2202     return ret;
2203 }
2204
2205 notmuch_status_t
2206 notmuch_database_remove_message (notmuch_database_t *notmuch,
2207                                  const char *filename)
2208 {
2209     notmuch_status_t status;
2210     notmuch_message_t *message;
2211
2212     status = notmuch_database_find_message_by_filename (notmuch, filename,
2213                                                         &message);
2214
2215     if (status == NOTMUCH_STATUS_SUCCESS && message) {
2216             status = _notmuch_message_remove_filename (message, filename);
2217             if (status == NOTMUCH_STATUS_SUCCESS)
2218                 _notmuch_message_delete (message);
2219             else if (status == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID)
2220                 _notmuch_message_sync (message);
2221
2222             notmuch_message_destroy (message);
2223     }
2224
2225     return status;
2226 }
2227
2228 notmuch_status_t
2229 notmuch_database_find_message_by_filename (notmuch_database_t *notmuch,
2230                                            const char *filename,
2231                                            notmuch_message_t **message_ret)
2232 {
2233     void *local;
2234     const char *prefix = _find_prefix ("file-direntry");
2235     char *direntry, *term;
2236     Xapian::PostingIterator i, end;
2237     notmuch_status_t status;
2238
2239     if (message_ret == NULL)
2240         return NOTMUCH_STATUS_NULL_POINTER;
2241
2242     if (! (notmuch->features & NOTMUCH_FEATURE_FILE_TERMS))
2243         return NOTMUCH_STATUS_UPGRADE_REQUIRED;
2244
2245     /* return NULL on any failure */
2246     *message_ret = NULL;
2247
2248     local = talloc_new (notmuch);
2249
2250     try {
2251         status = _notmuch_database_filename_to_direntry (
2252             local, notmuch, filename, NOTMUCH_FIND_LOOKUP, &direntry);
2253         if (status || !direntry)
2254             goto DONE;
2255
2256         term = talloc_asprintf (local, "%s%s", prefix, direntry);
2257
2258         find_doc_ids_for_term (notmuch, term, &i, &end);
2259
2260         if (i != end) {
2261             notmuch_private_status_t private_status;
2262
2263             *message_ret = _notmuch_message_create (notmuch, notmuch, *i,
2264                                                     &private_status);
2265             if (*message_ret == NULL)
2266                 status = NOTMUCH_STATUS_OUT_OF_MEMORY;
2267         }
2268     } catch (const Xapian::Error &error) {
2269         fprintf (stderr, "Error: A Xapian exception occurred finding message by filename: %s\n",
2270                  error.get_msg().c_str());
2271         notmuch->exception_reported = TRUE;
2272         status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
2273     }
2274
2275   DONE:
2276     talloc_free (local);
2277
2278     if (status && *message_ret) {
2279         notmuch_message_destroy (*message_ret);
2280         *message_ret = NULL;
2281     }
2282     return status;
2283 }
2284
2285 notmuch_string_list_t *
2286 _notmuch_database_get_terms_with_prefix (void *ctx, Xapian::TermIterator &i,
2287                                          Xapian::TermIterator &end,
2288                                          const char *prefix)
2289 {
2290     int prefix_len = strlen (prefix);
2291     notmuch_string_list_t *list;
2292
2293     list = _notmuch_string_list_create (ctx);
2294     if (unlikely (list == NULL))
2295         return NULL;
2296
2297     for (i.skip_to (prefix); i != end; i++) {
2298         /* Terminate loop at first term without desired prefix. */
2299         if (strncmp ((*i).c_str (), prefix, prefix_len))
2300             break;
2301
2302         _notmuch_string_list_append (list, (*i).c_str () + prefix_len);
2303     }
2304
2305     return list;
2306 }
2307
2308 notmuch_tags_t *
2309 notmuch_database_get_all_tags (notmuch_database_t *db)
2310 {
2311     Xapian::TermIterator i, end;
2312     notmuch_string_list_t *tags;
2313
2314     try {
2315         i = db->xapian_db->allterms_begin();
2316         end = db->xapian_db->allterms_end();
2317         tags = _notmuch_database_get_terms_with_prefix (db, i, end,
2318                                                         _find_prefix ("tag"));
2319         _notmuch_string_list_sort (tags);
2320         return _notmuch_tags_create (db, tags);
2321     } catch (const Xapian::Error &error) {
2322         fprintf (stderr, "A Xapian exception occurred getting tags: %s.\n",
2323                  error.get_msg().c_str());
2324         db->exception_reported = TRUE;
2325         return NULL;
2326     }
2327 }