X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=lib%2Fmessage.cc;h=fca99082a8483cba035fba37f9a1bc1ebaab0b4e;hp=a7e8c3cac4504dc9fec59611c7c0dcdf5539dbf2;hb=HEAD;hpb=9088db76d89264b733f6b45e776d8952da237921 diff --git a/lib/message.cc b/lib/message.cc index a7e8c3ca..46638f80 100644 --- a/lib/message.cc +++ b/lib/message.cc @@ -32,6 +32,7 @@ struct _notmuch_message { int frozen; char *message_id; char *thread_id; + size_t thread_depth; char *in_reply_to; notmuch_string_list_t *tag_list; notmuch_string_list_t *filename_term_list; @@ -41,6 +42,7 @@ struct _notmuch_message { notmuch_message_file_t *message_file; notmuch_string_list_t *property_term_list; notmuch_string_map_t *property_map; + notmuch_string_list_t *reference_list; notmuch_message_list_t *replies; unsigned long flags; /* For flags that are initialized on-demand, lazy_flags indicates @@ -66,11 +68,11 @@ struct maildir_flag_tag { }; /* ASCII ordered table of Maildir flags and associated tags */ -static struct maildir_flag_tag flag2tag[] = { - { 'D', "draft", false}, - { 'F', "flagged", false}, - { 'P', "passed", false}, - { 'R', "replied", false}, +static const struct maildir_flag_tag flag2tag[] = { + { 'D', "draft", false }, + { 'F', "flagged", false }, + { 'P', "passed", false }, + { 'R', "replied", false }, { 'S', "unread", true } }; @@ -88,6 +90,20 @@ _notmuch_message_destructor (notmuch_message_t *message) return 0; } +#define LOG_XAPIAN_EXCEPTION(message, error) _log_xapian_exception (__location__, message, error) + +static void +_log_xapian_exception (const char *where, notmuch_message_t *message, const Xapian::Error error) +{ + notmuch_database_t *notmuch = notmuch_message_get_database (message); + + _notmuch_database_log (notmuch, + "A Xapian exception occurred at %s: %s\n", + where, + error.get_msg ().c_str ()); + notmuch->exception_reported = true; +} + static notmuch_message_t * _notmuch_message_create_for_document (const void *talloc_owner, notmuch_database_t *notmuch, @@ -117,6 +133,9 @@ _notmuch_message_create_for_document (const void *talloc_owner, /* the message is initially not synchronized with Xapian */ message->last_view = 0; + /* Calculated after the thread structure is computed */ + message->thread_depth = 0; + /* Each of these will be lazily created as needed. */ message->message_id = NULL; message->thread_id = NULL; @@ -129,6 +148,7 @@ _notmuch_message_create_for_document (const void *talloc_owner, message->author = NULL; message->property_term_list = NULL; message->property_map = NULL; + message->reference_list = NULL; message->replies = _notmuch_message_list_create (message); if (unlikely (message->replies == NULL)) { @@ -149,6 +169,7 @@ _notmuch_message_create_for_document (const void *talloc_owner, message->doc = doc; message->termpos = 0; + message->modified = false; return message; } @@ -257,7 +278,7 @@ _notmuch_message_create_for_message_id (notmuch_database_t *notmuch, return NULL; } - if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY) + if (_notmuch_database_mode (notmuch) == NOTMUCH_DATABASE_MODE_READ_ONLY) INTERNAL_ERROR ("Failure to ensure database is writable."); try { @@ -268,8 +289,9 @@ _notmuch_message_create_for_message_id (notmuch_database_t *notmuch, doc_id = _notmuch_database_generate_doc_id (notmuch); } catch (const Xapian::Error &error) { - _notmuch_database_log(notmuch_message_get_database (message), "A Xapian exception occurred creating message: %s\n", - error.get_msg().c_str()); + _notmuch_database_log (notmuch, + "A Xapian exception occurred creating message: %s\n", + error.get_msg ().c_str ()); notmuch->exception_reported = true; *status_ret = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION; return NULL; @@ -300,10 +322,11 @@ _notmuch_message_get_term (notmuch_message_t *message, return NULL; const std::string &term = *i; - if (strncmp (term.c_str(), prefix, prefix_len)) + + if (strncmp (term.c_str (), prefix, prefix_len)) return NULL; - value = talloc_strdup (message, term.c_str() + prefix_len); + value = talloc_strdup (message, term.c_str () + prefix_len); #if DEBUG_DATABASE_SANITY i++; @@ -318,23 +341,6 @@ _notmuch_message_get_term (notmuch_message_t *message, return value; } -/* - * For special applications where we only want the thread id, reading - * in all metadata is a heavy I/O penalty. - */ -const char * -_notmuch_message_get_thread_id_only (notmuch_message_t *message) -{ - - Xapian::TermIterator i = message->doc.termlist_begin (); - Xapian::TermIterator end = message->doc.termlist_end (); - - message->thread_id = _notmuch_message_get_term (message, i, end, - _find_prefix ("thread")); - return message->thread_id; -} - - static void _notmuch_message_ensure_metadata (notmuch_message_t *message, void *field) { @@ -344,31 +350,32 @@ _notmuch_message_ensure_metadata (notmuch_message_t *message, void *field) return; const char *thread_prefix = _find_prefix ("thread"), - *tag_prefix = _find_prefix ("tag"), - *id_prefix = _find_prefix ("id"), - *type_prefix = _find_prefix ("type"), - *filename_prefix = _find_prefix ("file-direntry"), - *property_prefix = _find_prefix ("property"), - *replyto_prefix = _find_prefix ("replyto"); + *tag_prefix = _find_prefix ("tag"), + *id_prefix = _find_prefix ("id"), + *type_prefix = _find_prefix ("type"), + *filename_prefix = _find_prefix ("file-direntry"), + *property_prefix = _find_prefix ("property"), + *reference_prefix = _find_prefix ("reference"), + *replyto_prefix = _find_prefix ("replyto"); /* We do this all in a single pass because Xapian decompresses the * term list every time you iterate over it. Thus, while this is * slightly more costly than looking up individual fields if only * one field of the message object is actually used, it's a huge * win as more fields are used. */ - for (int count=0; count < 3; count++) { + for (int count = 0; count < 3; count++) { try { i = message->doc.termlist_begin (); end = message->doc.termlist_end (); /* Get thread */ - if (!message->thread_id) + if (! message->thread_id) message->thread_id = _notmuch_message_get_term (message, i, end, thread_prefix); /* Get tags */ assert (strcmp (thread_prefix, tag_prefix) < 0); - if (!message->tag_list) { + if (! message->tag_list) { message->tag_list = _notmuch_database_get_terms_with_prefix (message, i, end, tag_prefix); @@ -377,7 +384,7 @@ _notmuch_message_ensure_metadata (notmuch_message_t *message, void *field) /* Get id */ assert (strcmp (tag_prefix, id_prefix) < 0); - if (!message->message_id) + if (! message->message_id) message->message_id = _notmuch_message_get_term (message, i, end, id_prefix); @@ -400,7 +407,7 @@ _notmuch_message_ensure_metadata (notmuch_message_t *message, void *field) * expand them to full file names when needed in * _notmuch_message_ensure_filename_list. */ assert (strcmp (type_prefix, filename_prefix) < 0); - if (!message->filename_term_list && !message->filename_list) + if (! message->filename_term_list && ! message->filename_list) message->filename_term_list = _notmuch_database_get_terms_with_prefix (message, i, end, filename_prefix); @@ -408,33 +415,39 @@ _notmuch_message_ensure_metadata (notmuch_message_t *message, void *field) /* Get property terms. Mimic the setup with filenames above */ assert (strcmp (filename_prefix, property_prefix) < 0); - if (!message->property_map && !message->property_term_list) + if (! message->property_map && ! message->property_term_list) message->property_term_list = _notmuch_database_get_terms_with_prefix (message, i, end, - property_prefix); + property_prefix); + + /* get references */ + assert (strcmp (property_prefix, reference_prefix) < 0); + if (! message->reference_list) { + message->reference_list = + _notmuch_database_get_terms_with_prefix (message, i, end, + reference_prefix); + } /* Get reply to */ assert (strcmp (property_prefix, replyto_prefix) < 0); - if (!message->in_reply_to) + if (! message->in_reply_to) message->in_reply_to = _notmuch_message_get_term (message, i, end, replyto_prefix); /* It's perfectly valid for a message to have no In-Reply-To * header. For these cases, we return an empty string. */ - if (!message->in_reply_to) + if (! message->in_reply_to) message->in_reply_to = talloc_strdup (message, ""); /* all the way without an exception */ break; } catch (const Xapian::DatabaseModifiedError &error) { - notmuch_status_t status = _notmuch_database_reopen (message->notmuch); + notmuch_status_t status = notmuch_database_reopen (message->notmuch, + NOTMUCH_DATABASE_MODE_READ_ONLY); if (status != NOTMUCH_STATUS_SUCCESS) INTERNAL_ERROR ("unhandled error from notmuch_database_reopen: %s\n", notmuch_status_to_string (status)); - } catch (const Xapian::Error &error) { - INTERNAL_ERROR ("A Xapian exception occurred fetching message metadata: %s\n", - error.get_msg().c_str()); } } message->last_view = message->notmuch->view; @@ -492,8 +505,14 @@ _notmuch_message_get_doc_id (notmuch_message_t *message) const char * notmuch_message_get_message_id (notmuch_message_t *message) { - _notmuch_message_ensure_metadata (message, message->message_id); - if (!message->message_id) + try { + _notmuch_message_ensure_metadata (message, message->message_id); + } catch (const Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + return NULL; + } + + if (! message->message_id) INTERNAL_ERROR ("Message with document ID of %u has no message ID.\n", message->doc_id); return message->message_id; @@ -538,13 +557,11 @@ notmuch_message_get_header (notmuch_message_t *message, const char *header) * it could just mean we didn't record the header. */ if ((message->notmuch->features & NOTMUCH_FEATURE_FROM_SUBJECT_ID_VALUES) || - ! value.empty()) + ! value.empty ()) return talloc_strdup (message, value.c_str ()); } catch (Xapian::Error &error) { - _notmuch_database_log(notmuch_message_get_database (message), "A Xapian exception occurred when reading header: %s\n", - error.get_msg().c_str()); - message->notmuch->exception_reported = true; + LOG_XAPIAN_EXCEPTION (message, error); return NULL; } } @@ -574,8 +591,13 @@ _notmuch_message_get_in_reply_to (notmuch_message_t *message) const char * notmuch_message_get_thread_id (notmuch_message_t *message) { - _notmuch_message_ensure_metadata (message, message->thread_id); - if (!message->thread_id) + try { + _notmuch_message_ensure_metadata (message, message->thread_id); + } catch (Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + return NULL; + } + if (! message->thread_id) INTERNAL_ERROR ("Message with document ID of %u has no thread ID.\n", message->doc_id); return message->thread_id; @@ -588,6 +610,85 @@ _notmuch_message_add_reply (notmuch_message_t *message, _notmuch_message_list_add_message (message->replies, reply); } +size_t +_notmuch_message_get_thread_depth (notmuch_message_t *message) +{ + return message->thread_depth; +} + +void +_notmuch_message_label_depths (notmuch_message_t *message, + size_t depth) +{ + message->thread_depth = depth; + + for (notmuch_messages_t *messages = _notmuch_messages_create (message->replies); + notmuch_messages_valid (messages); + notmuch_messages_move_to_next (messages)) { + notmuch_message_t *child = notmuch_messages_get (messages); + _notmuch_message_label_depths (child, depth + 1); + } +} + +const notmuch_string_list_t * +_notmuch_message_get_references (notmuch_message_t *message) +{ + _notmuch_message_ensure_metadata (message, message->reference_list); + return message->reference_list; +} + +static int +_cmpmsg (const void *pa, const void *pb) +{ + notmuch_message_t **a = (notmuch_message_t **) pa; + notmuch_message_t **b = (notmuch_message_t **) pb; + time_t time_a = notmuch_message_get_date (*a); + time_t time_b = notmuch_message_get_date (*b); + + if (time_a == time_b) + return 0; + else if (time_a < time_b) + return -1; + else + return 1; +} + +notmuch_message_list_t * +_notmuch_message_sort_subtrees (void *ctx, notmuch_message_list_t *list) +{ + + size_t count = 0; + size_t capacity = 16; + + if (! list) + return list; + + void *local = talloc_new (NULL); + notmuch_message_list_t *new_list = _notmuch_message_list_create (ctx); + notmuch_message_t **message_array = talloc_zero_array (local, notmuch_message_t *, capacity); + + for (notmuch_messages_t *messages = _notmuch_messages_create (list); + notmuch_messages_valid (messages); + notmuch_messages_move_to_next (messages)) { + notmuch_message_t *root = notmuch_messages_get (messages); + if (count >= capacity) { + capacity *= 2; + message_array = talloc_realloc (local, message_array, notmuch_message_t *, capacity); + } + message_array[count++] = root; + root->replies = _notmuch_message_sort_subtrees (root, root->replies); + } + + qsort (message_array, count, sizeof (notmuch_message_t *), _cmpmsg); + for (size_t i = 0; i < count; i++) { + _notmuch_message_list_add_message (new_list, message_array[i]); + } + + talloc_free (local); + talloc_free (list); + return new_list; +} + notmuch_messages_t * notmuch_message_get_replies (notmuch_message_t *message) { @@ -618,12 +719,16 @@ _notmuch_message_remove_terms (notmuch_message_t *message, const char *prefix) /* Ignore failure to remove non-existent term. */ } } + + _notmuch_message_invalidate_metadata (message, "property"); } /* Remove all terms generated by indexing, i.e. not tags or * properties, along with any automatic tags*/ -notmuch_private_status_t +/* According to Xapian API docs, none of these calls throw + * exceptions */ +static notmuch_private_status_t _notmuch_message_remove_indexed_terms (notmuch_message_t *message) { Xapian::TermIterator i; @@ -634,53 +739,62 @@ _notmuch_message_remove_indexed_terms (notmuch_message_t *message) tag_prefix = _find_prefix ("tag"), type_prefix = _find_prefix ("type"); - for (i = message->doc.termlist_begin (); - i != message->doc.termlist_end (); i++) { - - const std::string term = *i; + /* Make sure we have the data to restore to Xapian*/ + _notmuch_message_ensure_metadata (message, NULL); - if (term.compare (0, type_prefix.size (), type_prefix) == 0) - continue; + /* Empirically, it turns out to be faster to remove all the terms, + * and add back the ones we want. */ + message->doc.clear_terms (); + message->modified = true; - if (term.compare (0, id_prefix.size (), id_prefix) == 0) - continue; + /* still a mail message */ + message->doc.add_term (type_prefix + "mail"); - if (term.compare (0, property_prefix.size (), property_prefix) == 0) - continue; + /* Put back message-id */ + message->doc.add_term (id_prefix + message->message_id); - if (term.compare (0, tag_prefix.size (), tag_prefix) == 0 && - term.compare (1, strlen("encrypted"), "encrypted") != 0 && - term.compare (1, strlen("signed"), "signed") != 0 && - term.compare (1, strlen("attachment"), "attachment") != 0) - continue; + /* Put back non-automatic tags */ + for (notmuch_tags_t *tags = notmuch_message_get_tags (message); + notmuch_tags_valid (tags); + notmuch_tags_move_to_next (tags)) { - try { - message->doc.remove_term ((*i)); - message->modified = true; - } catch (const Xapian::InvalidArgumentError) { - /* Ignore failure to remove non-existent term. */ - } catch (const Xapian::Error &error) { - notmuch_database_t *notmuch = message->notmuch; + const char *tag = notmuch_tags_get (tags); - if (!notmuch->exception_reported) { - _notmuch_database_log(notmuch_message_get_database (message), "A Xapian exception occurred creating message: %s\n", - error.get_msg().c_str()); - notmuch->exception_reported = true; - } - return NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION; + if (strcmp (tag, "encrypted") != 0 && + strcmp (tag, "signed") != 0 && + strcmp (tag, "attachment") != 0) { + std::string term = tag_prefix + tag; + message->doc.add_term (term); } } + + /* Put back properties */ + notmuch_message_properties_t *list; + + for (list = notmuch_message_get_properties (message, "", false); + notmuch_message_properties_valid (list); notmuch_message_properties_move_to_next (list)) { + std::string term = property_prefix + + notmuch_message_properties_key (list) + "=" + + notmuch_message_properties_value (list); + + message->doc.add_term (term); + } + + notmuch_message_properties_destroy (list); + return NOTMUCH_PRIVATE_STATUS_SUCCESS; } + /* Return true if p points at "new" or "cur". */ -static bool is_maildir (const char *p) +static bool +is_maildir (const char *p) { return strcmp (p, "cur") == 0 || strcmp (p, "new") == 0; } /* Add "folder:" term for directory. */ -static notmuch_status_t +NODISCARD static notmuch_status_t _notmuch_message_add_folder_terms (notmuch_message_t *message, const char *directory) { @@ -716,7 +830,10 @@ _notmuch_message_add_folder_terms (notmuch_message_t *message, *folder = '\0'; } - _notmuch_message_add_term (message, "folder", folder); + if (notmuch_status_t status = COERCE_STATUS (_notmuch_message_add_term (message, "folder", + folder), + "adding folder term")) + return status; talloc_free (folder); @@ -727,12 +844,17 @@ _notmuch_message_add_folder_terms (notmuch_message_t *message, #define RECURSIVE_SUFFIX "/**" /* Add "path:" terms for directory. */ -static notmuch_status_t +NODISCARD static notmuch_status_t _notmuch_message_add_path_terms (notmuch_message_t *message, const char *directory) { + notmuch_status_t status; + /* Add exact "path:" term. */ - _notmuch_message_add_term (message, "path", directory); + status = COERCE_STATUS (_notmuch_message_add_term (message, "path", directory), + "adding path term"); + if (status) + return status; if (strlen (directory)) { char *path, *p; @@ -745,7 +867,10 @@ _notmuch_message_add_path_terms (notmuch_message_t *message, for (p = path + strlen (path) - 1; p > path; p--) { if (*p == '/') { strcpy (p, RECURSIVE_SUFFIX); - _notmuch_message_add_term (message, "path", path); + status = COERCE_STATUS (_notmuch_message_add_term (message, "path", path), + "adding path term"); + if (status) + return status; } } @@ -753,7 +878,10 @@ _notmuch_message_add_path_terms (notmuch_message_t *message, } /* Recursive all-matching path:** for consistency. */ - _notmuch_message_add_term (message, "path", "**"); + status = COERCE_STATUS (_notmuch_message_add_term (message, "path", "**"), + "adding path term"); + if (status) + return status; return NOTMUCH_STATUS_SUCCESS; } @@ -772,6 +900,7 @@ _notmuch_message_add_directory_terms (void *ctx, notmuch_message_t *message) const char *direntry, *directory; char *colon; const std::string &term = *i; + notmuch_status_t term_status; /* Terminate loop at first term without desired prefix. */ if (strncmp (term.c_str (), direntry_prefix, direntry_prefix_len)) @@ -792,8 +921,13 @@ _notmuch_message_add_directory_terms (void *ctx, notmuch_message_t *message) message->notmuch, directory_id); - _notmuch_message_add_folder_terms (message, directory); - _notmuch_message_add_path_terms (message, directory); + term_status = _notmuch_message_add_folder_terms (message, directory); + if (term_status) + return term_status; + + term_status = _notmuch_message_add_path_terms (message, directory); + if (term_status) + return term_status; } return status; @@ -809,6 +943,7 @@ _notmuch_message_add_filename (notmuch_message_t *message, { const char *relative, *directory; notmuch_status_t status; + notmuch_private_status_t private_status; void *local = talloc_new (message); char *direntry; @@ -832,10 +967,25 @@ _notmuch_message_add_filename (notmuch_message_t *message, /* New file-direntry allows navigating to this message with * notmuch_directory_get_child_files() . */ - _notmuch_message_add_term (message, "file-direntry", direntry); + private_status = _notmuch_message_add_term (message, "file-direntry", direntry); + switch (private_status) { + case NOTMUCH_PRIVATE_STATUS_SUCCESS: + break; + case NOTMUCH_PRIVATE_STATUS_TERM_TOO_LONG: + _notmuch_database_log (message->notmuch, "filename too long for file-direntry term: %s\n", + filename); + return NOTMUCH_STATUS_PATH_ERROR; + default: + return COERCE_STATUS (private_status, "adding file-direntry term"); + } + + status = _notmuch_message_add_folder_terms (message, directory); + if (status) + return status; - _notmuch_message_add_folder_terms (message, directory); - _notmuch_message_add_path_terms (message, directory); + status = _notmuch_message_add_path_terms (message, directory); + if (status) + return status; talloc_free (local); @@ -869,7 +1019,7 @@ _notmuch_message_remove_filename (notmuch_message_t *message, status = _notmuch_database_filename_to_direntry ( local, message->notmuch, filename, NOTMUCH_FIND_LOOKUP, &direntry); - if (status || !direntry) + if (status || ! direntry) return status; /* Unlink this file from its parent directory. */ @@ -938,7 +1088,7 @@ _notmuch_message_ensure_filename_list (notmuch_message_t *message) message->filename_list = _notmuch_string_list_create (message); node = message->filename_term_list->head; - if (!node) { + if (! node) { /* A message document created by an old version of notmuch * (prior to rename support) will have the filename in the * data of the document rather than as a file-direntry term. @@ -974,7 +1124,7 @@ _notmuch_message_ensure_filename_list (notmuch_message_t *message) *colon = '\0'; - db_path = notmuch_database_get_path (message->notmuch); + db_path = notmuch_config_get (message->notmuch, NOTMUCH_CONFIG_MAIL_ROOT); directory = _notmuch_database_get_directory_path (local, message->notmuch, @@ -999,14 +1149,18 @@ _notmuch_message_ensure_filename_list (notmuch_message_t *message) const char * notmuch_message_get_filename (notmuch_message_t *message) { - _notmuch_message_ensure_filename_list (message); + try { + _notmuch_message_ensure_filename_list (message); + } catch (Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + return NULL; + } if (message->filename_list == NULL) return NULL; if (message->filename_list->head == NULL || - message->filename_list->head->string == NULL) - { + message->filename_list->head->string == NULL) { INTERNAL_ERROR ("message with no filename"); } @@ -1016,7 +1170,12 @@ notmuch_message_get_filename (notmuch_message_t *message) notmuch_filenames_t * notmuch_message_get_filenames (notmuch_message_t *message) { - _notmuch_message_ensure_filename_list (message); + try { + _notmuch_message_ensure_filename_list (message); + } catch (Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + return NULL; + } return _notmuch_filenames_create (message, message->filename_list); } @@ -1024,20 +1183,50 @@ notmuch_message_get_filenames (notmuch_message_t *message) int notmuch_message_count_files (notmuch_message_t *message) { - _notmuch_message_ensure_filename_list (message); + try { + _notmuch_message_ensure_filename_list (message); + } catch (Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + return -1; + } return _notmuch_string_list_length (message->filename_list); } +notmuch_status_t +notmuch_message_get_flag_st (notmuch_message_t *message, + notmuch_message_flag_t flag, + notmuch_bool_t *is_set) +{ + if (! is_set) + return NOTMUCH_STATUS_NULL_POINTER; + + try { + if (flag == NOTMUCH_MESSAGE_FLAG_GHOST && + ! NOTMUCH_TEST_BIT (message->lazy_flags, flag)) + _notmuch_message_ensure_metadata (message, NULL); + } catch (Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + return NOTMUCH_STATUS_XAPIAN_EXCEPTION; + } + + *is_set = NOTMUCH_TEST_BIT (message->flags, flag); + return NOTMUCH_STATUS_SUCCESS; +} + notmuch_bool_t notmuch_message_get_flag (notmuch_message_t *message, notmuch_message_flag_t flag) { - if (flag == NOTMUCH_MESSAGE_FLAG_GHOST && - ! NOTMUCH_TEST_BIT (message->lazy_flags, flag)) - _notmuch_message_ensure_metadata (message, NULL); + notmuch_bool_t is_set; + notmuch_status_t status; + + status = notmuch_message_get_flag_st (message, flag, &is_set); - return NOTMUCH_TEST_BIT (message->flags, flag); + if (status) + return FALSE; + else + return is_set; } void @@ -1059,9 +1248,7 @@ notmuch_message_get_date (notmuch_message_t *message) try { value = message->doc.get_value (NOTMUCH_VALUE_TIMESTAMP); } catch (Xapian::Error &error) { - _notmuch_database_log(notmuch_message_get_database (message), "A Xapian exception occurred when reading date: %s\n", - error.get_msg().c_str()); - message->notmuch->exception_reported = true; + LOG_XAPIAN_EXCEPTION (message, error); return 0; } @@ -1076,7 +1263,12 @@ notmuch_message_get_tags (notmuch_message_t *message) { notmuch_tags_t *tags; - _notmuch_message_ensure_metadata (message, message->tag_list); + try { + _notmuch_message_ensure_metadata (message, message->tag_list); + } catch (Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + return NULL; + } tags = _notmuch_tags_create (message, message->tag_list); /* _notmuch_tags_create steals the reference to the tag_list, but @@ -1085,7 +1277,7 @@ notmuch_message_get_tags (notmuch_message_t *message) * possible to modify the message tags (which talloc_unlink's the * current list from the message) while still iterating because * the iterator will keep the current list alive. */ - if (!talloc_reference (message, message->tag_list)) + if (! talloc_reference (message, message->tag_list)) return NULL; return tags; @@ -1099,11 +1291,11 @@ _notmuch_message_get_author (notmuch_message_t *message) void _notmuch_message_set_author (notmuch_message_t *message, - const char *author) + const char *author) { if (message->author) - talloc_free(message->author); - message->author = talloc_strdup(message, author); + talloc_free (message->author); + message->author = talloc_strdup (message, author); return; } @@ -1135,6 +1327,14 @@ _notmuch_message_set_header_values (notmuch_message_t *message, message->modified = true; } +void +_notmuch_message_update_subject (notmuch_message_t *message, + const char *subject) +{ + message->doc.add_value (NOTMUCH_VALUE_SUBJECT, subject); + message->modified = true; +} + /* Upgrade a message to support NOTMUCH_FEATURE_LAST_MOD. The caller * must call _notmuch_message_sync. */ void @@ -1149,9 +1349,7 @@ _notmuch_message_upgrade_last_mod (notmuch_message_t *message) void _notmuch_message_sync (notmuch_message_t *message) { - Xapian::WritableDatabase *db; - - if (message->notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY) + if (_notmuch_database_mode (message->notmuch) == NOTMUCH_DATABASE_MODE_READ_ONLY) return; if (! message->modified) @@ -1169,8 +1367,8 @@ _notmuch_message_sync (notmuch_message_t *message) _notmuch_database_new_revision ( message->notmuch))); - db = static_cast (message->notmuch->xapian_db); - db->replace_document (message->doc_id, message->doc); + message->notmuch->writable_xapian_db-> + replace_document (message->doc_id, message->doc); message->modified = false; } @@ -1180,12 +1378,10 @@ notmuch_status_t _notmuch_message_delete (notmuch_message_t *message) { notmuch_status_t status; - Xapian::WritableDatabase *db; - const char *mid, *tid, *query_string; + const char *mid, *tid; notmuch_message_t *ghost; notmuch_private_status_t private_status; notmuch_database_t *notmuch; - notmuch_query_t *query; unsigned int count = 0; bool is_ghost; @@ -1197,27 +1393,44 @@ _notmuch_message_delete (notmuch_message_t *message) if (status) return status; - db = static_cast (notmuch->xapian_db); - db->delete_document (message->doc_id); - - /* if this was a ghost to begin with, we are done */ - private_status = _notmuch_message_has_term (message, "type", "ghost", &is_ghost); - if (private_status) - return COERCE_STATUS (private_status, - "Error trying to determine whether message was a ghost"); - if (is_ghost) - return NOTMUCH_STATUS_SUCCESS; - - query_string = talloc_asprintf (message, "thread:%s", tid); - query = notmuch_query_create (notmuch, query_string); - if (query == NULL) - return NOTMUCH_STATUS_OUT_OF_MEMORY; - status = notmuch_query_count_messages (query, &count); - if (status) { - notmuch_query_destroy (query); - return status; + try { + Xapian::PostingIterator thread_doc, thread_doc_end; + Xapian::PostingIterator mail_doc, mail_doc_end; + + /* look for a non-ghost message in the same thread */ + /* if this was a ghost to begin with, we are done */ + private_status = _notmuch_message_has_term (message, "type", "ghost", &is_ghost); + if (private_status) + return COERCE_STATUS (private_status, + "Error trying to determine whether message was a ghost"); + + message->notmuch->writable_xapian_db->delete_document (message->doc_id); + + if (is_ghost) + return NOTMUCH_STATUS_SUCCESS; + + _notmuch_database_find_doc_ids (message->notmuch, "thread", tid, &thread_doc, + &thread_doc_end); + _notmuch_database_find_doc_ids (message->notmuch, "type", "mail", &mail_doc, &mail_doc_end); + + while (count == 0 && + thread_doc != thread_doc_end && + mail_doc != mail_doc_end) { + thread_doc.skip_to (*mail_doc); + if (thread_doc != thread_doc_end) { + if (*thread_doc == *mail_doc) { + count++; + } else { + mail_doc.skip_to (*thread_doc); + if (mail_doc != mail_doc_end && *thread_doc == *mail_doc) + count++; + } + } + } + } catch (Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + return NOTMUCH_STATUS_XAPIAN_EXCEPTION; } - if (count > 0) { /* reintroduce a ghost in its place because there are still * other active messages in this thread: */ @@ -1228,35 +1441,29 @@ _notmuch_message_delete (notmuch_message_t *message) _notmuch_message_sync (ghost); } else if (private_status == NOTMUCH_PRIVATE_STATUS_SUCCESS) { /* this is deeply weird, and we should not have gotten - into this state. is there a better error message to - return here? */ + * into this state. is there a better error message to + * return here? */ status = NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID; } notmuch_message_destroy (ghost); status = COERCE_STATUS (private_status, "Error converting to ghost message"); } else { - /* the thread is empty; drop all ghost messages from it */ - notmuch_messages_t *messages; - status = _notmuch_query_search_documents (query, - "ghost", - &messages); - if (status == NOTMUCH_STATUS_SUCCESS) { - notmuch_status_t last_error = NOTMUCH_STATUS_SUCCESS; - while (notmuch_messages_valid (messages)) { - message = notmuch_messages_get (messages); - status = _notmuch_message_delete (message); - if (status) /* we'll report the last failure we see; - * if there is more than one failure, we - * forget about previous ones */ - last_error = status; - notmuch_message_destroy (message); - notmuch_messages_move_to_next (messages); + /* the thread now contains only ghosts: delete them */ + try { + Xapian::PostingIterator doc, doc_end; + + _notmuch_database_find_doc_ids (message->notmuch, "thread", tid, &doc, &doc_end); + + for (; doc != doc_end; doc++) { + message->notmuch->writable_xapian_db->delete_document (*doc); } - status = last_error; + } catch (Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + return NOTMUCH_STATUS_XAPIAN_EXCEPTION; } + } - notmuch_query_destroy (query); return status; } @@ -1298,36 +1505,43 @@ _notmuch_message_close (notmuch_message_t *message) * * This change will not be reflected in the database until the next * call to _notmuch_message_sync. */ -notmuch_private_status_t +NODISCARD notmuch_private_status_t _notmuch_message_add_term (notmuch_message_t *message, const char *prefix_name, const char *value) { char *term; + notmuch_private_status_t status = NOTMUCH_PRIVATE_STATUS_SUCCESS; if (value == NULL) return NOTMUCH_PRIVATE_STATUS_NULL_POINTER; term = talloc_asprintf (message, "%s%s", _find_prefix (prefix_name), value); + if (strlen (term) > NOTMUCH_TERM_MAX) { + status = NOTMUCH_PRIVATE_STATUS_TERM_TOO_LONG; + goto DONE; + } - if (strlen (term) > NOTMUCH_TERM_MAX) - return NOTMUCH_PRIVATE_STATUS_TERM_TOO_LONG; - - message->doc.add_term (term, 0); - message->modified = true; + try { + message->doc.add_term (term, 0); + message->modified = true; + _notmuch_message_invalidate_metadata (message, prefix_name); + } catch (Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + status = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION; + } + DONE: talloc_free (term); - - _notmuch_message_invalidate_metadata (message, prefix_name); - - return NOTMUCH_PRIVATE_STATUS_SUCCESS; + return status; } /* Parse 'text' and add a term to 'message' for each parsed word. Each - * term will be added both prefixed (if prefix_name is not NULL) and - * also non-prefixed). */ + * term will be added with the appropriate prefix if prefix_name is + * non-NULL. + */ notmuch_private_status_t _notmuch_message_gen_terms (notmuch_message_t *message, const char *prefix_name, @@ -1339,22 +1553,21 @@ _notmuch_message_gen_terms (notmuch_message_t *message, return NOTMUCH_PRIVATE_STATUS_NULL_POINTER; term_gen->set_document (message->doc); + term_gen->set_termpos (message->termpos); if (prefix_name) { - const char *prefix = _find_prefix (prefix_name); - - term_gen->set_termpos (message->termpos); - term_gen->index_text (text, 1, prefix); - /* Create a gap between this an the next terms so they don't - * appear to be a phrase. */ - message->termpos = term_gen->get_termpos () + 100; + const char *prefix = _notmuch_database_prefix (message->notmuch, prefix_name); + if (prefix == NULL) + return NOTMUCH_PRIVATE_STATUS_BAD_PREFIX; _notmuch_message_invalidate_metadata (message, prefix_name); + term_gen->index_text (text, 1, prefix); + } else { + term_gen->index_text (text); } - term_gen->set_termpos (message->termpos); - term_gen->index_text (text); - /* Create a term gap, as above. */ + /* Create a gap between this an the next terms so they don't + * appear to be a phrase. */ message->termpos = term_gen->get_termpos () + 100; return NOTMUCH_PRIVATE_STATUS_SUCCESS; @@ -1367,7 +1580,7 @@ _notmuch_message_gen_terms (notmuch_message_t *message, * * This change will not be reflected in the database until the next * call to _notmuch_message_sync. */ -notmuch_private_status_t +NODISCARD notmuch_private_status_t _notmuch_message_remove_term (notmuch_message_t *message, const char *prefix_name, const char *value) @@ -1386,11 +1599,12 @@ _notmuch_message_remove_term (notmuch_message_t *message, try { message->doc.remove_term (term); message->modified = true; - } catch (const Xapian::InvalidArgumentError) { + } catch (const Xapian::InvalidArgumentError &error) { /* We'll let the philosophers try to wrestle with the * question of whether failing to remove that which was not * there in the first place is failure. For us, we'll silently * consider it all good. */ + LOG_XAPIAN_EXCEPTION (message, error); } talloc_free (term); @@ -1424,7 +1638,7 @@ _notmuch_message_has_term (notmuch_message_t *message, Xapian::TermIterator i = message->doc.termlist_begin (); i.skip_to (term); if (i != message->doc.termlist_end () && - !strcmp ((*i).c_str (), term)) + ! strcmp ((*i).c_str (), term)) out = true; } catch (Xapian::Error &error) { status = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION; @@ -1441,24 +1655,31 @@ notmuch_message_add_tag (notmuch_message_t *message, const char *tag) notmuch_private_status_t private_status; notmuch_status_t status; - status = _notmuch_database_ensure_writable (message->notmuch); - if (status) - return status; + try { + status = _notmuch_database_ensure_writable (message->notmuch); + if (status) + return status; - if (tag == NULL) - return NOTMUCH_STATUS_NULL_POINTER; + if (tag == NULL) + return NOTMUCH_STATUS_NULL_POINTER; - if (strlen (tag) > NOTMUCH_TAG_MAX) - return NOTMUCH_STATUS_TAG_TOO_LONG; + if (strlen (tag) > NOTMUCH_TAG_MAX) + return NOTMUCH_STATUS_TAG_TOO_LONG; - private_status = _notmuch_message_add_term (message, "tag", tag); - if (private_status) { - INTERNAL_ERROR ("_notmuch_message_add_term return unexpected value: %d\n", - private_status); - } + private_status = _notmuch_message_add_term (message, "tag", tag); + if (private_status) { + return COERCE_STATUS (private_status, + "_notmuch_message_remove_term return unexpected value: %d\n", + private_status); + } - if (! message->frozen) - _notmuch_message_sync (message); + if (! message->frozen) + _notmuch_message_sync (message); + + } catch (Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + return NOTMUCH_STATUS_XAPIAN_EXCEPTION; + } return NOTMUCH_STATUS_SUCCESS; } @@ -1469,24 +1690,30 @@ notmuch_message_remove_tag (notmuch_message_t *message, const char *tag) notmuch_private_status_t private_status; notmuch_status_t status; - status = _notmuch_database_ensure_writable (message->notmuch); - if (status) - return status; + try { + status = _notmuch_database_ensure_writable (message->notmuch); + if (status) + return status; - if (tag == NULL) - return NOTMUCH_STATUS_NULL_POINTER; + if (tag == NULL) + return NOTMUCH_STATUS_NULL_POINTER; - if (strlen (tag) > NOTMUCH_TAG_MAX) - return NOTMUCH_STATUS_TAG_TOO_LONG; + if (strlen (tag) > NOTMUCH_TAG_MAX) + return NOTMUCH_STATUS_TAG_TOO_LONG; - private_status = _notmuch_message_remove_term (message, "tag", tag); - if (private_status) { - INTERNAL_ERROR ("_notmuch_message_remove_term return unexpected value: %d\n", - private_status); - } + private_status = _notmuch_message_remove_term (message, "tag", tag); + if (private_status) { + return COERCE_STATUS (private_status, + "_notmuch_message_remove_term return unexpected value: %d\n", + private_status); + } - if (! message->frozen) - _notmuch_message_sync (message); + if (! message->frozen) + _notmuch_message_sync (message); + } catch (Xapian::Error &error) { + LOG_XAPIAN_EXCEPTION (message, error); + return NOTMUCH_STATUS_XAPIAN_EXCEPTION; + } return NOTMUCH_STATUS_SUCCESS; } @@ -1524,15 +1751,14 @@ _filename_is_in_maildir (const char *filename) dir = slash + 1; if (STRNCMP_LITERAL (dir, "cur/") == 0 || - STRNCMP_LITERAL (dir, "new/") == 0) - { + STRNCMP_LITERAL (dir, "new/") == 0) { return dir; } return NULL; } -static void +static notmuch_status_t _ensure_maildir_flags (notmuch_message_t *message, bool force) { const char *flags; @@ -1547,11 +1773,12 @@ _ensure_maildir_flags (notmuch_message_t *message, bool force) message->maildir_flags = NULL; } } - - for (filenames = notmuch_message_get_filenames (message); + filenames = notmuch_message_get_filenames (message); + if (! filenames) + return NOTMUCH_STATUS_XAPIAN_EXCEPTION; + for (; notmuch_filenames_valid (filenames); - notmuch_filenames_move_to_next (filenames)) - { + notmuch_filenames_move_to_next (filenames)) { filename = notmuch_filenames_get (filenames); dir = _filename_is_in_maildir (filename); @@ -1575,13 +1802,38 @@ _ensure_maildir_flags (notmuch_message_t *message, bool force) } if (seen_maildir_info) message->maildir_flags = combined_flags; + return NOTMUCH_STATUS_SUCCESS; } notmuch_bool_t notmuch_message_has_maildir_flag (notmuch_message_t *message, char flag) { - _ensure_maildir_flags (message, false); - return message->maildir_flags && (strchr (message->maildir_flags, flag) != NULL); + notmuch_status_t status; + notmuch_bool_t ret; + + status = notmuch_message_has_maildir_flag_st (message, flag, &ret); + if (status) + return FALSE; + + return ret; +} + +notmuch_status_t +notmuch_message_has_maildir_flag_st (notmuch_message_t *message, + char flag, + notmuch_bool_t *is_set) +{ + notmuch_status_t status; + + if (! is_set) + return NOTMUCH_STATUS_NULL_POINTER; + + status = _ensure_maildir_flags (message, false); + if (status) + return status; + + *is_set = message->maildir_flags && (strchr (message->maildir_flags, flag) != NULL); + return NOTMUCH_STATUS_SUCCESS; } notmuch_status_t @@ -1590,7 +1842,9 @@ notmuch_message_maildir_flags_to_tags (notmuch_message_t *message) notmuch_status_t status; unsigned i; - _ensure_maildir_flags (message, true); + status = _ensure_maildir_flags (message, true); + if (status) + return status; /* If none of the filenames have any maildir info field (not even * an empty info with no flags set) then there's no information to * go on, so do nothing. */ @@ -1601,11 +1855,10 @@ notmuch_message_maildir_flags_to_tags (notmuch_message_t *message) if (status) return status; - for (i = 0; i < ARRAY_SIZE(flag2tag); i++) { + for (i = 0; i < ARRAY_SIZE (flag2tag); i++) { if ((strchr (message->maildir_flags, flag2tag[i].flag) != NULL) ^ - flag2tag[i].inverse) - { + flag2tag[i].inverse) { status = notmuch_message_add_tag (message, flag2tag[i].tag); } else { status = notmuch_message_remove_tag (message, flag2tag[i].tag); @@ -1640,8 +1893,7 @@ _get_maildir_flag_actions (notmuch_message_t *message, /* First, find flags for all set tags. */ for (tags = notmuch_message_get_tags (message); notmuch_tags_valid (tags); - notmuch_tags_move_to_next (tags)) - { + notmuch_tags_move_to_next (tags)) { tag = notmuch_tags_get (tags); for (i = 0; i < ARRAY_SIZE (flag2tag); i++) { @@ -1691,7 +1943,7 @@ _get_maildir_flag_actions (notmuch_message_t *message, * non-ASCII ordering of flags), this function will return NULL * (meaning that renaming would not be safe and should not occur). */ -static char* +static char * _new_maildir_filename (void *ctx, const char *filename, const char *flags_to_set, @@ -1711,13 +1963,12 @@ _new_maildir_filename (void *ctx, info = strstr (filename, ":2,"); if (info == NULL) { - info = filename + strlen(filename); + info = filename + strlen (filename); } else { /* Loop through existing flags in filename. */ for (flags = info + 3, last_flag = 0; *flags; - last_flag = flag, flags++) - { + last_flag = flag, flags++) { flag = *flags; /* Original flags not in ASCII order. Abort. */ @@ -1725,7 +1976,7 @@ _new_maildir_filename (void *ctx, return NULL; /* Non-ASCII flag. Abort. */ - if (flag > sizeof(flag_map) - 1) + if (flag > sizeof (flag_map) - 1) return NULL; /* Repeated flag value. Abort. */ @@ -1759,7 +2010,7 @@ _new_maildir_filename (void *ctx, /* Messages in new/ without maildir info can be kept in new/ if no * flags have changed. */ dir = (char *) _filename_is_in_maildir (filename); - if (dir && STRNCMP_LITERAL (dir, "new/") == 0 && !*info && !flags_changed) + if (dir && STRNCMP_LITERAL (dir, "new/") == 0 && ! *info && ! flags_changed) return talloc_strdup (ctx, filename); filename_new = (char *) talloc_size (ctx, @@ -1774,8 +2025,7 @@ _new_maildir_filename (void *ctx, strcat (filename_new, ":2,"); s = filename_new + strlen (filename_new); - for (i = 0; i < sizeof (flag_map); i++) - { + for (i = 0; i < sizeof (flag_map); i++) { if (flag_map[i]) { *s = i; s++; @@ -1800,12 +2050,15 @@ notmuch_message_tags_to_maildir_flags (notmuch_message_t *message) char *to_set, *to_clear; notmuch_status_t status = NOTMUCH_STATUS_SUCCESS; + status = _notmuch_database_ensure_writable (message->notmuch); + if (status) + return status; + _get_maildir_flag_actions (message, &to_set, &to_clear); for (filenames = notmuch_message_get_filenames (message); notmuch_filenames_valid (filenames); - notmuch_filenames_move_to_next (filenames)) - { + notmuch_filenames_move_to_next (filenames)) { filename = notmuch_filenames_get (filenames); if (! _filename_is_in_maildir (filename)) @@ -1864,17 +2117,20 @@ notmuch_message_remove_all_tags (notmuch_message_t *message) status = _notmuch_database_ensure_writable (message->notmuch); if (status) return status; + tags = notmuch_message_get_tags (message); + if (! tags) + return NOTMUCH_STATUS_XAPIAN_EXCEPTION; - for (tags = notmuch_message_get_tags (message); + for (; notmuch_tags_valid (tags); - notmuch_tags_move_to_next (tags)) - { + notmuch_tags_move_to_next (tags)) { tag = notmuch_tags_get (tags); private_status = _notmuch_message_remove_term (message, "tag", tag); if (private_status) { - INTERNAL_ERROR ("_notmuch_message_remove_term return unexpected value: %d\n", - private_status); + return COERCE_STATUS (private_status, + "_notmuch_message_remove_term return unexpected value: %d\n", + private_status); } } @@ -1925,7 +2181,7 @@ notmuch_message_destroy (notmuch_message_t *message) } notmuch_database_t * -notmuch_message_get_database (notmuch_message_t *message) +notmuch_message_get_database (const notmuch_message_t *message) { return message->notmuch; } @@ -1946,8 +2202,8 @@ _notmuch_message_ensure_property_map (notmuch_message_t *message) const char *key; char *value; - value = strchr(node->string, '='); - if (!value) + value = strchr (node->string, '='); + if (! value) INTERNAL_ERROR ("malformed property term"); *value = '\0'; @@ -1994,9 +2250,11 @@ notmuch_message_reindex (notmuch_message_t *message, /* Save in case we need to delete message */ orig_thread_id = notmuch_message_get_thread_id (message); - if (!orig_thread_id) { - /* XXX TODO: make up new error return? */ - INTERNAL_ERROR ("message without thread-id"); + if (! orig_thread_id) { + /* the following is correct as long as there is only one reason + * n_m_get_thread_id returns NULL + */ + return NOTMUCH_STATUS_XAPIAN_EXCEPTION; } /* strdup it because the metadata may be invalidated */ @@ -2012,7 +2270,7 @@ notmuch_message_reindex (notmuch_message_t *message, private_status = _notmuch_message_remove_indexed_terms (message); if (private_status) { - ret = COERCE_STATUS(private_status, "error removing terms"); + ret = COERCE_STATUS (private_status, "error removing terms"); goto DONE; } @@ -2059,7 +2317,11 @@ notmuch_message_reindex (notmuch_message_t *message, if (thread_id == NULL) thread_id = orig_thread_id; - _notmuch_message_add_term (message, "thread", thread_id); + ret = COERCE_STATUS (_notmuch_message_add_term (message, "thread", thread_id), + "adding thread term"); + if (ret) + goto DONE; + /* Take header values only from first filename */ if (found == 0) _notmuch_message_set_header_values (message, date, from, subject); @@ -2077,13 +2339,17 @@ notmuch_message_reindex (notmuch_message_t *message, } if (found == 0) { /* put back thread id to help cleanup */ - _notmuch_message_add_term (message, "thread", orig_thread_id); + ret = COERCE_STATUS (_notmuch_message_add_term (message, "thread", orig_thread_id), + "adding thread term"); + if (ret) + goto DONE; + ret = _notmuch_message_delete (message); } else { _notmuch_message_sync (message); } - DONE: + DONE: if (message_file) _notmuch_message_file_close (message_file);