X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=message.cc;h=154efa0fd47ebde90460ed1516256715b902f723;hp=b66ca7e2dc3cd7fdeb8a317084f360bd963dc34d;hb=d4c4318fb95ba2ed86823389cf82b11a2bcae073;hpb=3b8e3ab666a54407f9596a53c66ba8ce623ac91d diff --git a/message.cc b/message.cc index b66ca7e2..154efa0f 100644 --- a/message.cc +++ b/message.cc @@ -21,30 +21,21 @@ #include "notmuch-private.h" #include "database-private.h" +#include + #include struct _notmuch_message { notmuch_database_t *notmuch; Xapian::docid doc_id; + int frozen; char *message_id; + char *thread_id; char *filename; + notmuch_message_file_t *message_file; Xapian::Document doc; }; -typedef struct _notmuch_terms { - char prefix_char; - Xapian::TermIterator iterator; - Xapian::TermIterator iterator_end; -} notmuch_terms_t; - -struct _notmuch_tags { - notmuch_terms_t terms; -}; - -struct _notmuch_thread_ids { - notmuch_terms_t terms; -}; - /* "128 bits of thread-id ought to be enough for anybody" */ #define NOTMUCH_THREAD_ID_BITS 128 #define NOTMUCH_THREAD_ID_DIGITS (NOTMUCH_THREAD_ID_BITS / 4) @@ -80,13 +71,15 @@ _notmuch_message_destructor (notmuch_message_t *message) * caller *is* responsible for calling notmuch_message_destroy. * * If no document exists in the database with document ID of 'doc_id' - * then this function returns NULL and sets *status to + * then this function returns NULL and optionally sets *status to * NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND. * * This function can also fail to due lack of available memory, * returning NULL and optionally setting *status to - * NOTMUCH_PRIVATE_STATUS_OUT_OF_MEMORY. Caller can pass NULL - * for status if uninterested in distinguishing these two cases. + * NOTMUCH_PRIVATE_STATUS_OUT_OF_MEMORY. + * + * The caller can pass NULL for status if uninterested in + * distinguishing these two cases. */ notmuch_message_t * _notmuch_message_create (const void *talloc_owner, @@ -108,8 +101,14 @@ _notmuch_message_create (const void *talloc_owner, message->notmuch = notmuch; message->doc_id = doc_id; - message->message_id = NULL; /* lazily created */ - message->filename = NULL; /* lazily created */ + + message->frozen = 0; + + /* Each of these will be lazily created as needed. */ + message->message_id = NULL; + message->thread_id = NULL; + message->filename = NULL; + message->message_file = NULL; /* This is C++'s creepy "placement new", which is really just an * ugly way to call a constructor for a pre-allocated object. So @@ -149,7 +148,8 @@ _notmuch_message_create (const void *talloc_owner, * If there is already a document with message ID 'message_id' in the * database, then the returned message can be used to query/modify the * document. Otherwise, a new document will be inserted into the - * database before this function returns. + * database before this function returns, (and *status will be set + * to NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND). * * If an error occurs, this function will return NULL and *status * will be set as appropriate. (The status pointer argument must @@ -159,15 +159,14 @@ notmuch_message_t * _notmuch_message_create_for_message_id (const void *talloc_owner, notmuch_database_t *notmuch, const char *message_id, - notmuch_status_t *status) + notmuch_private_status_t *status_ret) { - notmuch_private_status_t private_status; notmuch_message_t *message; Xapian::Document doc; unsigned int doc_id; char *term; - *status = NOTMUCH_STATUS_SUCCESS; + *status_ret = NOTMUCH_PRIVATE_STATUS_SUCCESS; message = notmuch_database_find_message (notmuch, message_id); if (message) @@ -176,7 +175,7 @@ _notmuch_message_create_for_message_id (const void *talloc_owner, term = talloc_asprintf (NULL, "%s%s", _find_prefix ("id"), message_id); if (term == NULL) { - *status = NOTMUCH_STATUS_OUT_OF_MEMORY; + *status_ret = NOTMUCH_PRIVATE_STATUS_OUT_OF_MEMORY; return NULL; } @@ -188,20 +187,17 @@ _notmuch_message_create_for_message_id (const void *talloc_owner, doc_id = notmuch->xapian_db->add_document (doc); } catch (const Xapian::Error &error) { - *status = NOTMUCH_STATUS_XAPIAN_EXCEPTION; + *status_ret = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION; return NULL; } message = _notmuch_message_create (talloc_owner, notmuch, - doc_id, &private_status); - - if (private_status >= (notmuch_private_status_t) NOTMUCH_STATUS_LAST_STATUS) - { - fprintf (stderr, "Internal error: Failed to find document immediately after adding it.\n"); - exit (1); - } + doc_id, status_ret); - *status = (notmuch_status_t) private_status; + /* We want to inform the caller that we had to create a new + * document. */ + if (*status_ret == NOTMUCH_PRIVATE_STATUS_SUCCESS) + *status_ret = NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND; return message; } @@ -217,23 +213,111 @@ notmuch_message_get_message_id (notmuch_message_t *message) i = message->doc.termlist_begin (); i.skip_to (_find_prefix ("id")); - if (i == message->doc.termlist_end ()) { - fprintf (stderr, "Internal error: Message with document ID of %d has no message ID.\n", - message->doc_id); - exit (1); - } + if (i == message->doc.termlist_end ()) + INTERNAL_ERROR ("Message with document ID of %d has no message ID.\n", + message->doc_id); message->message_id = talloc_strdup (message, (*i).c_str () + 1); + +#if DEBUG_DATABASE_SANITY + i++; + + if (i != message->doc.termlist_end () && + strncmp ((*i).c_str (), _find_prefix ("id"), + strlen (_find_prefix ("id"))) == 0) + { + INTERNAL_ERROR ("Mail (doc_id: %d) has duplicate message IDs", + message->doc_id); + } +#endif + return message->message_id; } +static void +_notmuch_message_ensure_message_file (notmuch_message_t *message) +{ + const char *filename; + + if (message->message_file) + return; + + filename = notmuch_message_get_filename (message); + if (unlikely (filename == NULL)) + return; + + message->message_file = _notmuch_message_file_open_ctx (message, filename); +} + +const char * +notmuch_message_get_header (notmuch_message_t *message, const char *header) +{ + _notmuch_message_ensure_message_file (message); + if (message->message_file == NULL) + return NULL; + + return notmuch_message_file_get_header (message->message_file, header); +} + +const char * +notmuch_message_get_all_headers (notmuch_message_t *message) +{ + _notmuch_message_ensure_message_file (message); + if (message->message_file == NULL) + return NULL; + + return notmuch_message_file_get_all_headers (message->message_file); +} + +size_t +notmuch_message_get_header_size (notmuch_message_t *message) +{ + _notmuch_message_ensure_message_file (message); + if (message->message_file == NULL) + return 0; + + return notmuch_message_file_get_header_size (message->message_file); + +} + +const char * +notmuch_message_get_thread_id (notmuch_message_t *message) +{ + Xapian::TermIterator i; + + if (message->thread_id) + return message->thread_id; + + i = message->doc.termlist_begin (); + i.skip_to (_find_prefix ("thread")); + + if (i == message->doc.termlist_end ()) + INTERNAL_ERROR ("Message with document ID of %d has no thread ID.\n", + message->doc_id); + + message->thread_id = talloc_strdup (message, (*i).c_str () + 1); + +#if DEBUG_DATABASE_SANITY + i++; + + if (i != message->doc.termlist_end () && + strncmp ((*i).c_str (), _find_prefix ("thread"), + strlen (_find_prefix ("thread"))) == 0) + { + INTERNAL_ERROR ("Message %s has duplicate thread IDs: %s and %s\n", + notmuch_message_get_message_id (message), + message->thread_id, + (*i).c_str () + 1); + } +#endif + + return message->thread_id; +} + /* Set the filename for 'message' to 'filename'. * - * XXX: We should still figure out what we want to do for multiple - * files with identical message IDs. We will probably want to store a - * list of filenames here, (so that this will be "add_filename" - * instead of "set_filename"). Which would make this very similar to - * add_thread_ids. + * XXX: We should still figure out if we think it's important to store + * multiple filenames for email messages with identical message IDs. * * This change will not be reflected in the database until the next * call to _notmuch_message_set_sync. */ @@ -241,90 +325,103 @@ void _notmuch_message_set_filename (notmuch_message_t *message, const char *filename) { - if (message->filename) + const char *s; + const char *db_path; + unsigned int db_path_len; + + if (message->filename) { talloc_free (message->filename); - message->doc.set_data (filename); + message->filename = NULL; + } + + if (filename == NULL) + INTERNAL_ERROR ("Message filename cannot be NULL."); + + s = filename; + + db_path = notmuch_database_get_path (message->notmuch); + db_path_len = strlen (db_path); + + if (*s == '/' && strncmp (s, db_path, db_path_len) == 0 + && strlen (s) > db_path_len) + { + s += db_path_len + 1; + } + + message->doc.set_data (s); } const char * notmuch_message_get_filename (notmuch_message_t *message) { std::string filename_str; + const char *db_path; if (message->filename) return message->filename; filename_str = message->doc.get_data (); - message->filename = talloc_strdup (message, filename_str.c_str ()); + db_path = notmuch_database_get_path (message->notmuch); + + if (filename_str[0] != '/') + message->filename = talloc_asprintf (message, "%s/%s", db_path, + filename_str.c_str ()); + else + message->filename = talloc_strdup (message, filename_str.c_str ()); return message->filename; } -/* We end up having to call the destructors explicitly because we had - * to use "placement new" in order to initialize C++ objects within a - * block that we allocated with talloc. So C++ is making talloc - * slightly less simple to use, (we wouldn't need - * talloc_set_destructor at all otherwise). - */ -static int -_notmuch_terms_destructor (notmuch_terms_t *terms) +time_t +notmuch_message_get_date (notmuch_message_t *message) { - terms->iterator.~TermIterator (); - terms->iterator_end.~TermIterator (); + std::string value; - return 0; + try { + value = message->doc.get_value (NOTMUCH_VALUE_TIMESTAMP); + } catch (Xapian::Error &error) { + INTERNAL_ERROR ("Failed to read timestamp value from document."); + return 0; + } + + return Xapian::sortable_unserialise (value); } -notmuch_terms_t * -_notmuch_terms_create (void *ctx, - Xapian::Document doc, - const char *prefix_name) +notmuch_tags_t * +notmuch_message_get_tags (notmuch_message_t *message) { - notmuch_terms_t *terms; - const char *prefix = _find_prefix (prefix_name); + const char *prefix = _find_prefix ("tag"); + Xapian::TermIterator i, end; + notmuch_tags_t *tags; + std::string tag; - /* Currently, notmuch_terms_t is written with the assumption that - * any prefix its derivatives use will be only a single - * character. */ + /* Currently this iteration is written with the assumption that + * "tag" has a single-character prefix. */ assert (strlen (prefix) == 1); - terms = talloc (ctx, notmuch_terms_t); - if (unlikely (terms == NULL)) + tags = _notmuch_tags_create (message); + if (unlikely (tags == NULL)) return NULL; - terms->prefix_char = *prefix; - new (&terms->iterator) Xapian::TermIterator; - new (&terms->iterator_end) Xapian::TermIterator; + i = message->doc.termlist_begin (); + end = message->doc.termlist_end (); - talloc_set_destructor (terms, _notmuch_terms_destructor); + i.skip_to (prefix); - terms->iterator = doc.termlist_begin (); - terms->iterator.skip_to (prefix); - terms->iterator_end = doc.termlist_end (); + while (1) { + tag = *i; - return terms; -} + if (tag.empty () || tag[0] != *prefix) + break; -/* The assertion is to ensure that 'type' is a derivative of - * notmuch_terms_t in that it contains a notmuch_terms_t as its first - * member. We do this by name of 'terms' as opposed to type, because - * that's as clever as I've been so far. */ -#define _notmuch_terms_create_type(ctx, doc, prefix_name, type) \ - (COMPILE_TIME_ASSERT(offsetof(type, terms) == 0), \ - (type *) _notmuch_terms_create (ctx, doc, prefix_name)) + _notmuch_tags_add_tag (tags, tag.c_str () + 1); -notmuch_tags_t * -notmuch_message_get_tags (notmuch_message_t *message) -{ - return _notmuch_terms_create_type (message, message->doc, "tag", - notmuch_tags_t); -} + i++; + } -notmuch_thread_ids_t * -notmuch_message_get_thread_ids (notmuch_message_t *message) -{ - return _notmuch_terms_create_type (message, message->doc, "thread", - notmuch_thread_ids_t); + _notmuch_tags_prepare_iterator (tags); + + return tags; } void @@ -333,19 +430,12 @@ _notmuch_message_set_date (notmuch_message_t *message, { time_t time_value; - time_value = notmuch_parse_date (date, NULL); + time_value = g_mime_utils_header_decode_date (date, NULL); message->doc.add_value (NOTMUCH_VALUE_TIMESTAMP, Xapian::sortable_serialise (time_value)); } -void -_notmuch_message_add_thread_id (notmuch_message_t *message, - const char *thread_id) -{ - _notmuch_message_add_term (message, "thread", thread_id); -} - static void thread_id_generate (thread_id_t *thread_id) { @@ -425,6 +515,32 @@ _notmuch_message_add_term (notmuch_message_t *message, return NOTMUCH_PRIVATE_STATUS_SUCCESS; } +/* 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 unprefixed). */ +notmuch_private_status_t +_notmuch_message_gen_terms (notmuch_message_t *message, + const char *prefix_name, + const char *text) +{ + Xapian::TermGenerator *term_gen = message->notmuch->term_gen; + + if (text == NULL) + return NOTMUCH_PRIVATE_STATUS_NULL_POINTER; + + term_gen->set_document (message->doc); + + if (prefix_name) { + const char *prefix = _find_prefix (prefix_name); + + term_gen->index_text (text, 1, prefix); + } + + term_gen->index_text (text); + + return NOTMUCH_PRIVATE_STATUS_SUCCESS; +} + /* Remove a name:value term from 'message', (the actual term will be * encoded by prefixing the value with a short prefix). See * NORMAL_PREFIX and BOOLEAN_PREFIX arrays for the mapping of term @@ -448,7 +564,14 @@ _notmuch_message_remove_term (notmuch_message_t *message, if (strlen (term) > NOTMUCH_TERM_MAX) return NOTMUCH_PRIVATE_STATUS_TERM_TOO_LONG; - message->doc.remove_term (term); + try { + message->doc.remove_term (term); + } catch (const Xapian::InvalidArgumentError) { + /* We'll let the philosopher's 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. */ + } talloc_free (term); @@ -468,12 +591,12 @@ notmuch_message_add_tag (notmuch_message_t *message, const char *tag) status = _notmuch_message_add_term (message, "tag", tag); if (status) { - fprintf (stderr, "Internal error: _notmuch_message_add_term return unexpected value: %d\n", - status); - exit (1); + INTERNAL_ERROR ("_notmuch_message_add_term return unexpected value: %d\n", + status); } - _notmuch_message_sync (message); + if (! message->frozen) + _notmuch_message_sync (message); return NOTMUCH_STATUS_SUCCESS; } @@ -491,99 +614,61 @@ notmuch_message_remove_tag (notmuch_message_t *message, const char *tag) status = _notmuch_message_remove_term (message, "tag", tag); if (status) { - fprintf (stderr, "Internal error: _notmuch_message_remove_term return unexpected value: %d\n", - status); - exit (1); + INTERNAL_ERROR ("_notmuch_message_remove_term return unexpected value: %d\n", + status); } - _notmuch_message_sync (message); + if (! message->frozen) + _notmuch_message_sync (message); return NOTMUCH_STATUS_SUCCESS; } void -notmuch_message_destroy (notmuch_message_t *message) +notmuch_message_remove_all_tags (notmuch_message_t *message) { - talloc_free (message); -} - -notmuch_bool_t -_notmuch_terms_has_more (notmuch_terms_t *terms) -{ - std::string s; - - if (terms->iterator == terms->iterator_end) - return FALSE; - - s = *terms->iterator; - if (! s.empty () && s[0] == terms->prefix_char) - return TRUE; - else - return FALSE; -} - -const char * -_notmuch_terms_get (notmuch_terms_t *terms) -{ - return talloc_strdup (terms, (*terms->iterator).c_str () + 1); -} - -void -_notmuch_terms_advance (notmuch_terms_t *terms) -{ - terms->iterator++; -} - -void -_notmuch_terms_destroy (notmuch_terms_t *terms) -{ - talloc_free (terms); -} + notmuch_private_status_t status; + notmuch_tags_t *tags; + const char *tag; -notmuch_bool_t -notmuch_tags_has_more (notmuch_tags_t *tags) -{ - return _notmuch_terms_has_more (&tags->terms); -} + for (tags = notmuch_message_get_tags (message); + notmuch_tags_has_more (tags); + notmuch_tags_advance (tags)) + { + tag = notmuch_tags_get (tags); -const char * -notmuch_tags_get (notmuch_tags_t *tags) -{ - return _notmuch_terms_get (&tags->terms); -} + status = _notmuch_message_remove_term (message, "tag", tag); + if (status) { + INTERNAL_ERROR ("_notmuch_message_remove_term return unexpected value: %d\n", + status); + } + } -void -notmuch_tags_advance (notmuch_tags_t *tags) -{ - return _notmuch_terms_advance (&tags->terms); + if (! message->frozen) + _notmuch_message_sync (message); } void -notmuch_tags_destroy (notmuch_tags_t *tags) +notmuch_message_freeze (notmuch_message_t *message) { - return _notmuch_terms_destroy (&tags->terms); + message->frozen++; } -notmuch_bool_t -notmuch_thread_ids_has_more (notmuch_thread_ids_t *thread_ids) -{ - return _notmuch_terms_has_more (&thread_ids->terms); -} - -const char * -notmuch_thread_ids_get (notmuch_thread_ids_t *thread_ids) -{ - return _notmuch_terms_get (&thread_ids->terms); -} - -void -notmuch_thread_ids_advance (notmuch_thread_ids_t *thread_ids) -{ - return _notmuch_terms_advance (&thread_ids->terms); +notmuch_status_t +notmuch_message_thaw (notmuch_message_t *message) +{ + if (message->frozen > 0) { + message->frozen--; + if (message->frozen == 0) + _notmuch_message_sync (message); + return NOTMUCH_STATUS_SUCCESS; + } else { + return NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW; + } } void -notmuch_thread_ids_destroy (notmuch_thread_ids_t *thread_ids) +notmuch_message_destroy (notmuch_message_t *message) { - return _notmuch_terms_destroy (&thread_ids->terms); + talloc_free (message); }