#include <xapian.h>
-#include <glib.h> /* g_strdup_printf, g_free, GPtrArray, GHashTable */
+#include <glib.h> /* g_free, GPtrArray, GHashTable */
using namespace std;
prefix_t BOOLEAN_PREFIX_INTERNAL[] = {
{ "type", "T" },
- { "thread", "G" },
{ "ref", "XREFERENCE" },
{ "timestamp", "XTIMESTAMP" },
};
prefix_t BOOLEAN_PREFIX_EXTERNAL[] = {
+ { "thread", "G" },
{ "tag", "K" },
{ "id", "Q" }
};
return "Erroneous NULL pointer";
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";
default:
case NOTMUCH_STATUS_LAST_STATUS:
return "Unknown error status value";
}
}
-/* XXX: We should drop this function and convert all callers to call
- * _notmuch_message_add_term instead. */
-static void
-add_term (Xapian::Document doc,
- const char *prefix_name,
- const char *value)
-{
- const char *prefix;
- char *term;
-
- if (value == NULL)
- return;
-
- prefix = _find_prefix (prefix_name);
-
- term = g_strdup_printf ("%s%s", prefix, value);
-
- if (strlen (term) <= NOTMUCH_TERM_MAX)
- doc.add_term (term);
-
- g_free (term);
-}
-
static void
find_doc_ids (notmuch_database_t *notmuch,
const char *prefix_name,
Xapian::PostingIterator i;
char *term;
- term = g_strdup_printf ("%s%s", _find_prefix (prefix_name), value);
+ term = talloc_asprintf (notmuch, "%s%s",
+ _find_prefix (prefix_name), value);
*begin = notmuch->xapian_db->postlist_begin (term);
*end = notmuch->xapian_db->postlist_end (term);
- free (term);
+ talloc_free (term);
}
static notmuch_private_status_t
* 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 allocated string which the caller should free()
- * when done with it.
+ * 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 (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 (end <= s)
return NULL;
- result = strndup (s, end - s + 1);
+ result = talloc_strndup (ctx, s, end - s + 1);
/* Finally, collapse any whitespace that is within the message-id
* itself. */
return result;
}
-/* Parse a References header value, putting a copy of each referenced
- * message-id into 'hash'. */
+/* Parse a References header value, putting a (talloc'ed under 'ctx')
+ * copy of each referenced message-id into 'hash'. */
static void
-parse_references (GHashTable *hash,
+parse_references (void *ctx,
+ GHashTable *hash,
const char *refs)
{
char *ref;
return;
while (*refs) {
- ref = parse_message_id (refs, &refs);
+ ref = parse_message_id (ctx, refs, &refs);
if (ref)
g_hash_table_insert (hash, ref, NULL);
char *
notmuch_database_default_path (void)
{
+ char *path;
+
if (getenv ("NOTMUCH_BASE"))
return strdup (getenv ("NOTMUCH_BASE"));
- return g_strdup_printf ("%s/mail", getenv ("HOME"));
+ if (asprintf (&path, "%s/mail", getenv ("HOME")) == -1) {
+ fprintf (stderr, "Out of memory.\n");
+ return xstrdup("");
+ }
+
+ return path;
}
notmuch_database_t *
goto DONE;
}
- notmuch_path = g_strdup_printf ("%s/%s", path, ".notmuch");
+ notmuch_path = talloc_asprintf (NULL, "%s/%s", path, ".notmuch");
err = mkdir (notmuch_path, 0755);
DONE:
if (notmuch_path)
- free (notmuch_path);
+ talloc_free (notmuch_path);
if (local_path)
free (local_path);
if (path == NULL)
path = local_path = notmuch_database_default_path ();
- notmuch_path = g_strdup_printf ("%s/%s", path, ".notmuch");
+ if (asprintf (¬much_path, "%s/%s", path, ".notmuch") == -1) {
+ notmuch_path = NULL;
+ fprintf (stderr, "Out of memory\n");
+ goto DONE;
+ }
err = stat (notmuch_path, &st);
if (err) {
goto DONE;
}
- xapian_path = g_strdup_printf ("%s/%s", notmuch_path, "xapian");
+ if (asprintf (&xapian_path, "%s/%s", notmuch_path, "xapian") == -1) {
+ xapian_path = NULL;
+ fprintf (stderr, "Out of memory\n");
+ goto DONE;
+ }
notmuch = talloc (NULL, notmuch_database_t);
notmuch->path = talloc_strdup (notmuch, path);
} catch (const Xapian::Error &error) {
fprintf (stderr, "A Xapian exception occurred: %s\n",
error.get_msg().c_str());
+ notmuch = NULL;
}
DONE:
void
notmuch_database_close (notmuch_database_t *notmuch)
{
+ notmuch->xapian_db->flush ();
+
delete notmuch->query_parser;
delete notmuch->xapian_db;
talloc_free (notmuch);
return ret;
}
+static void
+_my_talloc_free_for_g_hash (void *ptr)
+{
+ talloc_free (ptr);
+}
+
static notmuch_status_t
_notmuch_database_link_message_to_parents (notmuch_database_t *notmuch,
notmuch_message_t *message,
notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
parents = g_hash_table_new_full (g_str_hash, g_str_equal,
- free, NULL);
+ _my_talloc_free_for_g_hash, NULL);
refs = notmuch_message_file_get_header (message_file, "references");
- parse_references (parents, refs);
+ parse_references (message, parents, refs);
in_reply_to = notmuch_message_file_get_header (message_file, "in-reply-to");
- parse_references (parents, in_reply_to);
+ parse_references (message, parents, in_reply_to);
keys = g_hash_table_get_keys (parents);
for (l = keys; l; l = l->next) {
notmuch_status_t
notmuch_database_add_message (notmuch_database_t *notmuch,
- const char *filename)
+ const char *filename,
+ notmuch_message_t **message_ret)
{
notmuch_message_file_t *message_file;
notmuch_message_t *message;
const char *from, *to, *subject, *old_filename;
char *message_id;
+ if (message_ret)
+ *message_ret = NULL;
+
message_file = notmuch_message_file_open (filename);
if (message_file == NULL) {
ret = NOTMUCH_STATUS_FILE_ERROR;
header = notmuch_message_file_get_header (message_file, "message-id");
if (header) {
- message_id = parse_message_id (header, NULL);
+ 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 = xstrdup (header);
+ message_id = talloc_strdup (message_file, header);
} else {
/* No message-id at all, let's generate one by taking a
* hash over the file's contents. */
goto DONE;
}
- message_id = g_strdup_printf ("notmuch-sha1-%s", sha1);
+ message_id = talloc_asprintf (message_file,
+ "notmuch-sha1-%s", sha1);
free (sha1);
}
notmuch,
message_id,
&ret);
- free (message_id);
+
+ talloc_free (message_id);
if (message == NULL)
goto DONE;
}
DONE:
- if (message)
- notmuch_message_destroy (message);
+ if (message) {
+ if (ret == NOTMUCH_STATUS_SUCCESS && message_ret)
+ *message_ret = message;
+ else
+ notmuch_message_destroy (message);
+ }
+
if (message_file)
notmuch_message_file_close (message_file);
projects / notmuch / blobdiff