#include "database-private.h"
-/* Advance 'str' past any whitespace or RFC 822 comments. A comment is
- * a (potentially nested) parenthesized sequence with '\' used to
- * escape any character (including parentheses).
- *
- * If the sequence to be skipped continues to the end of the string,
- * then 'str' will be left pointing at the final terminating '\0'
- * character.
- */
-static void
-skip_space_and_comments (const char **str)
-{
- const char *s;
-
- s = *str;
- while (*s && (isspace (*s) || *s == '(')) {
- while (*s && isspace (*s))
- s++;
- if (*s == '(') {
- int nesting = 1;
- s++;
- while (*s && nesting) {
- if (*s == '(') {
- nesting++;
- } else if (*s == ')') {
- nesting--;
- } else if (*s == '\\') {
- if (*(s+1))
- s++;
- }
- s++;
- }
- }
- }
-
- *str = s;
-}
-
-/* Parse an RFC 822 message-id, discarding whitespace, any RFC 822
- * comments, and the '<' and '>' delimiters.
- *
- * If not NULL, then *next will be made to point to the first character
- * not parsed, (possibly pointing to the final '\0' terminator.
- *
- * Returns a newly talloc'ed string belonging to 'ctx'.
- *
- * 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)
-{
- const char *s, *end;
- char *result;
-
- if (message_id == NULL || *message_id == '\0')
- return NULL;
-
- s = message_id;
-
- skip_space_and_comments (&s);
-
- /* Skip any unstructured text as well. */
- while (*s && *s != '<')
- s++;
-
- if (*s == '<') {
- s++;
- } else {
- if (next)
- *next = s;
- return NULL;
- }
-
- skip_space_and_comments (&s);
-
- end = s;
- while (*end && *end != '>')
- end++;
- if (next) {
- if (*end)
- *next = end + 1;
- else
- *next = end;
- }
-
- if (end > s && *end == '>')
- end--;
- if (end <= s)
- return NULL;
-
- result = talloc_strndup (ctx, s, end - s + 1);
-
- /* Finally, collapse any whitespace that is within the message-id
- * itself. */
- {
- char *r;
- int len;
-
- for (r = result, len = strlen (r); *r; r++, len--)
- if (*r == ' ' || *r == '\t')
- memmove (r, r+1, len);
- }
-
- return result;
-}
-
/* Parse a References header value, putting a (talloc'ed under 'ctx')
* copy of each referenced message-id into 'hash'.
*
return NULL;
while (*refs) {
- ref = _parse_message_id (ctx, refs, &refs);
+ ref = _notmuch_message_id_parse (ctx, refs, &refs);
if (ref && strcmp (ref, message_id)) {
g_hash_table_add (hash, ref);
* reference to the database. We should avoid making a message
* its own parent, thus the above check.
*/
- return talloc_strdup(ctx, last_ref);
+ return talloc_strdup (ctx, last_ref);
}
static const char *
_notmuch_database_generate_thread_id (notmuch_database_t *notmuch)
{
- /* 16 bytes (+ terminator) for hexadecimal representation of
- * a 64-bit integer. */
- static char thread_id[17];
- Xapian::WritableDatabase *db;
-
- db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
notmuch->last_thread_id++;
- sprintf (thread_id, "%016" PRIx64, notmuch->last_thread_id);
+ sprintf (notmuch->thread_id_str, "%016" PRIx64, notmuch->last_thread_id);
- db->set_metadata ("last_thread_id", thread_id);
+ notmuch->writable_xapian_db->set_metadata ("last_thread_id", notmuch->thread_id_str);
- return thread_id;
+ return notmuch->thread_id_str;
}
static char *
* can return the thread ID stored in the metadata. Otherwise, we
* generate a new thread ID and store it there.
*/
- db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
+ db = notmuch->writable_xapian_db;
metadata_key = _get_metadata_thread_id_key (ctx, message_id);
thread_id_string = notmuch->xapian_db->get_metadata (metadata_key);
- if (thread_id_string.empty()) {
+ if (thread_id_string.empty ()) {
*thread_id_ret = talloc_strdup (ctx,
_notmuch_database_generate_thread_id (notmuch));
db->set_metadata (metadata_key, *thread_id_ret);
} else {
- *thread_id_ret = talloc_strdup (ctx, thread_id_string.c_str());
+ *thread_id_ret = talloc_strdup (ctx, thread_id_string.c_str ());
}
talloc_free (metadata_key);
_notmuch_database_find_doc_ids (notmuch, "thread", loser_thread_id, &loser, &loser_end);
- for ( ; loser != loser_end; loser++) {
+ for (; loser != loser_end; loser++) {
message = _notmuch_message_create (notmuch, notmuch,
*loser, &private_status);
if (message == NULL) {
talloc_free (ptr);
}
-static notmuch_status_t
+notmuch_status_t
_notmuch_database_link_message_to_parents (notmuch_database_t *notmuch,
notmuch_message_t *message,
notmuch_message_file_t *message_file,
const char **thread_id)
{
GHashTable *parents = NULL;
- const char *refs, *in_reply_to, *in_reply_to_message_id;
+ const char *refs, *in_reply_to, *in_reply_to_message_id, *strict_message_id = NULL;
const char *last_ref_message_id, *this_message_id;
GList *l, *keys = NULL;
notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
parents, refs);
in_reply_to = _notmuch_message_file_get_header (message_file, "in-reply-to");
+ if (in_reply_to)
+ strict_message_id = _notmuch_message_id_parse_strict (message,
+ in_reply_to);
+
in_reply_to_message_id = parse_references (message,
this_message_id,
parents, in_reply_to);
- /* For the parent of this message, use the last message ID of the
- * References header, if available. If not, fall back to the
- * first message ID in the In-Reply-To header. */
- if (last_ref_message_id) {
+ /* For the parent of this message, use
+ * 1) the In-Reply-To header, if it looks sane, otherwise
+ * 2) the last message ID of the References header, if available.
+ * 3) Otherwise, fall back to the first message ID in
+ * the In-Reply-To header.
+ */
+
+ if (strict_message_id) {
+ _notmuch_message_add_term (message, "replyto", strict_message_id);
+ } else if (last_ref_message_id) {
_notmuch_message_add_term (message, "replyto",
last_ref_message_id);
} else if (in_reply_to_message_id) {
_notmuch_message_add_term (message, "replyto",
- in_reply_to_message_id);
+ in_reply_to_message_id);
}
keys = g_hash_table_get_keys (parents);
_notmuch_database_find_doc_ids (notmuch, "reference", message_id, &child, &children_end);
- for ( ; child != children_end; child++) {
+ for (; child != children_end; child++) {
child_message = _notmuch_message_create (message, notmuch,
*child, &private_status);
if (stored_id.empty ()) {
return NULL;
} else {
- Xapian::WritableDatabase *db;
-
- db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
-
/* Clear the metadata for this message ID. We don't need it
* anymore. */
- db->set_metadata (metadata_key, "");
+ notmuch->writable_xapian_db->set_metadata (metadata_key, "");
return talloc_strdup (ctx, stored_id.c_str ());
}
_notmuch_database_link_message (notmuch_database_t *notmuch,
notmuch_message_t *message,
notmuch_message_file_t *message_file,
- notmuch_bool_t is_ghost)
+ bool is_ghost,
+ bool is_new)
{
void *local = talloc_new (NULL);
notmuch_status_t status;
const char *thread_id = NULL;
/* Check if the message already had a thread ID */
- if (notmuch->features & NOTMUCH_FEATURE_GHOSTS) {
+ if (! is_new) {
+ thread_id = notmuch_message_get_thread_id (message);
+ } else if (notmuch->features & NOTMUCH_FEATURE_GHOSTS) {
if (is_ghost)
thread_id = notmuch_message_get_thread_id (message);
} else {
_notmuch_message_add_term (message, "thread", thread_id);
}
- DONE:
+ DONE:
talloc_free (local);
return status;
}
notmuch_status_t
-notmuch_database_add_message (notmuch_database_t *notmuch,
- const char *filename,
- notmuch_message_t **message_ret)
+notmuch_database_index_file (notmuch_database_t *notmuch,
+ const char *filename,
+ notmuch_indexopts_t *indexopts,
+ notmuch_message_t **message_ret)
{
notmuch_message_file_t *message_file;
notmuch_message_t *message = NULL;
notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS, ret2;
notmuch_private_status_t private_status;
- notmuch_bool_t is_ghost = FALSE, is_new = FALSE;
+ notmuch_bool_t is_ghost = false, is_new = false;
+ notmuch_indexopts_t *def_indexopts = NULL;
- const char *date, *header;
+ const char *date;
const char *from, *to, *subject;
char *message_id = NULL;
if (ret)
goto DONE;
- /* Parse message up front to get better error status. */
- ret = _notmuch_message_file_parse (message_file);
+ ret = _notmuch_message_file_get_headers (message_file,
+ &from, &subject, &to, &date,
+ &message_id);
if (ret)
goto DONE;
- /* Before we do any real work, (especially before doing a
- * potential SHA-1 computation on the entire file's contents),
- * let's make sure that what we're looking at looks like an
- * actual email message.
- */
- from = _notmuch_message_file_get_header (message_file, "from");
- subject = _notmuch_message_file_get_header (message_file, "subject");
- to = _notmuch_message_file_get_header (message_file, "to");
-
- if ((from == NULL || *from == '\0') &&
- (subject == NULL || *subject == '\0') &&
- (to == NULL || *to == '\0')) {
- ret = NOTMUCH_STATUS_FILE_NOT_EMAIL;
- goto DONE;
- }
-
- /* Now that we're sure it's mail, the first order of business
- * is to find a message ID (or else create one ourselves).
- */
- header = _notmuch_message_file_get_header (message_file, "message-id");
- 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);
- }
-
- 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);
-
- /* If that failed too, something is really wrong. Give up. */
- if (sha1 == NULL) {
- ret = NOTMUCH_STATUS_FILE_ERROR;
- goto DONE;
- }
-
- message_id = talloc_asprintf (message_file, "notmuch-sha1-%s", sha1);
- free (sha1);
- }
-
try {
/* Now that we have a message ID, we get a message object,
* (which may or may not reference an existing document in the
/* We cannot call notmuch_message_get_flag for a new message */
switch (private_status) {
case NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND:
- is_ghost = FALSE;
- is_new = TRUE;
+ is_ghost = false;
+ is_new = true;
break;
case NOTMUCH_PRIVATE_STATUS_SUCCESS:
- is_ghost = notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_GHOST);
- is_new = FALSE;
+ ret = notmuch_message_get_flag_st (message, NOTMUCH_MESSAGE_FLAG_GHOST, &is_ghost);
+ if (ret)
+ goto DONE;
+ is_new = false;
break;
default:
ret = COERCE_STATUS (private_status,
goto DONE;
}
- _notmuch_message_add_filename (message, filename);
+ ret = _notmuch_message_add_filename (message, filename);
+ if (ret)
+ goto DONE;
if (is_new || is_ghost) {
_notmuch_message_add_term (message, "type", "mail");
if (is_ghost)
/* Convert ghost message to a regular message */
_notmuch_message_remove_term (message, "type", "ghost");
- ret = _notmuch_database_link_message (notmuch, message,
- message_file, is_ghost);
- if (ret)
- goto DONE;
+ }
+
+ ret = _notmuch_database_link_message (notmuch, message,
+ message_file, is_ghost, is_new);
+ if (ret)
+ goto DONE;
- date = _notmuch_message_file_get_header (message_file, "date");
+ if (is_new || is_ghost)
_notmuch_message_set_header_values (message, date, from, subject);
- ret = _notmuch_message_index_file (message, message_file);
- if (ret)
- goto DONE;
- } else {
- ret = NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID;
+ if (! indexopts) {
+ def_indexopts = notmuch_database_get_default_indexopts (notmuch);
+ indexopts = def_indexopts;
}
+ ret = _notmuch_message_index_file (message, indexopts, message_file);
+ if (ret)
+ goto DONE;
+
+ if (! is_new && ! is_ghost)
+ ret = NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID;
+
_notmuch_message_sync (message);
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred adding message: %s.\n",
- error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ error.get_msg ().c_str ());
+ notmuch->exception_reported = true;
ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
goto DONE;
}
DONE:
+ if (def_indexopts)
+ notmuch_indexopts_destroy (def_indexopts);
+
if (message) {
if ((ret == NOTMUCH_STATUS_SUCCESS ||
ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) && message_ret)
return ret;
}
+
+notmuch_status_t
+notmuch_database_add_message (notmuch_database_t *notmuch,
+ const char *filename,
+ notmuch_message_t **message_ret)
+{
+ return notmuch_database_index_file (notmuch, filename,
+ NULL,
+ message_ret);
+
+}
projects / notmuch / blobdiff