From c4d909114fcbc1b5199bdc051781ffa9b406dcb9 Mon Sep 17 00:00:00 2001 From: david Date: Fri, 7 Dec 2012 21:26:42 +2000 Subject: [PATCH] [Patch v3b 4/9] tag-util.[ch]: New files for common tagging routines --- 2f/d9f6d732476fe854aa8add9b173c42c7d8a0ec | 494 ++++++++++++++++++++++ 1 file changed, 494 insertions(+) create mode 100644 2f/d9f6d732476fe854aa8add9b173c42c7d8a0ec diff --git a/2f/d9f6d732476fe854aa8add9b173c42c7d8a0ec b/2f/d9f6d732476fe854aa8add9b173c42c7d8a0ec new file mode 100644 index 000000000..53b02ab9a --- /dev/null +++ b/2f/d9f6d732476fe854aa8add9b173c42c7d8a0ec @@ -0,0 +1,494 @@ +Return-Path: +X-Original-To: notmuch@notmuchmail.org +Delivered-To: notmuch@notmuchmail.org +Received: from localhost (localhost [127.0.0.1]) + by olra.theworths.org (Postfix) with ESMTP id 61BC2431FBD + for ; Thu, 6 Dec 2012 17:27:30 -0800 (PST) +X-Virus-Scanned: Debian amavisd-new at olra.theworths.org +X-Spam-Flag: NO +X-Spam-Score: 0 +X-Spam-Level: +X-Spam-Status: No, score=0 tagged_above=-999 required=5 tests=[none] + autolearn=disabled +Received: from olra.theworths.org ([127.0.0.1]) + by localhost (olra.theworths.org [127.0.0.1]) (amavisd-new, port 10024) + with ESMTP id 7jj86OJjMRhL for ; + Thu, 6 Dec 2012 17:27:27 -0800 (PST) +Received: from tesseract.cs.unb.ca (tesseract.cs.unb.ca [131.202.240.238]) + (using TLSv1 with cipher AES256-SHA (256/256 bits)) + (No client certificate requested) + by olra.theworths.org (Postfix) with ESMTPS id B9B7F429E29 + for ; Thu, 6 Dec 2012 17:27:13 -0800 (PST) +Received: from fctnnbsc30w-142167090129.dhcp-dynamic.fibreop.nb.bellaliant.net + ([142.167.90.129] helo=zancas.localnet) + by tesseract.cs.unb.ca with esmtpsa + (TLS1.0:DHE_RSA_AES_128_CBC_SHA1:16) (Exim 4.72) + (envelope-from ) + id 1Tgmie-0003Nt-Jg; Thu, 06 Dec 2012 21:27:13 -0400 +Received: from bremner by zancas.localnet with local (Exim 4.80) + (envelope-from ) + id 1TgmiZ-0004ka-5f; Thu, 06 Dec 2012 21:27:07 -0400 +From: david@tethera.net +To: notmuch@notmuchmail.org +Subject: [Patch v3b 4/9] tag-util.[ch]: New files for common tagging routines +Date: Thu, 6 Dec 2012 21:26:42 -0400 +Message-Id: <1354843607-17980-5-git-send-email-david@tethera.net> +X-Mailer: git-send-email 1.7.10.4 +In-Reply-To: <1354843607-17980-1-git-send-email-david@tethera.net> +References: <1354843607-17980-1-git-send-email-david@tethera.net> +X-Spam_bar: - +Cc: David Bremner +X-BeenThere: notmuch@notmuchmail.org +X-Mailman-Version: 2.1.13 +Precedence: list +List-Id: "Use and development of the notmuch mail system." + +List-Unsubscribe: , + +List-Archive: +List-Post: +List-Help: +List-Subscribe: , + +X-List-Received-Date: Fri, 07 Dec 2012 01:27:30 -0000 + +From: David Bremner + +These are meant to be shared between notmuch-tag and notmuch-restore. + +The bulk of the routines implement a "tag operation list" abstract +data type act as a structured representation of a set of tag +operations (typically coming from a single tag command or line of +input). +--- + Makefile.local | 1 + + tag-util.c | 278 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + tag-util.h | 119 ++++++++++++++++++++++++ + 3 files changed, 398 insertions(+) + create mode 100644 tag-util.c + create mode 100644 tag-util.h + +diff --git a/Makefile.local b/Makefile.local +index 2b91946..854867d 100644 +--- a/Makefile.local ++++ b/Makefile.local +@@ -274,6 +274,7 @@ notmuch_client_srcs = \ + query-string.c \ + mime-node.c \ + crypto.c \ ++ tag-util.c + + notmuch_client_modules = $(notmuch_client_srcs:.c=.o) + +diff --git a/tag-util.c b/tag-util.c +new file mode 100644 +index 0000000..932ee7f +--- /dev/null ++++ b/tag-util.c +@@ -0,0 +1,278 @@ ++#include ++#include "string-util.h" ++#include "tag-util.h" ++#include "hex-escape.h" ++ ++#define TAG_OP_LIST_INITIAL_SIZE 10 ++ ++struct _tag_operation_t { ++ const char *tag; ++ notmuch_bool_t remove; ++}; ++ ++struct _tag_op_list_t { ++ tag_operation_t *ops; ++ size_t count; ++ size_t size; ++}; ++ ++int ++parse_tag_line (void *ctx, char *line, ++ tag_op_flag_t flags, ++ char **query_string, ++ tag_op_list_t *tag_ops) ++{ ++ char *tok = line; ++ size_t tok_len = 0; ++ char *line_for_error = talloc_strdup (ctx, line); ++ int ret = 0; ++ ++ chomp_newline (line); ++ ++ /* remove leading space */ ++ while (*tok == ' ' || *tok == '\t') ++ tok++; ++ ++ /* Skip empty and comment lines. */ ++ if (*tok == '\0' || *tok == '#') { ++ ret = 1; ++ goto DONE; ++ } ++ ++ tag_op_list_reset (tag_ops); ++ ++ /* Parse tags. */ ++ while ((tok = strtok_len (tok + tok_len, " ", &tok_len)) != NULL) { ++ notmuch_bool_t remove; ++ char *tag; ++ ++ /* Optional explicit end of tags marker. */ ++ if (tok_len == 2 && strncmp (tok, "--", tok_len) == 0) { ++ tok = strtok_len (tok + tok_len, " ", &tok_len); ++ break; ++ } ++ ++ /* Implicit end of tags. */ ++ if (*tok != '-' && *tok != '+') ++ break; ++ ++ /* If tag is terminated by NUL, there's no query string. */ ++ if (*(tok + tok_len) == '\0') { ++ fprintf (stderr, "no query string: %s\n", line_for_error); ++ ret = 1; ++ goto DONE; ++ } ++ ++ /* Terminate, and start next token after terminator. */ ++ *(tok + tok_len++) = '\0'; ++ ++ remove = (*tok == '-'); ++ tag = tok + 1; ++ ++ /* Maybe refuse empty tags. */ ++ if (! (flags & TAG_FLAG_BE_GENEROUS) && *tag == '\0') { ++ fprintf (stderr, "Error: empty tag: %s\n", line_for_error); ++ goto DONE; ++ } ++ ++ /* Decode tag. */ ++ if (hex_decode_inplace (tag) != HEX_SUCCESS) { ++ fprintf (stderr, "Hex decoding of tag %s failed\n", ++ tag); ++ ret = 1; ++ goto DONE; ++ } ++ ++ if (tag_op_list_append (ctx, tag_ops, tag, remove)) { ++ ret = -1; ++ goto DONE; ++ } ++ } ++ ++ if (tok == NULL) { ++ fprintf (stderr, "Warning: Ignoring invalid input line: %s\n", ++ line_for_error); ++ ret = 1; ++ goto DONE; ++ } ++ ++ /* tok now points to the query string */ ++ if (hex_decode_inplace (tok) != HEX_SUCCESS) { ++ fprintf (stderr, "Hex decoding of query %s failed\n", ++ tok); ++ ret = 1; ++ goto DONE; ++ } ++ ++ *query_string = tok; ++ DONE: ++ talloc_free (line_for_error); ++ return ret; ++} ++ ++static inline void ++message_error (notmuch_message_t *message, ++ notmuch_status_t status, ++ const char *format, ...) ++{ ++ va_list va_args; ++ ++ va_start (va_args, format); ++ ++ vfprintf (stderr, format, va_args); ++ fprintf (stderr, "Message-ID: %s\n", notmuch_message_get_message_id (message)); ++ fprintf (stderr, "Status: %s\n", notmuch_status_to_string (status)); ++} ++ ++notmuch_status_t ++tag_op_list_apply (notmuch_message_t *message, ++ tag_op_list_t *list, ++ tag_op_flag_t flags) ++{ ++ size_t i; ++ notmuch_status_t status = 0; ++ tag_operation_t *tag_ops = list->ops; ++ ++ status = notmuch_message_freeze (message); ++ if (status) { ++ message_error (message, status, "freezing message"); ++ return status; ++ } ++ ++ if (flags & TAG_FLAG_REMOVE_ALL) { ++ status = notmuch_message_remove_all_tags (message); ++ if (status) { ++ message_error (message, status, "removing all tags"); ++ return status; ++ } ++ } ++ ++ for (i = 0; i < list->count; i++) { ++ if (tag_ops[i].remove) { ++ status = notmuch_message_remove_tag (message, tag_ops[i].tag); ++ if (status) { ++ message_error (message, status, "removing tag %s", tag_ops[i].tag); ++ return status; ++ } ++ } else { ++ status = notmuch_message_add_tag (message, tag_ops[i].tag); ++ if (status) { ++ message_error (message, status, "adding tag %s", tag_ops[i].tag); ++ return status; ++ } ++ ++ } ++ } ++ ++ status = notmuch_message_thaw (message); ++ if (status) { ++ message_error (message, status, "thawing message"); ++ return status; ++ } ++ ++ ++ if (flags & TAG_FLAG_MAILDIR_SYNC) { ++ status = notmuch_message_tags_to_maildir_flags (message); ++ if (status) { ++ message_error (message, status, "synching tags to maildir"); ++ return status; ++ } ++ } ++ ++ return NOTMUCH_STATUS_SUCCESS; ++ ++} ++ ++ ++/* Array of tagging operations (add or remove. Size will be increased ++ * as necessary. */ ++ ++tag_op_list_t * ++tag_op_list_create (void *ctx) ++{ ++ tag_op_list_t *list; ++ ++ list = talloc (ctx, tag_op_list_t); ++ if (list == NULL) ++ return NULL; ++ ++ list->size = TAG_OP_LIST_INITIAL_SIZE; ++ list->count = 0; ++ ++ list->ops = talloc_array (ctx, tag_operation_t, list->size); ++ if (list->ops == NULL) ++ return NULL; ++ ++ return list; ++} ++ ++ ++int ++tag_op_list_append (void *ctx, ++ tag_op_list_t *list, ++ const char *tag, ++ notmuch_bool_t remove) ++{ ++ /* Make room if current array is full. This should be a fairly ++ * rare case, considering the initial array size. ++ */ ++ ++ if (list->count == list->size) { ++ list->size *= 2; ++ list->ops = talloc_realloc (ctx, list->ops, tag_operation_t, ++ list->size); ++ if (list->ops == NULL) { ++ fprintf (stderr, "Out of memory.\n"); ++ return 1; ++ } ++ } ++ ++ /* add the new operation */ ++ ++ list->ops[list->count].tag = tag; ++ list->ops[list->count].remove = remove; ++ list->count++; ++ return 0; ++} ++ ++/* ++ * Is the i'th tag operation a remove? ++ */ ++ ++notmuch_bool_t ++tag_op_list_isremove (const tag_op_list_t *list, size_t i) ++{ ++ assert (i < list->count); ++ return list->ops[i].remove; ++} ++ ++/* ++ * Reset a list to contain no operations ++ */ ++ ++void ++tag_op_list_reset (tag_op_list_t *list) ++{ ++ list->count = 0; ++} ++ ++/* ++ * Return the number of operations in a list ++ */ ++ ++size_t ++tag_op_list_size (const tag_op_list_t *list) ++{ ++ return list->count; ++} ++ ++/* ++ * return the i'th tag in the list ++ */ ++ ++const char * ++tag_op_list_tag (const tag_op_list_t *list, size_t i) ++{ ++ assert (i < list->count); ++ return list->ops[i].tag; ++} +diff --git a/tag-util.h b/tag-util.h +new file mode 100644 +index 0000000..df05d72 +--- /dev/null ++++ b/tag-util.h +@@ -0,0 +1,119 @@ ++#ifndef _TAG_UTIL_H ++#define _TAG_UTIL_H ++ ++#include "notmuch-client.h" ++ ++typedef struct _tag_operation_t tag_operation_t; ++typedef struct _tag_op_list_t tag_op_list_t; ++ ++/* Use powers of 2 */ ++typedef enum { ++ TAG_FLAG_NONE = 0, ++ ++ /* Operations are synced to maildir, if possible. ++ */ ++ TAG_FLAG_MAILDIR_SYNC = (1 << 0), ++ ++ /* Remove all tags from message before applying list. ++ */ ++ TAG_FLAG_REMOVE_ALL = (1 << 1), ++ ++ /* Don't try to avoid database operations. Useful when we ++ * know that message passed needs these operations. ++ */ ++ TAG_FLAG_PRE_OPTIMIZED = (1 << 2), ++ ++ /* Accept strange tags that might be user error; ++ * intended for use by notmuch-restore. ++ */ ++ TAG_FLAG_BE_GENEROUS = (1 << 3) ++ ++} tag_op_flag_t; ++ ++/* Parse a string of the following format: ++ * ++ * +|- [...] [--] ++ * ++ * Each line is interpreted similarly to "notmuch tag" command line ++ * arguments. The delimiter is one or more spaces ' '. Any characters ++ * in and MAY be hex encoded with %NN where NN is ++ * the hexadecimal value of the character. Any ' ' and '%' characters ++ * in and MUST be hex encoded (using %20 and %25, ++ * respectively). Any characters that are not part of or ++ * MUST NOT be hex encoded. ++ * ++ * Leading and trailing space ' ' is ignored. Empty lines and lines ++ * beginning with '#' are ignored. ++ * ++ * Returns: 0 for OK, 1 for skipped line, -1 for fatal(ish) error. ++ * ++ * Output Parameters: ++ * ops contains a list of tag operations ++ * query_str the search terms. ++ */ ++int ++parse_tag_line (void *ctx, char *line, ++ tag_op_flag_t flags, ++ char **query_str, tag_op_list_t *ops); ++ ++/* ++ * Create an empty list of tag operations ++ * ++ * ctx is passed to talloc ++ */ ++ ++tag_op_list_t ++*tag_op_list_create (void *ctx); ++ ++/* ++ * Add a tag operation (delete iff remove == TRUE) to a list. ++ * The list is expanded as necessary. ++ */ ++ ++int ++tag_op_list_append (void *ctx, ++ tag_op_list_t *list, ++ const char *tag, ++ notmuch_bool_t remove); ++ ++/* ++ * Apply a list of tag operations, in order, to a given message. ++ * ++ * Flags can be bitwise ORed; see enum above for possibilies. ++ */ ++ ++notmuch_status_t ++tag_op_list_apply (notmuch_message_t *message, ++ tag_op_list_t *tag_ops, ++ tag_op_flag_t flags); ++ ++/* ++ * Return the number of operations in a list ++ */ ++ ++size_t ++tag_op_list_size (const tag_op_list_t *list); ++ ++/* ++ * Reset a list to contain no operations ++ */ ++ ++void ++tag_op_list_reset (tag_op_list_t *list); ++ ++ ++ /* ++ * return the i'th tag in the list ++ */ ++ ++const char * ++tag_op_list_tag (const tag_op_list_t *list, size_t i); ++ ++/* ++ * Is the i'th tag operation a remove? ++ */ ++ ++notmuch_bool_t ++tag_op_list_isremove (const tag_op_list_t *list, size_t i); ++ ++#endif +-- +1.7.10.4 + -- 2.26.2