X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=message.cc;h=154efa0fd47ebde90460ed1516256715b902f723;hp=8ca8fdee1871b0f10f7700477e1e3da76f0553b4;hb=fa226a7a10ba95f8d8a7ff92dbfc44f6404d9d4d;hpb=8ad4350fef132b016bbab5eeb1c4a713e51035c6 diff --git a/message.cc b/message.cc index 8ca8fdee..154efa0f 100644 --- a/message.cc +++ b/message.cc @@ -21,73 +21,27 @@ #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; }; -struct _notmuch_tags { - Xapian::TermIterator iterator; - Xapian::TermIterator iterator_end; -}; - -struct _notmuch_thread_ids { - char *current; - char *next; -}; - -#define ARRAY_SIZE(arr) (sizeof (arr) / sizeof (arr[0])) - -/* These prefix values are specifically chosen to be compatible - * with sup, (http://sup.rubyforge.org), written by - * William Morgan , and released - * under the GNU GPL v2. - */ - -typedef struct { - const char *name; - const char *prefix; -} prefix_t; - -prefix_t NORMAL_PREFIX[] = { - { "subject", "S" }, - { "body", "B" }, - { "from_name", "FN" }, - { "to_name", "TN" }, - { "name", "N" }, - { "attachment", "A" } -}; - -prefix_t BOOLEAN_PREFIX[] = { - { "type", "K" }, - { "from_email", "FE" }, - { "to_email", "TE" }, - { "email", "E" }, - { "date", "D" }, - { "label", "L" }, - { "source_id", "I" }, - { "attachment_extension", "O" }, - { "msgid", "Q" }, - { "thread", "H" }, - { "ref", "R" } -}; - -const char * -_find_prefix (const char *name) -{ - unsigned int i; - - for (i = 0; i < ARRAY_SIZE (NORMAL_PREFIX); i++) - if (strcmp (name, NORMAL_PREFIX[i].name) == 0) - return NORMAL_PREFIX[i].prefix; - - for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX); i++) - if (strcmp (name, BOOLEAN_PREFIX[i].name) == 0) - return BOOLEAN_PREFIX[i].prefix; - - return ""; -} +/* "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) +typedef struct _thread_id { + char str[NOTMUCH_THREAD_ID_DIGITS + 1]; +} thread_id_t; /* We end up having to call the destructor explicitly because we had * to use "placement new" in order to initialize C++ objects within a @@ -103,22 +57,147 @@ _notmuch_message_destructor (notmuch_message_t *message) return 0; } +/* Create a new notmuch_message_t object for an existing document in + * the database. + * + * Here, 'talloc owner' is an optional talloc context to which the new + * message will belong. This allows for the caller to not bother + * calling notmuch_message_destroy on the message, and no that all + * memory will be reclaimed with 'talloc_owner' is free. The caller + * still can call notmuch_message_destroy when finished with the + * message if desired. + * + * The 'talloc_owner' argument can also be NULL, in which case the + * 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 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. + * + * The caller can pass NULL for status if uninterested in + * distinguishing these two cases. + */ notmuch_message_t * -_notmuch_message_create (notmuch_results_t *owner, +_notmuch_message_create (const void *talloc_owner, notmuch_database_t *notmuch, - Xapian::docid doc_id) + unsigned int doc_id, + notmuch_private_status_t *status) { notmuch_message_t *message; - message = talloc (owner, notmuch_message_t); - if (unlikely (message == NULL)) + if (status) + *status = NOTMUCH_PRIVATE_STATUS_SUCCESS; + + message = talloc (talloc_owner, notmuch_message_t); + if (unlikely (message == NULL)) { + if (status) + *status = NOTMUCH_PRIVATE_STATUS_OUT_OF_MEMORY; return NULL; + } + + message->notmuch = notmuch; + message->doc_id = doc_id; + + 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 + * it's really not an error to not be checking for OUT_OF_MEMORY + * here, since this "new" isn't actually allocating memory. This + * is language-design comedy of the wrong kind. */ new (&message->doc) Xapian::Document; talloc_set_destructor (message, _notmuch_message_destructor); - message->doc = notmuch->xapian_db->get_document (doc_id); + try { + message->doc = notmuch->xapian_db->get_document (doc_id); + } catch (const Xapian::DocNotFoundError &error) { + talloc_free (message); + if (status) + *status = NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND; + return NULL; + } + + return message; +} + +/* Create a new notmuch_message_t object for a specific message ID, + * (which may or may not already exist in the databas). + * + * Here, 'talloc owner' is an optional talloc context to which the new + * message will belong. This allows for the caller to not bother + * calling notmuch_message_destroy on the message, and no that all + * memory will be reclaimed with 'talloc_owner' is free. The caller + * still can call notmuch_message_destroy when finished with the + * message if desired. + * + * The 'talloc_owner' argument can also be NULL, in which case the + * caller *is* responsible for calling notmuch_message_destroy. + * + * 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, (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 + * not be NULL.) + */ +notmuch_message_t * +_notmuch_message_create_for_message_id (const void *talloc_owner, + notmuch_database_t *notmuch, + const char *message_id, + notmuch_private_status_t *status_ret) +{ + notmuch_message_t *message; + Xapian::Document doc; + unsigned int doc_id; + char *term; + + *status_ret = NOTMUCH_PRIVATE_STATUS_SUCCESS; + + message = notmuch_database_find_message (notmuch, message_id); + if (message) + return talloc_steal (talloc_owner, message); + + term = talloc_asprintf (NULL, "%s%s", + _find_prefix ("id"), message_id); + if (term == NULL) { + *status_ret = NOTMUCH_PRIVATE_STATUS_OUT_OF_MEMORY; + return NULL; + } + + try { + doc.add_term (term); + talloc_free (term); + + doc.add_value (NOTMUCH_VALUE_MESSAGE_ID, message_id); + + doc_id = notmuch->xapian_db->add_document (doc); + } catch (const Xapian::Error &error) { + *status_ret = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION; + return NULL; + } + + message = _notmuch_message_create (talloc_owner, notmuch, + doc_id, status_ret); + + /* 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; } @@ -128,131 +207,468 @@ notmuch_message_get_message_id (notmuch_message_t *message) { Xapian::TermIterator i; + if (message->message_id) + return message->message_id; + i = message->doc.termlist_begin (); - i.skip_to ("Q"); - if (i != message->doc.termlist_end ()) - return talloc_strdup (message, (*i).c_str () + 1); - else + i.skip_to (_find_prefix ("id")); + + 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); } -/* 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_tags_destructor (notmuch_tags_t *tags) +const char * +notmuch_message_get_all_headers (notmuch_message_t *message) { - tags->iterator.~TermIterator (); - tags->iterator_end.~TermIterator (); + _notmuch_message_ensure_message_file (message); + if (message->message_file == NULL) + return NULL; - return 0; + 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 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. */ +void +_notmuch_message_set_filename (notmuch_message_t *message, + const char *filename) +{ + const char *s; + const char *db_path; + unsigned int db_path_len; + + if (message->filename) { + talloc_free (message->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 (); + 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; +} + +time_t +notmuch_message_get_date (notmuch_message_t *message) +{ + std::string value; + + 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_tags_t * notmuch_message_get_tags (notmuch_message_t *message) { + const char *prefix = _find_prefix ("tag"); + Xapian::TermIterator i, end; notmuch_tags_t *tags; + std::string tag; - tags = talloc (message, notmuch_tags_t); + /* Currently this iteration is written with the assumption that + * "tag" has a single-character prefix. */ + assert (strlen (prefix) == 1); + + tags = _notmuch_tags_create (message); if (unlikely (tags == NULL)) return NULL; - new (&tags->iterator) Xapian::TermIterator; - new (&tags->iterator_end) Xapian::TermIterator; + i = message->doc.termlist_begin (); + end = message->doc.termlist_end (); + + i.skip_to (prefix); - talloc_set_destructor (tags, _notmuch_tags_destructor); + while (1) { + tag = *i; - tags->iterator = message->doc.termlist_begin (); - tags->iterator.skip_to ("L"); - tags->iterator_end = message->doc.termlist_end (); + if (tag.empty () || tag[0] != *prefix) + break; + + _notmuch_tags_add_tag (tags, tag.c_str () + 1); + + i++; + } + + _notmuch_tags_prepare_iterator (tags); return tags; } -notmuch_thread_ids_t * -notmuch_message_get_thread_ids (notmuch_message_t *message) +void +_notmuch_message_set_date (notmuch_message_t *message, + const char *date) { - notmuch_thread_ids_t *thread_ids; - const char *id_str; + time_t time_value; - thread_ids = talloc (message, notmuch_thread_ids_t); - if (unlikely (thread_ids == NULL)) - return NULL; + time_value = g_mime_utils_header_decode_date (date, NULL); - id_str = message->doc.get_value (NOTMUCH_VALUE_THREAD).c_str (); - thread_ids->next = talloc_strdup (message, id_str); + message->doc.add_value (NOTMUCH_VALUE_TIMESTAMP, + Xapian::sortable_serialise (time_value)); +} - /* Initialize thread_ids->current and terminate first ID. */ - notmuch_thread_ids_advance (thread_ids); +static void +thread_id_generate (thread_id_t *thread_id) +{ + static int seeded = 0; + FILE *dev_random; + uint32_t value; + char *s; + int i; + + if (! seeded) { + dev_random = fopen ("/dev/random", "r"); + if (dev_random == NULL) { + srand (time (NULL)); + } else { + fread ((void *) &value, sizeof (value), 1, dev_random); + srand (value); + fclose (dev_random); + } + seeded = 1; + } + + s = thread_id->str; + for (i = 0; i < NOTMUCH_THREAD_ID_DIGITS; i += 8) { + value = rand (); + sprintf (s, "%08x", value); + s += 8; + } +} + +void +_notmuch_message_ensure_thread_id (notmuch_message_t *message) +{ + /* If not part of any existing thread, generate a new thread_id. */ + thread_id_t thread_id; - return thread_ids; + thread_id_generate (&thread_id); + _notmuch_message_add_term (message, "thread", thread_id.str); } +/* Synchronize changes made to message->doc out into the database. */ void -notmuch_message_destroy (notmuch_message_t *message) +_notmuch_message_sync (notmuch_message_t *message) { - talloc_free (message); + Xapian::WritableDatabase *db = message->notmuch->xapian_db; + + db->replace_document (message->doc_id, message->doc); } -notmuch_bool_t -notmuch_tags_has_more (notmuch_tags_t *tags) +/* Add a name:value term to '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 + * names to prefix values. + * + * This change will not be reflected in the database until the next + * call to _notmuch_message_set_sync. */ +notmuch_private_status_t +_notmuch_message_add_term (notmuch_message_t *message, + const char *prefix_name, + const char *value) { - std::string s; - if (tags->iterator == tags->iterator_end) - return FALSE; + char *term; - s = *tags->iterator; - if (s.size () && s[0] == 'L') - return TRUE; - else - return FALSE; + 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) + return NOTMUCH_PRIVATE_STATUS_TERM_TOO_LONG; + + message->doc.add_term (term); + + talloc_free (term); + + return NOTMUCH_PRIVATE_STATUS_SUCCESS; } -const char * -notmuch_tags_get (notmuch_tags_t *tags) +/* 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) { - return talloc_strdup (tags, (*tags->iterator).c_str () + 1); + 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; } -void -notmuch_tags_advance (notmuch_tags_t *tags) +/* 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 + * names to prefix values. + * + * This change will not be reflected in the database until the next + * call to _notmuch_message_set_sync. */ +notmuch_private_status_t +_notmuch_message_remove_term (notmuch_message_t *message, + const char *prefix_name, + const char *value) { - tags->iterator++; + char *term; + + 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) + return NOTMUCH_PRIVATE_STATUS_TERM_TOO_LONG; + + 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); + + return NOTMUCH_PRIVATE_STATUS_SUCCESS; } -void -notmuch_tags_destroy (notmuch_tags_t *tags) +notmuch_status_t +notmuch_message_add_tag (notmuch_message_t *message, const char *tag) { - talloc_free (tags); + notmuch_private_status_t status; + + if (tag == NULL) + return NOTMUCH_STATUS_NULL_POINTER; + + if (strlen (tag) > NOTMUCH_TAG_MAX) + return NOTMUCH_STATUS_TAG_TOO_LONG; + + status = _notmuch_message_add_term (message, "tag", tag); + if (status) { + INTERNAL_ERROR ("_notmuch_message_add_term return unexpected value: %d\n", + status); + } + + if (! message->frozen) + _notmuch_message_sync (message); + + return NOTMUCH_STATUS_SUCCESS; } -notmuch_bool_t -notmuch_thread_ids_has_more (notmuch_thread_ids_t *thread_ids) +notmuch_status_t +notmuch_message_remove_tag (notmuch_message_t *message, const char *tag) { - if (thread_ids->current == NULL || *thread_ids->current == '\0') - return FALSE; - else - return TRUE; + notmuch_private_status_t status; + + if (tag == NULL) + return NOTMUCH_STATUS_NULL_POINTER; + + if (strlen (tag) > NOTMUCH_TAG_MAX) + return NOTMUCH_STATUS_TAG_TOO_LONG; + + status = _notmuch_message_remove_term (message, "tag", tag); + if (status) { + INTERNAL_ERROR ("_notmuch_message_remove_term return unexpected value: %d\n", + status); + } + + if (! message->frozen) + _notmuch_message_sync (message); + + return NOTMUCH_STATUS_SUCCESS; } -const char * -notmuch_thread_ids_get (notmuch_thread_ids_t *thread_ids) +void +notmuch_message_remove_all_tags (notmuch_message_t *message) { - return thread_ids->current; + notmuch_private_status_t status; + notmuch_tags_t *tags; + const char *tag; + + for (tags = notmuch_message_get_tags (message); + notmuch_tags_has_more (tags); + notmuch_tags_advance (tags)) + { + tag = notmuch_tags_get (tags); + + status = _notmuch_message_remove_term (message, "tag", tag); + if (status) { + INTERNAL_ERROR ("_notmuch_message_remove_term return unexpected value: %d\n", + status); + } + } + + if (! message->frozen) + _notmuch_message_sync (message); } void -notmuch_thread_ids_advance (notmuch_thread_ids_t *thread_ids) +notmuch_message_freeze (notmuch_message_t *message) { - thread_ids->current = strsep (&thread_ids->next, ","); + message->frozen++; +} + +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) { - talloc_free (thread_ids); + talloc_free (message); }