From 46e42dcf44573b23812ada87bfe5313cb318662f Mon Sep 17 00:00:00 2001 From: Michael Zucci Date: Thu, 25 Jan 2001 05:10:59 +0000 Subject: Oops. svn path=/trunk/; revision=7801 --- camel/camel-search-private.c | 275 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 camel/camel-search-private.c (limited to 'camel/camel-search-private.c') diff --git a/camel/camel-search-private.c b/camel/camel-search-private.c new file mode 100644 index 0000000000..94c6c1a355 --- /dev/null +++ b/camel/camel-search-private.c @@ -0,0 +1,275 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* + * Authors: Jeffrey Stedfast + * Michael Zucchi + * + * Copyright 2000 Helix Code, Inc. (www.helixcode.com) + * Copyright 2001 Ximian Inc. (www.ximian.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA. + * + */ + +/* (from glibc headers: + POSIX says that must be included (by the caller) before . */ +#include +#include +#include +#include +#include + +#include "camel-exception.h" +#include "camel-mime-message.h" +#include "camel-multipart.h" +#include "camel-stream-mem.h" +#include "e-util/e-sexp.h" + +#include "camel-search-private.h" + +#define d(x) + +/* builds the regex into pattern */ +/* taken from camel-folder-search, with added isregex & exception parameter */ +/* Basically, we build a new regex, either based on subset regex's, or substrings, + that can be executed once over the whoel body, to match anything suitable. + This is more efficient than multiple searches, and probably most (naive) strstr + implementations, over long content. + + A small issue is that case-insenstivity wont work entirely correct for utf8 strings. */ +int +camel_search_build_match_regex(regex_t *pattern, camel_search_flags_t type, int argc, struct _ESExpResult **argv, CamelException *ex) +{ + GString *match = g_string_new(""); + int c, i, count=0, err; + char *word; + int flags; + + /* build a regex pattern we can use to match the words, we OR them together */ + if (argc>1) + g_string_append_c(match, '('); + for (i=0;itype == ESEXP_RES_STRING) { + if (count > 0) + g_string_append_c(match, '|'); + /* escape any special chars (not sure if this list is complete) */ + word = argv[i]->value.string; + if (type & CAMEL_SEARCH_MATCH_REGEX) { + g_string_append(match, word); + } else { + if (type & CAMEL_SEARCH_MATCH_START) + g_string_append_c(match, '^'); + while ((c = *word++)) { + if (strchr("*\\.()[]^$+", c) != NULL) { + g_string_append_c(match, '\\'); + } + g_string_append_c(match, c); + } + if (type & CAMEL_SEARCH_MATCH_END) + g_string_append_c(match, '^'); + } + count++; + } else { + g_warning("Invalid type passed to body-contains match function"); + } + } + if (argc>1) + g_string_append_c(match, ')'); + flags = REG_EXTENDED|REG_NOSUB; + if (type & CAMEL_SEARCH_MATCH_ICASE) + flags |= REG_ICASE; + err = regcomp(pattern, match->str, flags); + if (err != 0) { + /* regerror gets called twice to get the full error string + length to do proper posix error reporting */ + int len = regerror(err, pattern, 0, 0); + char *buffer = g_malloc0(len + 1); + + regerror(err, pattern, buffer, len); + camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, + _("Regular expression compilation failed: %s: %s"), + match->str, buffer); + + regfree(pattern); + } + d(printf("Built regex: '%s'\n", match->str)); + g_string_free(match, TRUE); + return err; +} + +static unsigned char soundex_table[256] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 49, 50, 51, 0, 49, 50, 0, 0, 50, 50, 52, 53, 53, 0, + 49, 50, 54, 50, 51, 0, 49, 0, 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 49, 50, 51, 0, 49, 50, 0, 0, 50, 50, 52, 53, 53, 0, + 49, 50, 54, 50, 51, 0, 49, 0, 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +static void +soundexify (const gchar *sound, gchar code[5]) +{ + guchar *c, last = '\0'; + gint n; + + for (c = (guchar *) sound; *c && !isalpha (*c); c++); + code[0] = toupper (*c); + memset (code + 1, '0', 3); + for (n = 1; *c && n < 5; c++) { + guchar ch = soundex_table[*c]; + + if (ch && ch != last) { + code[n++] = ch; + last = ch; + } + } + code[4] = '\0'; +} + +static gboolean +header_soundex(const char *header, const char *match) +{ + char mcode[5], hcode[5]; + const char *p; + char c; + GString *word; + int truth = FALSE; + + soundexify(match, mcode); + + /* split the header into words, and soundexify and compare each one */ + /* FIXME: Should this convert to utf8, and split based on that, and what not? + soundex only makes sense for us-ascii though ... */ + + word = g_string_new(""); + p = header; + do { + c = *p++; + if (c == 0 || isspace(c)) { + if (word->len > 0) { + soundexify(word->str, hcode); + if (strcmp(hcode, mcode) == 0) + truth = TRUE; + } + g_string_truncate(word, 0); + } else if (isalpha(c)) + g_string_append_c(word, c); + } while (c && !truth); + g_string_free(word, TRUE); + + return truth; +} + +/* searhces for match inside value, if match is mixed case, hten use case-sensitive, + else insensitive */ +gboolean camel_search_header_match(const char *value, const char *match, camel_search_match_t how) +{ + const char *p; + + if (how == CAMEL_SEARCH_MATCH_SOUNDEX) + return header_soundex(value, match); + + while (*value && isspace(*value)) + value++; + + if (strlen(value) < strlen(match)) + return FALSE; + + /* from dan the man, if we have mixed case, perform a case-sensitive match, + otherwise not */ + p = match; + while (*p) { + if (isupper(*p)) { + switch(how) { + case CAMEL_SEARCH_MATCH_EXACT: + return strcmp(value, match) == 0; + case CAMEL_SEARCH_MATCH_CONTAINS: + return strstr(value, match) != NULL; + case CAMEL_SEARCH_MATCH_STARTS: + return strncmp(value, match, strlen(match)) == 0; + case CAMEL_SEARCH_MATCH_ENDS: + return strcmp(value+strlen(value)-strlen(match), match) == 0; + default: + break; + } + return FALSE; + } + p++; + } + switch(how) { + case CAMEL_SEARCH_MATCH_EXACT: + return strcasecmp(value, match) == 0; + case CAMEL_SEARCH_MATCH_CONTAINS: + return e_utf8_strstrcase(value, match) != NULL; + case CAMEL_SEARCH_MATCH_STARTS: + return strncasecmp(value, match, strlen(match)) == 0; + case CAMEL_SEARCH_MATCH_ENDS: + return strcasecmp(value+strlen(value)-strlen(match), match) == 0; + default: + break; + } + + return FALSE; +} + +/* performs a 'slow' content-based match */ +/* there is also an identical copy of this in camel-filter-search.c */ +gboolean +camel_search_message_body_contains(CamelDataWrapper *object, regex_t *pattern) +{ + CamelDataWrapper *containee; + int truth = FALSE; + int parts, i; + + containee = camel_medium_get_content_object(CAMEL_MEDIUM(object)); + + if (containee == NULL) + return FALSE; + + /* TODO: I find it odd that get_part and get_content_object do not + add a reference, probably need fixing for multithreading */ + + /* using the object types is more accurate than using the mime/types */ + if (CAMEL_IS_MULTIPART(containee)) { + parts = camel_multipart_get_number(CAMEL_MULTIPART(containee)); + for (i=0;imime_type, "text", "*")) { + /* for all other text parts, we look inside, otherwise we dont care */ + CamelStreamMem *mem = (CamelStreamMem *)camel_stream_mem_new(); + + camel_data_wrapper_write_to_stream(containee, (CamelStream *)mem); + camel_stream_write((CamelStream *)mem, "", 1); + truth = regexec(pattern, mem->buffer->data, 0, NULL, 0) == 0; + camel_object_unref((CamelObject *)mem); + } + return truth; +} + -- cgit v1.2.3