From: david Date: Sun, 18 Nov 2012 19:04:50 +0000 (+2000) Subject: [PATCH 08/16] tag-util.[ch]: New files for common tagging routines X-Git-Url: http://git.tremily.us/gitweb.cgi?a=commitdiff_plain;h=7c6c3b1cf205a0b379c2b6f59c04ee4f368e3dd1;p=notmuch-archives.git [PATCH 08/16] tag-util.[ch]: New files for common tagging routines --- diff --git a/56/ffbae58633faaec6132fb3d06577273e0039f3 b/56/ffbae58633faaec6132fb3d06577273e0039f3 new file mode 100644 index 000000000..10bfefba4 --- /dev/null +++ b/56/ffbae58633faaec6132fb3d06577273e0039f3 @@ -0,0 +1,441 @@ +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 66FDC431FBF + for ; Sun, 18 Nov 2012 11:05:34 -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 zqhzYSnasydp for ; + Sun, 18 Nov 2012 11:05:31 -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 3515F431FAF + for ; Sun, 18 Nov 2012 11:05:19 -0800 (PST) +Received: from fctnnbsc30w-156034089108.dhcp-dynamic.fibreop.nb.bellaliant.net + ([156.34.89.108] 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 1TaABC-000288-2Z; Sun, 18 Nov 2012 15:05:18 -0400 +Received: from bremner by zancas.localnet with local (Exim 4.80) + (envelope-from ) + id 1TaAB6-0001Ij-Hd; Sun, 18 Nov 2012 15:05:12 -0400 +From: david@tethera.net +To: notmuch@notmuchmail.org +Subject: [PATCH 08/16] tag-util.[ch]: New files for common tagging routines +Date: Sun, 18 Nov 2012 15:04:50 -0400 +Message-Id: <1353265498-3839-9-git-send-email-david@tethera.net> +X-Mailer: git-send-email 1.7.10.4 +In-Reply-To: <1353265498-3839-1-git-send-email-david@tethera.net> +References: <1353265498-3839-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: Sun, 18 Nov 2012 19:05:34 -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 | 273 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + tag-util.h | 71 +++++++++++++++ + 3 files changed, 345 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..5329b1f +--- /dev/null ++++ b/tag-util.c +@@ -0,0 +1,273 @@ ++#include "tag-util.h" ++#include "hex-escape.h" ++ ++static char * ++strtok_len (char *s, const char *delim, size_t *len) ++{ ++ /* skip initial delims */ ++ s += strspn (s, delim); ++ ++ /* length of token */ ++ *len = strcspn (s, delim); ++ ++ return *len ? s : NULL; ++} ++ ++/* Tag messages according to 'input', which must consist of lines of ++ * the 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. ++ */ ++int ++parse_tag_line (void *ctx, char *line, ++ char **query_string, ++ tag_op_list_t *tag_ops) ++{ ++ char *tok = line; ++ size_t tok_len = 0; ++ ++ chomp_newline (line); ++ 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 (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') { ++ tok = NULL; ++ break; ++ } ++ ++ /* Terminate, and start next token after terminator. */ ++ *(tok + tok_len++) = '\0'; ++ ++ remove = (*tok == '-'); ++ tag = tok + 1; ++ ++ /* Refuse empty tags. */ ++ if (*tag == '\0') { ++ tok = NULL; ++ break; ++ } ++ ++ /* Decode tag. */ ++ if (hex_decode_inplace (tag) != HEX_SUCCESS) { ++ tok = NULL; ++ break; ++ } ++ ++ if (tag_op_list_append (ctx, tag_ops, tag, remove)) ++ return -1; ++ } ++ ++ if (tok == NULL || tag_ops->count == 0) { ++ /* FIXME: line has been modified! */ ++ fprintf (stderr, "Warning: Ignoring invalid input line: %s\n", ++ line); ++ return 1; ++ } ++ ++ /* tok now points to the query string */ ++ if (hex_decode_inplace (tok) != HEX_SUCCESS) { ++ /* FIXME: line has been modified! */ ++ fprintf (stderr, "Warning: Ignoring invalid input line: %s\n", ++ line); ++ return 1; ++ } ++ ++ *query_string = tok; ++ ++ return 0; ++} ++ ++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) ++{ ++ int 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), terminated with an ++ * empty element. 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) ++{ ++ list->ops[list->count].tag = tag; ++ list->ops[list->count].remove = remove; ++ list->count++; ++ ++ /* Make room for terminating empty element and potential ++ * new tags, if necessary. 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; ++ } ++ } ++ ++ list->ops[list->count].tag = NULL; ++ ++ return 0; ++} ++ ++ ++/* WARNING: modifies it's string argument */ ++ ++int ++tag_op_list_from_string (void *ctx, ++ char *tag_string, ++ notmuch_bool_t remove, ++ tag_op_list_t *tag_ops) ++{ ++ char *tok = tag_string; ++ size_t tok_len = 0; ++ ++ tag_op_list_reset (tag_ops); ++ ++/* Parse tags. */ ++ while ((tok = strtok_len (tok + tok_len, " ", &tok_len)) != NULL) { ++ ++ if (*(tok + tok_len) != '\0') { ++ *(tok + tok_len) = '\0'; ++ tok_len++; ++ } ++ ++ if (tag_op_list_append (ctx, tag_ops, tok, remove)) ++ return -1; ++ } ++ ++ return 0; ++ ++} ++ ++notmuch_bool_t ++tag_op_list_empty (tag_op_list_t *list) ++{ ++ return (list->count == 0); ++} ++ ++ ++void ++tag_op_list_reset (tag_op_list_t *list) ++{ ++ list->count = 0; ++} +diff --git a/tag-util.h b/tag-util.h +new file mode 100644 +index 0000000..b381b8e +--- /dev/null ++++ b/tag-util.h +@@ -0,0 +1,71 @@ ++#ifndef _TAG_UTIL_H ++#define _TAG_UTIL_H ++ ++#include "notmuch-client.h" ++ ++typedef struct { ++ const char *tag; ++ notmuch_bool_t remove; ++} tag_operation_t; ++ ++#define TAG_OP_LIST_INITIAL_SIZE 10 ++ ++typedef struct { ++ tag_operation_t *ops; ++ int count; ++ int size; ++} tag_op_list_t; ++ ++/* Use powers of 2 */ ++typedef enum { TAG_FLAG_NONE = 0, ++ TAG_FLAG_MAILDIR_SYNC = 1, ++ TAG_FLAG_REMOVE_ALL = 2 } tag_op_flag_t; ++ ++ ++typedef int (*tag_callback_t)(void *ctx, ++ notmuch_database_t *notmuch, ++ const char *query_string, ++ tag_op_list_t *tag_ops, ++ tag_op_flag_t flags); ++ ++int ++parse_tag_stream (void *ctx, ++ notmuch_database_t *notmuch, ++ FILE *input, ++ tag_callback_t callback, ++ tag_op_flag_t flags, ++ volatile sig_atomic_t *interrupted); ++ ++/* ++ * Returns: 0 for OK, 1 for skipped line, -1 for fatal(ish) error. ++ */ ++int ++parse_tag_line (void *ctx, char *line, char **query_str, tag_op_list_t *ops); ++ ++tag_op_list_t ++*tag_op_list_create (void *ctx); ++ ++int ++tag_op_list_append (void *ctx, ++ tag_op_list_t *list, ++ const char *tag, ++ notmuch_bool_t remove); ++ ++notmuch_status_t ++tag_op_list_apply (notmuch_message_t *message, ++ tag_op_list_t *tag_ops, ++ tag_op_flag_t flags); ++ ++int ++tag_op_list_from_string (void *ctx, ++ char *tag_string, ++ notmuch_bool_t remove, ++ tag_op_list_t *tag_ops); ++ ++notmuch_bool_t ++tag_op_list_empty (tag_op_list_t *list); ++ ++void ++tag_op_list_reset (tag_op_list_t *list); ++ ++#endif +-- +1.7.10.4 +