callisto-debian/evolution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New function to do danw's address "is" comparison (as specified in bug

Browse Source 
2001-08-07  Jeffrey Stedfast  <fejj@ximian.com>

	* camel-filter-search.c (address_matches_exactly): New function to
	do danw's address "is" comparison (as specified in bug #5886.
	(check_header): Special-case address-type headers when we are
	doing an exact match to use the address_matches_exactly function.

svn path=/trunk/; revision=11738
This commit is contained in:
Jeffrey Stedfast
2001-08-07 19:55:34 +00:00
committed by Jeffrey Stedfast
parent 299f6f642e
commit a039733f70
3 changed files with 167 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
camel/ChangeLog
View File

@ -1,3 +1,10 @@
2001-08-07 Jeffrey Stedfast <fejj@ximian.com>
* camel-filter-search.c (address_matches_exactly): New function to
do danw's address "is" comparison (as specified in bug #5886.
(check_header): Special-case address-type headers when we are
doing an exact match to use the address_matches_exactly function.
2001-08-06 Jeffrey Stedfast <fejj@ximian.com>
* providers/pop3/camel-pop3-folder.c (pop3_get_message_stream):

132
camel/camel-filter-search.c
View File

@ -104,8 +104,44 @@ static struct {
{ "get-size", (ESExpFunc *) get_size, 0 },
};
static gboolean
address_matches_exactly (const char *header, const char *string)
{
CamelInternetAddress *cia;
GCompareFunc compare;
const char *p;
for (p = string; *p; p++)
if (isupper ((unsigned) *p))
break;
if (*p)
compare = (GCompareFunc) strcmp;
else
compare = (GCompareFunc) g_strcasecmp;
/* the simple case? */
if (!compare (header, string))
return TRUE;
cia = camel_internet_address_new ();
if (camel_address_decode (CAMEL_ADDRESS (cia), header) == 1) {
const char *name, *addr;
camel_internet_address_get (cia, 0, &name, &addr);
if (!compare (name, string))
return TRUE;
if (!compare (addr, string))
return TRUE;
}
camel_object_unref (CAMEL_OBJECT (cia));
return FALSE;
}
static ESExpResult *
check_header(struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessageSearch *fms, camel_search_match_t how)
check_header (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessageSearch *fms, camel_search_match_t how)
{
gboolean matched = FALSE;
ESExpResult *r;
@ -114,24 +150,29 @@ check_header(struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessa
if (argc > 1 && argv[0]->type == ESEXP_RES_STRING) {
char *name = argv[0]->value.string;
const char *header;
if (strcasecmp(name, "x-camel-mlist") == 0)
header = camel_message_info_mlist(fms->info);
if (g_strcasecmp (name, "x-camel-mlist") == 0)
header = camel_message_info_mlist (fms->info);
else
header = camel_medium_get_header (CAMEL_MEDIUM (fms->message), argv[0]->value.string);
if (header) {
for (i=1;i<argc && !matched;i++) {
if (argv[i]->type == ESEXP_RES_STRING
&& camel_search_header_match(header, argv[i]->value.string, how)) {
matched = TRUE;
for (i = 1; i < argc && !matched; i++) {
if (argv[i]->type == ESEXP_RES_STRING) {
if (how == CAMEL_SEARCH_MATCH_EXACT
&& (!g_strcasecmp (name, "To")
|| !g_strcasecmp (name, "Cc")
|| !g_strcasecmp (name, "From")))
matched = address_matches_exactly (header, argv[i]->value.string);
else
matched = camel_search_header_match (header, argv[i]->value.string, how);
break;
}
}
}
}
r = e_sexp_result_new(f, ESEXP_RES_BOOL);
r = e_sexp_result_new (f, ESEXP_RES_BOOL);
r->value.bool = matched;
return r;
@ -140,32 +181,32 @@ check_header(struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessa
static ESExpResult *
header_contains (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessageSearch *fms)
{
return check_header(f, argc, argv, fms, CAMEL_SEARCH_MATCH_CONTAINS);
return check_header (f, argc, argv, fms, CAMEL_SEARCH_MATCH_CONTAINS);
}
static ESExpResult *
header_matches (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessageSearch *fms)
{
return check_header(f, argc, argv, fms, CAMEL_SEARCH_MATCH_EXACT);
return check_header (f, argc, argv, fms, CAMEL_SEARCH_MATCH_EXACT);
}
static ESExpResult *
header_starts_with (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessageSearch *fms)
{
return check_header(f, argc, argv, fms, CAMEL_SEARCH_MATCH_STARTS);
return check_header (f, argc, argv, fms, CAMEL_SEARCH_MATCH_STARTS);
}
static ESExpResult *
header_ends_with (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessageSearch *fms)
{
return check_header(f, argc, argv, fms, CAMEL_SEARCH_MATCH_ENDS);
return check_header (f, argc, argv, fms, CAMEL_SEARCH_MATCH_ENDS);
}
static ESExpResult *
header_soundex (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessageSearch *fms)
{
return check_header(f, argc, argv, fms, CAMEL_SEARCH_MATCH_SOUNDEX);
return check_header (f, argc, argv, fms, CAMEL_SEARCH_MATCH_SOUNDEX);
}
static ESExpResult *
@ -174,13 +215,13 @@ header_exists (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMes
gboolean matched = FALSE;
ESExpResult *r;
int i;
for (i=0;i<argc && !matched;i++) {
for (i = 0; i < argc && !matched; i++) {
if (argv[i]->type == ESEXP_RES_STRING)
matched = camel_medium_get_header (CAMEL_MEDIUM (fms->message), argv[i]->value.string) != NULL;
}
r = e_sexp_result_new(f, ESEXP_RES_BOOL);
r = e_sexp_result_new (f, ESEXP_RES_BOOL);
r->value.bool = matched;
return r;
@ -189,16 +230,17 @@ header_exists (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMes
static ESExpResult *
header_regex (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessageSearch *fms)
{
ESExpResult *r = e_sexp_result_new(f, ESEXP_RES_BOOL);
ESExpResult *r = e_sexp_result_new (f, ESEXP_RES_BOOL);
regex_t pattern;
const char *contents;
if (argc>1
&& argv[0]->type == ESEXP_RES_STRING
if (argc > 1 && argv[0]->type == ESEXP_RES_STRING
&& (contents = camel_medium_get_header (CAMEL_MEDIUM (fms->message), argv[0]->value.string))
&& camel_search_build_match_regex(&pattern, CAMEL_SEARCH_MATCH_REGEX|CAMEL_SEARCH_MATCH_ICASE, argc-1, argv+1, fms->ex) == 0) {
r->value.bool = regexec(&pattern, contents, 0, NULL, 0) == 0;
regfree(&pattern);
&& camel_search_build_match_regex (&pattern, CAMEL_SEARCH_MATCH_REGEX |
CAMEL_SEARCH_MATCH_ICASE, argc-1, argv+1,
fms->ex) == 0) {
r->value.bool = regexec (&pattern, contents, 0, NULL, 0) == 0;
regfree (&pattern);
} else
r->value.bool = FALSE;
@ -215,12 +257,12 @@ get_full_header (CamelMimeMessage *message)
for (h = mp->headers; h; h = h->next) {
if (h->value != NULL) {
g_string_append(str, h->name);
if (isspace(h->value[0]))
g_string_append(str, ":");
g_string_append (str, h->name);
if (isspace (h->value[0]))
g_string_append (str, ":");
else
g_string_append(str, ": ");
g_string_append(str, h->value);
g_string_append (str, ": ");
g_string_append (str, h->value);
}
}
@ -233,15 +275,16 @@ get_full_header (CamelMimeMessage *message)
static ESExpResult *
header_full_regex (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessageSearch *fms)
{
ESExpResult *r = e_sexp_result_new(f, ESEXP_RES_BOOL);
ESExpResult *r = e_sexp_result_new (f, ESEXP_RES_BOOL);
regex_t pattern;
char *contents;
if (camel_search_build_match_regex(&pattern, CAMEL_SEARCH_MATCH_REGEX|CAMEL_SEARCH_MATCH_ICASE, argc-1, argv+1, fms->ex) == 0) {
if (camel_search_build_match_regex (&pattern, CAMEL_SEARCH_MATCH_REGEX |
CAMEL_SEARCH_MATCH_ICASE, argc-1, argv+1, fms->ex) == 0) {
contents = get_full_header (fms->message);
r->value.bool = regexec(&pattern, contents, 0, NULL, 0) == 0;
g_free(contents);
regfree(&pattern);
r->value.bool = regexec (&pattern, contents, 0, NULL, 0) == 0;
g_free (contents);
regfree (&pattern);
} else
r->value.bool = FALSE;
@ -266,12 +309,12 @@ match_all (struct _ESExp *f, int argc, struct _ESExpTerm **argv, FilterMessageSe
static ESExpResult *
body_contains (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessageSearch *fms)
{
ESExpResult *r = e_sexp_result_new(f, ESEXP_RES_BOOL);
ESExpResult *r = e_sexp_result_new (f, ESEXP_RES_BOOL);
regex_t pattern;
if (camel_search_build_match_regex(&pattern, CAMEL_SEARCH_MATCH_ICASE, argc, argv, fms->ex) == 0) {
r->value.bool = camel_search_message_body_contains((CamelDataWrapper *)fms->message, &pattern);
regfree(&pattern);
if (camel_search_build_match_regex (&pattern, CAMEL_SEARCH_MATCH_ICASE, argc, argv, fms->ex) == 0) {
r->value.bool = camel_search_message_body_contains ((CamelDataWrapper *)fms->message, &pattern);
regfree (&pattern);
} else
r->value.bool = FALSE;
@ -283,10 +326,11 @@ body_regex (struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterMessag
{
ESExpResult *r = e_sexp_result_new(f, ESEXP_RES_BOOL);
regex_t pattern;
if (camel_search_build_match_regex(&pattern, CAMEL_SEARCH_MATCH_ICASE|CAMEL_SEARCH_MATCH_REGEX, argc, argv, fms->ex) == 0) {
r->value.bool = camel_search_message_body_contains((CamelDataWrapper *)fms->message, &pattern);
regfree(&pattern);
if (camel_search_build_match_regex (&pattern, CAMEL_SEARCH_MATCH_ICASE |
CAMEL_SEARCH_MATCH_REGEX, argc, argv, fms->ex) == 0) {
r->value.bool = camel_search_message_body_contains ((CamelDataWrapper *)fms->message, &pattern);
regfree (&pattern);
} else
r->value.bool = FALSE;

141
camel/camel-search-private.c
View File

@ -63,58 +63,59 @@ camel_search_build_match_regex (regex_t *pattern, camel_search_flags_t type, int
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;i<argc;i++) {
g_string_append_c (match, '(');
for (i = 0; i < argc; i++) {
if (argv[i]->type == ESEXP_RES_STRING) {
if (count > 0)
g_string_append_c(match, '|');
g_string_append_c (match, '|');
word = argv[i]->value.string;
if (type & CAMEL_SEARCH_MATCH_REGEX) {
/* no need to escape because this should already be a valid regex */
g_string_append(match, word);
g_string_append (match, word);
} else {
/* escape any special chars (not sure if this list is complete) */
if (type & CAMEL_SEARCH_MATCH_START)
g_string_append_c(match, '^');
g_string_append_c (match, '^');
while ((c = *word++)) {
if (strchr("*\\.()[]^$+", c) != NULL) {
g_string_append_c(match, '\\');
if (strchr ("*\\.()[]^$+", c) != NULL) {
g_string_append_c (match, '\\');
}
g_string_append_c(match, c);
g_string_append_c (match, c);
}
if (type & CAMEL_SEARCH_MATCH_END)
g_string_append_c(match, '^');
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, ')');
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);
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);
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);
g_string_free (match, TRUE);
return err;
}
@ -158,36 +159,36 @@ soundexify (const gchar *sound, gchar code[5])
}
static gboolean
header_soundex(const char *header, const char *match)
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);
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 (c == 0 || isspace (c)) {
if (word->len > 0) {
soundexify(word->str, hcode);
if (strcmp(hcode, mcode) == 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);
g_string_truncate (word, 0);
} else if (isalpha (c))
g_string_append_c (word, c);
} while (c && !truth);
g_string_free(word, TRUE);
g_string_free (word, TRUE);
return truth;
}
@ -214,10 +215,10 @@ camel_ustrstrcase (const char *haystack, const char *needle)
g_return_val_if_fail (haystack != NULL, NULL);
g_return_val_if_fail (needle != NULL, NULL);
if (strlen(needle) == 0)
if (strlen (needle) == 0)
return haystack;
if (strlen(haystack) == 0)
if (strlen (haystack) == 0)
return NULL;
puni = nuni = alloca (sizeof (gunichar) * strlen (needle));
@ -342,7 +343,7 @@ camel_search_header_match (const char *value, const char *match, camel_search_ma
{
const char *p;
int vlen, mlen;
while (*value && isspace (*value))
value++;
@ -358,12 +359,12 @@ camel_search_header_match (const char *value, const char *match, camel_search_ma
otherwise not */
p = match;
while (*p) {
if (isupper(*p)) {
switch(how) {
if (isupper (*p)) {
switch (how) {
case CAMEL_SEARCH_MATCH_EXACT:
return strcmp(value, match) == 0;
return strcmp (value, match) == 0;
case CAMEL_SEARCH_MATCH_CONTAINS:
return strstr(value, match) != NULL;
return strstr (value, match) != NULL;
case CAMEL_SEARCH_MATCH_STARTS:
return strncmp (value, match, mlen) == 0;
case CAMEL_SEARCH_MATCH_ENDS:
@ -375,11 +376,12 @@ camel_search_header_match (const char *value, const char *match, camel_search_ma
}
p++;
}
switch(how) {
switch (how) {
case CAMEL_SEARCH_MATCH_EXACT:
return camel_ustrcasecmp(value, match) == 0;
return camel_ustrcasecmp (value, match) == 0;
case CAMEL_SEARCH_MATCH_CONTAINS:
return camel_ustrstrcase(value, match) != NULL;
return camel_ustrstrcase (value, match) != NULL;
case CAMEL_SEARCH_MATCH_STARTS:
return camel_ustrncasecmp (value, match, mlen) == 0;
case CAMEL_SEARCH_MATCH_ENDS:
@ -387,47 +389,48 @@ camel_search_header_match (const char *value, const char *match, camel_search_ma
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)
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));
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;i<parts && truth==FALSE;i++) {
CamelDataWrapper *part = (CamelDataWrapper *)camel_multipart_get_part(CAMEL_MULTIPART(containee), i);
if (CAMEL_IS_MULTIPART (containee)) {
parts = camel_multipart_get_number (CAMEL_MULTIPART (containee));
for (i = 0; i < parts && truth == FALSE; i++) {
CamelDataWrapper *part = (CamelDataWrapper *)camel_multipart_get_part (CAMEL_MULTIPART (containee), i);
if (part)
truth = camel_search_message_body_contains(part, pattern);
truth = camel_search_message_body_contains (part, pattern);
}
} else if (CAMEL_IS_MIME_MESSAGE(containee)) {
} else if (CAMEL_IS_MIME_MESSAGE (containee)) {
/* for messages we only look at its contents */
truth = camel_search_message_body_contains((CamelDataWrapper *)containee, pattern);
} else if (header_content_type_is(CAMEL_DATA_WRAPPER(containee)->mime_type, "text", "*")) {
truth = camel_search_message_body_contains ((CamelDataWrapper *)containee, pattern);
} else if (header_content_type_is(CAMEL_DATA_WRAPPER (containee)->mime_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);
CamelStreamMem *mem = (CamelStreamMem *)camel_stream_mem_new ();
camel_data_wrapper_write_to_stream (containee, CAMEL_STREAM (mem));
camel_stream_write (CAMEL_STREAM (mem), "", 1);
truth = regexec (pattern, mem->buffer->data, 0, NULL, 0) == 0;
camel_object_unref (CAMEL_OBJECT (mem));
}
return truth;
}