X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=lib%2Fdatabase.cc;h=b6c4d07b794eb37ccdb73b68a31c993fc2326be8;hp=4e49e53f9c883a1d14ca0daa9e27e022f582d7b1;hb=db68eea0134bf0ea97aa6a887a7c302a610484a1;hpb=4d35c3544d7bb0143cb1a17cc197cfe271670bf8 diff --git a/lib/database.cc b/lib/database.cc index 4e49e53f..b6c4d07b 100644 --- a/lib/database.cc +++ b/lib/database.cc @@ -42,7 +42,8 @@ typedef struct { * Mail document * ------------- * A mail document is associated with a particular email message file - * on disk. It is indexed with the following prefixed terms: + * on disk. It is indexed with the following prefixed terms which the + * database uses to construct threads, etc.: * * Single terms of given prefix: * @@ -53,15 +54,14 @@ typedef struct { * * thread: The ID of the thread to which the mail belongs * + * replyto: The ID from the In-Reply-To header of the mail (if any). + * * Multiple terms of given prefix: * - * ref: All unresolved message IDs from In-Reply-To and - * References headers in the message. (Once a referenced - * message is added to the database and the thread IDs - * are linked the corresponding "ref" term is dropped - * from the message document.) + * reference: All message IDs from In-Reply-To and Re ferences + * headers in the message. * - * tag: Any tags associated with this message by the user. + * tag: Any tags associated with this message by the user. * * A mail document also has two values: * @@ -70,6 +70,11 @@ typedef struct { * * MESSAGE_ID: The unique ID of the mail mess (see "id" above) * + * In addition, terms from the content of the message are added with + * "from", "to", "attachment", and "subject" prefixes for use by the + * user in searching. But the database doesn't really care itself + * about any of these. + * * Timestamp document * ------------------ * A timestamp document is used by a client of the notmuch library to @@ -104,7 +109,7 @@ typedef struct { prefix_t BOOLEAN_PREFIX_INTERNAL[] = { { "type", "T" }, - { "ref", "XREFERENCE" }, + { "reference", "XREFERENCE" }, { "replyto", "XREPLYTO" }, { "timestamp", "XTIMESTAMP" }, }; @@ -142,17 +147,20 @@ _find_prefix (const char *name) { unsigned int i; - for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_INTERNAL); i++) + for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_INTERNAL); i++) { if (strcmp (name, BOOLEAN_PREFIX_INTERNAL[i].name) == 0) return BOOLEAN_PREFIX_INTERNAL[i].prefix; + } - for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) + for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) { if (strcmp (name, BOOLEAN_PREFIX_EXTERNAL[i].name) == 0) return BOOLEAN_PREFIX_EXTERNAL[i].prefix; + } - for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) + for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) { if (strcmp (name, PROBABILISTIC_PREFIX[i].name) == 0) return PROBABILISTIC_PREFIX[i].prefix; + } INTERNAL_ERROR ("No prefix exists for '%s'\n", name); @@ -167,6 +175,8 @@ notmuch_status_to_string (notmuch_status_t status) return "No error occurred"; case NOTMUCH_STATUS_OUT_OF_MEMORY: return "Out of memory"; + case NOTMUCH_STATUS_READONLY_DATABASE: + return "The database is read-only"; case NOTMUCH_STATUS_XAPIAN_EXCEPTION: return "A Xapian exception occurred"; case NOTMUCH_STATUS_FILE_ERROR: @@ -180,7 +190,7 @@ notmuch_status_to_string (notmuch_status_t status) case NOTMUCH_STATUS_TAG_TOO_LONG: return "Tag value is too long (exceeds NOTMUCH_TAG_MAX)"; case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW: - return "Unblanced number of calls to notmuch_message_freeze/thaw"; + return "Unbalanced number of calls to notmuch_message_freeze/thaw"; default: case NOTMUCH_STATUS_LAST_STATUS: return "Unknown error status value"; @@ -288,13 +298,14 @@ skip_space_and_comments (const char **str) int nesting = 1; s++; while (*s && nesting) { - if (*s == '(') + if (*s == '(') { nesting++; - else if (*s == ')') + } else if (*s == ')') { nesting--; - else if (*s == '\\') + } else if (*s == '\\') { if (*(s+1)) s++; + } s++; } } @@ -313,12 +324,12 @@ skip_space_and_comments (const char **str) * * Returns NULL if there is any error parsing the message-id. */ static char * -parse_message_id (void *ctx, const char *message_id, const char **next) +_parse_message_id (void *ctx, const char *message_id, const char **next) { const char *s, *end; char *result; - if (message_id == NULL) + if (message_id == NULL || *message_id == '\0') return NULL; s = message_id; @@ -371,21 +382,28 @@ parse_message_id (void *ctx, const char *message_id, const char **next) } /* Parse a References header value, putting a (talloc'ed under 'ctx') - * copy of each referenced message-id into 'hash'. */ + * copy of each referenced message-id into 'hash'. + * + * We explicitly avoid including any reference identical to + * 'message_id' in the result (to avoid mass confusion when a single + * message references itself cyclically---and yes, mail messages are + * not infrequent in the wild that do this---don't ask me why). +*/ static void parse_references (void *ctx, + const char *message_id, GHashTable *hash, const char *refs) { char *ref; - if (refs == NULL) + if (refs == NULL || *refs == '\0') return; while (*refs) { - ref = parse_message_id (ctx, refs, &refs); + ref = _parse_message_id (ctx, refs, &refs); - if (ref) + if (ref && strcmp (ref, message_id)) g_hash_table_insert (hash, ref, NULL); } } @@ -426,7 +444,8 @@ notmuch_database_create (const char *path) goto DONE; } - notmuch = notmuch_database_open (path); + notmuch = notmuch_database_open (path, + NOTMUCH_DATABASE_MODE_READ_WRITE); DONE: if (notmuch_path) @@ -436,7 +455,8 @@ notmuch_database_create (const char *path) } notmuch_database_t * -notmuch_database_open (const char *path) +notmuch_database_open (const char *path, + notmuch_database_mode_t mode) { notmuch_database_t *notmuch = NULL; char *notmuch_path = NULL, *xapian_path = NULL; @@ -464,22 +484,30 @@ notmuch_database_open (const char *path) } notmuch = talloc (NULL, notmuch_database_t); + notmuch->exception_reported = FALSE; notmuch->path = talloc_strdup (notmuch, path); if (notmuch->path[strlen (notmuch->path) - 1] == '/') notmuch->path[strlen (notmuch->path) - 1] = '\0'; + notmuch->mode = mode; try { - notmuch->xapian_db = new Xapian::WritableDatabase (xapian_path, - Xapian::DB_CREATE_OR_OPEN); + if (mode == NOTMUCH_DATABASE_MODE_READ_WRITE) { + notmuch->xapian_db = new Xapian::WritableDatabase (xapian_path, + Xapian::DB_CREATE_OR_OPEN); + } else { + notmuch->xapian_db = new Xapian::Database (xapian_path); + } notmuch->query_parser = new Xapian::QueryParser; notmuch->term_gen = new Xapian::TermGenerator; notmuch->term_gen->set_stemmer (Xapian::Stem ("english")); + notmuch->value_range_processor = new Xapian::NumberValueRangeProcessor (NOTMUCH_VALUE_TIMESTAMP); notmuch->query_parser->set_default_op (Xapian::Query::OP_AND); notmuch->query_parser->set_database (*notmuch->xapian_db); notmuch->query_parser->set_stemmer (Xapian::Stem ("english")); notmuch->query_parser->set_stemming_strategy (Xapian::QueryParser::STEM_SOME); + notmuch->query_parser->add_valuerangeprocessor (notmuch->value_range_processor); for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) { prefix_t *prefix = &BOOLEAN_PREFIX_EXTERNAL[i]; @@ -492,11 +520,11 @@ notmuch_database_open (const char *path) notmuch->query_parser->add_prefix (prefix->name, prefix->prefix); } } catch (const Xapian::Error &error) { - fprintf (stderr, "A Xapian exception occurred: %s\n", + fprintf (stderr, "A Xapian exception occurred opening database: %s\n", error.get_msg().c_str()); notmuch = NULL; } - + DONE: if (notmuch_path) free (notmuch_path); @@ -509,11 +537,20 @@ notmuch_database_open (const char *path) void notmuch_database_close (notmuch_database_t *notmuch) { - notmuch->xapian_db->flush (); + try { + if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_WRITE) + (static_cast (notmuch->xapian_db))->flush (); + } catch (const Xapian::Error &error) { + if (! notmuch->exception_reported) { + fprintf (stderr, "Error: A Xapian exception occurred flushing database: %s\n", + error.get_msg().c_str()); + } + } delete notmuch->term_gen; delete notmuch->query_parser; delete notmuch->xapian_db; + delete notmuch->value_range_processor; talloc_free (notmuch); } @@ -555,11 +592,18 @@ notmuch_database_set_timestamp (notmuch_database_t *notmuch, const char *key, time_t timestamp) { Xapian::Document doc; + Xapian::WritableDatabase *db; unsigned int doc_id; notmuch_private_status_t status; notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS; char *db_key = NULL; + if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY) { + fprintf (stderr, "Attempted to update a read-only database.\n"); + return NOTMUCH_STATUS_READONLY_DATABASE; + } + + db = static_cast (notmuch->xapian_db); db_key = timestamp_db_key (key); try { @@ -574,14 +618,15 @@ notmuch_database_set_timestamp (notmuch_database_t *notmuch, doc.add_term (term); talloc_free (term); - notmuch->xapian_db->add_document (doc); + db->add_document (doc); } else { - notmuch->xapian_db->replace_document (doc_id, doc); + db->replace_document (doc_id, doc); } - } catch (Xapian::Error &error) { - fprintf (stderr, "A Xapian exception occurred: %s.\n", + } catch (const Xapian::Error &error) { + fprintf (stderr, "A Xapian exception occurred setting timestamp: %s.\n", error.get_msg().c_str()); + notmuch->exception_reported = TRUE; ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION; } @@ -610,6 +655,7 @@ notmuch_database_get_timestamp (notmuch_database_t *notmuch, const char *key) ret = Xapian::sortable_unserialise (doc.get_value (NOTMUCH_VALUE_TIMESTAMP)); } catch (Xapian::Error &error) { + ret = 0; goto DONE; } @@ -697,7 +743,7 @@ _notmuch_database_link_message_to_parents (notmuch_database_t *notmuch, const char **thread_id) { GHashTable *parents = NULL; - const char *refs, *in_reply_to; + const char *refs, *in_reply_to, *in_reply_to_message_id; GList *l, *keys = NULL; notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS; @@ -705,12 +751,22 @@ _notmuch_database_link_message_to_parents (notmuch_database_t *notmuch, _my_talloc_free_for_g_hash, NULL); refs = notmuch_message_file_get_header (message_file, "references"); - parse_references (message, parents, refs); + parse_references (message, notmuch_message_get_message_id (message), + parents, refs); in_reply_to = notmuch_message_file_get_header (message_file, "in-reply-to"); - parse_references (message, parents, in_reply_to); - _notmuch_message_add_term (message, "replyto", - parse_message_id (message, in_reply_to, NULL)); + parse_references (message, notmuch_message_get_message_id (message), + parents, in_reply_to); + + /* Carefully avoid adding any self-referential in-reply-to term. */ + in_reply_to_message_id = _parse_message_id (message, in_reply_to, NULL); + if (in_reply_to_message_id && + strcmp (in_reply_to_message_id, + notmuch_message_get_message_id (message))) + { + _notmuch_message_add_term (message, "replyto", + _parse_message_id (message, in_reply_to, NULL)); + } keys = g_hash_table_get_keys (parents); for (l = keys; l; l = l->next) { @@ -723,7 +779,8 @@ _notmuch_database_link_message_to_parents (notmuch_database_t *notmuch, parent_message_id); if (parent_thread_id == NULL) { - _notmuch_message_add_term (message, "ref", parent_message_id); + _notmuch_message_add_term (message, "reference", + parent_message_id); } else { if (*thread_id == NULL) { *thread_id = talloc_strdup (message, parent_thread_id); @@ -757,7 +814,7 @@ _notmuch_database_link_message_to_children (notmuch_database_t *notmuch, notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS; notmuch_private_status_t private_status; - find_doc_ids (notmuch, "ref", message_id, &child, &children_end); + find_doc_ids (notmuch, "reference", message_id, &child, &children_end); for ( ; child != children_end; child++) { @@ -774,7 +831,7 @@ _notmuch_database_link_message_to_children (notmuch_database_t *notmuch, *thread_id = talloc_strdup (message, child_thread_id); _notmuch_message_add_term (message, "thread", *thread_id); } else if (strcmp (*thread_id, child_thread_id)) { - _notmuch_message_remove_term (child_message, "ref", + _notmuch_message_remove_term (child_message, "reference", message_id); _notmuch_message_sync (child_message); ret = _merge_threads (notmuch, *thread_id, child_thread_id); @@ -796,14 +853,13 @@ _notmuch_database_link_message_to_children (notmuch_database_t *notmuch, /* Given a (mostly empty) 'message' and its corresponding * 'message_file' link it to existing threads in the database. * - * We first looke at 'message_file' and its link-relevant headers + * We first look at 'message_file' and its link-relevant headers * (References and In-Reply-To) for message IDs. We also look in the - * database for existing message that reference 'message'.p + * database for existing message that reference 'message'. * - * The end result is to call _notmuch_message_add_thread_id with one - * or more thread IDs to which this message belongs, (including - * generating a new thread ID if necessary if the message doesn't - * connect to any existing threads). + * The end result is to call _notmuch_message_ensure_thread_id which + * generates a new thread ID if the message doesn't connect to any + * existing threads. */ static notmuch_status_t _notmuch_database_link_message (notmuch_database_t *notmuch, @@ -842,7 +898,7 @@ notmuch_database_add_message (notmuch_database_t *notmuch, const char *date, *header; const char *from, *to, *subject; - char *message_id; + char *message_id = NULL; if (message_ret) *message_ret = NULL; @@ -873,9 +929,9 @@ notmuch_database_add_message (notmuch_database_t *notmuch, subject = notmuch_message_file_get_header (message_file, "subject"); to = notmuch_message_file_get_header (message_file, "to"); - if (from == NULL && - subject == NULL && - to == NULL) + if ((from == NULL || *from == '\0') && + (subject == NULL || *subject == '\0') && + (to == NULL || *to == '\0')) { ret = NOTMUCH_STATUS_FILE_NOT_EMAIL; goto DONE; @@ -885,13 +941,22 @@ notmuch_database_add_message (notmuch_database_t *notmuch, * is to find a message ID (or else create one ourselves). */ header = notmuch_message_file_get_header (message_file, "message-id"); - if (header) { - message_id = parse_message_id (message_file, header, NULL); + if (header && *header != '\0') { + message_id = _parse_message_id (message_file, header, NULL); + /* So the header value isn't RFC-compliant, but it's * better than no message-id at all. */ if (message_id == NULL) message_id = talloc_strdup (message_file, header); - } else { + + /* Reject a Message ID that's too long. */ + if (message_id && strlen (message_id) + 1 > NOTMUCH_TERM_MAX) { + talloc_free (message_id); + message_id = NULL; + } + } + + if (message_id == NULL ) { /* No message-id at all, let's generate one by taking a * hash over the file's contents. */ char *sha1 = notmuch_sha1_of_file (filename); @@ -911,16 +976,17 @@ notmuch_database_add_message (notmuch_database_t *notmuch, * (which may or may not reference an existing document in the * database). */ - /* Use NULL for owner since we want to free this locally. */ - message = _notmuch_message_create_for_message_id (NULL, - notmuch, + message = _notmuch_message_create_for_message_id (notmuch, message_id, &private_status); talloc_free (message_id); - if (message == NULL) + if (message == NULL) { + ret = COERCE_STATUS (private_status, + "Unexpected status value from _notmuch_message_create_for_message_id"); goto DONE; + } /* Is this a newly created message object? */ if (private_status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) { @@ -942,8 +1008,9 @@ notmuch_database_add_message (notmuch_database_t *notmuch, _notmuch_message_sync (message); } catch (const Xapian::Error &error) { - fprintf (stderr, "A Xapian exception occurred: %s.\n", - error.get_msg().c_str()); + fprintf (stderr, "A Xapian exception occurred adding message: %s.\n", + error.get_description().c_str()); + notmuch->exception_reported = TRUE; ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION; goto DONE; } @@ -961,3 +1028,46 @@ notmuch_database_add_message (notmuch_database_t *notmuch, return ret; } + +notmuch_tags_t * +_notmuch_convert_tags (void *ctx, Xapian::TermIterator &i, + Xapian::TermIterator &end) +{ + const char *prefix = _find_prefix ("tag"); + notmuch_tags_t *tags; + std::string tag; + + /* Currently this iteration is written with the assumption that + * "tag" has a single-character prefix. */ + assert (strlen (prefix) == 1); + + tags = _notmuch_tags_create (ctx); + if (unlikely (tags == NULL)) + return NULL; + + i.skip_to (prefix); + + while (i != end) { + tag = *i; + + 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_tags_t * +notmuch_database_get_all_tags (notmuch_database_t *db) +{ + Xapian::TermIterator i, end; + i = db->xapian_db->allterms_begin(); + end = db->xapian_db->allterms_end(); + return _notmuch_convert_tags(db, i, end); +}