camel/camel-folder-search.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  *  Copyright (C) 2000-2003 Ximian Inc.
   4  *
   5  *  Authors: Michael Zucchi <notzed@ximian.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of version 2 of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 /* This is a helper class for folders to implement the search function.
  23    It implements enough to do basic searches on folders that can provide
  24    an in-memory summary and a body index. */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #include <sys/types.h>
  34 #include <regex.h>
  35
  36 #include <glib.h>
  37
  38 #include "libedataserver/e-memory.h"
  39
  40 #include "camel-folder-search.h"
  41 #include "camel-folder-thread.h"
  42
  43 #include "camel-exception.h"
  44 #include "camel-medium.h"
  45 #include "camel-multipart.h"
  46 #include "camel-mime-message.h"
  47 #include "camel-stream-mem.h"
  48 #include "camel-search-private.h"
  49 #include "camel-i18n.h"
  50
  51 #define d(x)
  52 #define r(x)
  53
  54 struct _CamelFolderSearchPrivate {
  55         GHashTable *mempool_hash;
  56         CamelException *ex;
  57
  58         CamelFolderThread *threads;
  59         GHashTable *threads_hash;
  60 };
  61
  62 #define _PRIVATE(o) (((CamelFolderSearch *)(o))->priv)
  63
  64 static ESExpResult *search_not(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search);
  65
  66 static ESExpResult *search_header_contains(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search);
  67 static ESExpResult *search_header_matches(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search);
  68 static ESExpResult *search_header_starts_with(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search);
  69 static ESExpResult *search_header_ends_with(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search);
  70 static ESExpResult *search_header_exists(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search);
  71 static ESExpResult *search_match_all(struct _ESExp *f, int argc, struct _ESExpTerm **argv, CamelFolderSearch *search);
  72 static ESExpResult *search_match_threads(struct _ESExp *f, int argc, struct _ESExpTerm **argv, CamelFolderSearch *s);
  73 static ESExpResult *search_body_contains(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search);
  74 static ESExpResult *search_user_flag(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s);
  75 static ESExpResult *search_user_tag(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s);
  76 static ESExpResult *search_system_flag(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s);
  77 static ESExpResult *search_get_sent_date(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s);
  78 static ESExpResult *search_get_received_date(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s);
  79 static ESExpResult *search_get_current_date(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s);
  80 static ESExpResult *search_get_size(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s);
  81 static ESExpResult *search_uid(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s);
  82
  83 static ESExpResult *search_dummy(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search);
  84
  85 static void camel_folder_search_class_init (CamelFolderSearchClass *klass);
  86 static void camel_folder_search_init       (CamelFolderSearch *obj);
  87 static void camel_folder_search_finalize   (CamelObject *obj);
  88
  89 static CamelObjectClass *camel_folder_search_parent;
  90
  91 static void
  92 camel_folder_search_class_init (CamelFolderSearchClass *klass)
  93 {
  94         camel_folder_search_parent = camel_type_get_global_classfuncs (camel_object_get_type ());
  95
  96         klass->not = search_not;
  97
  98         klass->match_all = search_match_all;
  99         klass->match_threads = search_match_threads;
 100         klass->body_contains = search_body_contains;
 101         klass->header_contains = search_header_contains;
 102         klass->header_matches = search_header_matches;
 103         klass->header_starts_with = search_header_starts_with;
 104         klass->header_ends_with = search_header_ends_with;
 105         klass->header_exists = search_header_exists;
 106         klass->user_tag = search_user_tag;
 107         klass->user_flag = search_user_flag;
 108         klass->system_flag = search_system_flag;
 109         klass->get_sent_date = search_get_sent_date;
 110         klass->get_received_date = search_get_received_date;
 111         klass->get_current_date = search_get_current_date;
 112         klass->get_size = search_get_size;
 113         klass->uid = search_uid;
 114 }
 115
 116 static void
 117 camel_folder_search_init (CamelFolderSearch *obj)
 118 {
 119         struct _CamelFolderSearchPrivate *p;
 120
 121         p = _PRIVATE(obj) = g_malloc0(sizeof(*p));
 122
 123         obj->sexp = e_sexp_new();
 124
 125         /* use a hash of mempools to associate the returned uid lists with
 126            the backing mempool.  yes pretty weird, but i didn't want to change
 127            the api just yet */
 128
 129         p->mempool_hash = g_hash_table_new(0, 0);
 130 }
 131
 132 static void
 133 free_mempool(void *key, void *value, void *data)
 134 {
 135         GPtrArray *uids = key;
 136         EMemPool *pool = value;
 137
 138         g_warning("Search closed with outstanding result unfreed: %p", uids);
 139
 140         g_ptr_array_free(uids, TRUE);
 141         e_mempool_destroy(pool);
 142 }
 143
 144 static void
 145 camel_folder_search_finalize (CamelObject *obj)
 146 {
 147         CamelFolderSearch *search = (CamelFolderSearch *)obj;
 148         struct _CamelFolderSearchPrivate *p = _PRIVATE(obj);
 149
 150         if (search->sexp)
 151                 e_sexp_unref(search->sexp);
 152         if (search->summary_hash)
 153                 g_hash_table_destroy(search->summary_hash);
 154
 155         g_free(search->last_search);
 156         g_hash_table_foreach(p->mempool_hash, free_mempool, obj);
 157         g_hash_table_destroy(p->mempool_hash);
 158         g_free(p);
 159 }
 160
 161 CamelType
 162 camel_folder_search_get_type (void)
 163 {
 164         static CamelType type = CAMEL_INVALID_TYPE;
 165
 166         if (type == CAMEL_INVALID_TYPE) {
 167                 type = camel_type_register (camel_object_get_type (), "CamelFolderSearch",
 168                                             sizeof (CamelFolderSearch),
 169                                             sizeof (CamelFolderSearchClass),
 170                                             (CamelObjectClassInitFunc) camel_folder_search_class_init,
 171                                             NULL,
 172                                             (CamelObjectInitFunc) camel_folder_search_init,
 173                                             (CamelObjectFinalizeFunc) camel_folder_search_finalize);
 174         }
 175
 176         return type;
 177 }
 178
 179 #ifdef offsetof
 180 #define CAMEL_STRUCT_OFFSET(type, field)        ((gint) offsetof (type, field))
 181 #else
 182 #define CAMEL_STRUCT_OFFSET(type, field)        ((gint) ((gchar*) &((type *) 0)->field))
 183 #endif
 184
 185 struct {
 186         char *name;
 187         int offset;
 188         int flags;              /* 0x02 = immediate, 0x01 = always enter */
 189 } builtins[] = {
 190         /* these have default implementations in e-sexp */
 191         { "and", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, and), 2 },
 192         { "or", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, or), 2 },
 193         /* we need to override this one though to implement an 'array not' */
 194         { "not", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, not), 0 },
 195         { "<", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, lt), 2 },
 196         { ">", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, gt), 2 },
 197         { "=", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, eq), 2 },
 198
 199         /* these we have to use our own default if there is none */
 200         /* they should all be defined in the language? so it parses, or should they not?? */
 201         { "match-all", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, match_all), 3 },
 202         { "match-threads", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, match_threads), 3 },
 203         { "body-contains", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, body_contains), 1 },
 204         { "header-contains", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, header_contains), 1 },
 205         { "header-matches", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, header_matches), 1 },
 206         { "header-starts-with", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, header_starts_with), 1 },
 207         { "header-ends-with", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, header_ends_with), 1 },
 208         { "header-exists", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, header_exists), 1 },
 209         { "user-tag", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, user_tag), 1 },
 210         { "user-flag", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, user_flag), 1 },
 211         { "system-flag", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, system_flag), 1 },
 212         { "get-sent-date", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, get_sent_date), 1 },
 213         { "get-received-date", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, get_received_date), 1 },
 214         { "get-current-date", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, get_current_date), 1 },
 215         { "get-size", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, get_size), 1 },
 216         { "uid", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, uid), 1 },
 217 };
 218
 219 void
 220 camel_folder_search_construct (CamelFolderSearch *search)
 221 {
 222         int i;
 223         CamelFolderSearchClass *klass = (CamelFolderSearchClass *)CAMEL_OBJECT_GET_CLASS(search);
 224
 225         for (i=0;i<sizeof(builtins)/sizeof(builtins[0]);i++) {
 226                 void *func;
 227                 /* c is sure messy sometimes */
 228                 func = *((void **)(((char *)klass)+builtins[i].offset));
 229                 if (func == NULL && builtins[i].flags&1) {
 230                         g_warning("Search class doesn't implement '%s' method: %s", builtins[i].name, camel_type_to_name(CAMEL_OBJECT_GET_CLASS(search)));
 231                         func = (void *)search_dummy;
 232                 }
 233                 if (func != NULL) {
 234                         if (builtins[i].flags&2) {
 235                                 e_sexp_add_ifunction(search->sexp, 0, builtins[i].name, (ESExpIFunc *)func, search);
 236                         } else {
 237                                 e_sexp_add_function(search->sexp, 0, builtins[i].name, (ESExpFunc *)func, search);
 238                         }
 239                 }
 240         }
 241 }
 242
 243 /**
 244  * camel_folder_search_new:
 245  *
 246  * Create a new CamelFolderSearch object.
 247  *
 248  * A CamelFolderSearch is a subclassable, extensible s-exp
 249  * evaluator which enforces a particular set of s-expressions.
 250  * Particular methods may be overriden by an implementation to
 251  * implement a search for any sort of backend.
 252  *
 253  * Return value: A new CamelFolderSearch widget.
 254  **/
 255 CamelFolderSearch *
 256 camel_folder_search_new (void)
 257 {
 258         CamelFolderSearch *new = CAMEL_FOLDER_SEARCH (camel_object_new (camel_folder_search_get_type ()));
 259
 260         camel_folder_search_construct(new);
 261         return new;
 262 }
 263
 264 /**
 265  * camel_folder_search_set_folder:
 266  * @search:
 267  * @folder: A folder.
 268  *
 269  * Set the folder attribute of the search.  This is currently unused, but
 270  * could be used to perform a slow-search when indexes and so forth are not
 271  * available.  Or for use by subclasses.
 272  **/
 273 void
 274 camel_folder_search_set_folder(CamelFolderSearch *search, CamelFolder *folder)
 275 {
 276         search->folder = folder;
 277 }
 278
 279 /**
 280  * camel_folder_search_set_summary:
 281  * @search:
 282  * @summary: An array of CamelMessageInfo pointers.
 283  *
 284  * Set the array of summary objects representing the span of the search.
 285  *
 286  * If this is not set, then a subclass must provide the functions
 287  * for searching headers and for the match-all operator.
 288  **/
 289 void
 290 camel_folder_search_set_summary(CamelFolderSearch *search, GPtrArray *summary)
 291 {
 292         int i;
 293
 294         search->summary = summary;
 295         if (search->summary_hash)
 296                 g_hash_table_destroy(search->summary_hash);
 297         search->summary_hash = g_hash_table_new(g_str_hash, g_str_equal);
 298         for (i=0;i<summary->len;i++)
 299                 g_hash_table_insert(search->summary_hash, (char *)camel_message_info_uid(summary->pdata[i]), summary->pdata[i]);
 300 }
 301
 302 /**
 303  * camel_folder_search_set_body_index:
 304  * @search:
 305  * @index:
 306  *
 307  * Set the index representing the contents of all messages
 308  * in this folder.  If this is not set, then the folder implementation
 309  * should sub-class the CamelFolderSearch and provide its own
 310  * body-contains function.
 311  **/
 312 void
 313 camel_folder_search_set_body_index(CamelFolderSearch *search, CamelIndex *index)
 314 {
 315         if (search->body_index)
 316                 camel_object_unref((CamelObject *)search->body_index);
 317         search->body_index = index;
 318         if (index)
 319                 camel_object_ref((CamelObject *)index);
 320 }
 321
 322 /**
 323  * camel_folder_search_execute_expression:
 324  * @search:
 325  * @expr:
 326  * @ex:
 327  *
 328  * Execute the search expression @expr, returning an array of
 329  * all matches as a GPtrArray of uid's of matching messages.
 330  *
 331  * Note that any settings such as set_body_index(), set_folder(),
 332  * and so on are reset to #NULL once the search has completed.
 333  *
 334  * TODO: The interface should probably return summary items instead
 335  * (since they are much more useful to any client).
 336  *
 337  * Return value: A GPtrArray of strings of all matching messages.
 338  * This must only be freed by camel_folder_search_free_result.
 339  **/
 340 GPtrArray *
 341 camel_folder_search_execute_expression(CamelFolderSearch *search, const char *expr, CamelException *ex)
 342 {
 343         ESExpResult *r;
 344         GPtrArray *matches;
 345         int i;
 346         GHashTable *results;
 347         EMemPool *pool;
 348         struct _CamelFolderSearchPrivate *p = _PRIVATE(search);
 349
 350         p->ex = ex;
 351
 352         /* only re-parse if the search has changed */
 353         if (search->last_search == NULL
 354             || strcmp(search->last_search, expr)) {
 355                 e_sexp_input_text(search->sexp, expr, strlen(expr));
 356                 if (e_sexp_parse(search->sexp) == -1) {
 357                         camel_exception_setv(ex, 1, _("Cannot parse search expression: %s:\n%s"), e_sexp_error(search->sexp), expr);
 358                         return NULL;
 359                 }
 360
 361                 g_free(search->last_search);
 362                 search->last_search = g_strdup(expr);
 363         }
 364         r = e_sexp_eval(search->sexp);
 365         if (r == NULL) {
 366                 if (!camel_exception_is_set(ex))
 367                         camel_exception_setv(ex, 1, _("Error executing search expression: %s:\n%s"), e_sexp_error(search->sexp), expr);
 368                 return NULL;
 369         }
 370
 371         matches = g_ptr_array_new();
 372
 373         /* now create a folder summary to return?? */
 374         if (r->type == ESEXP_RES_ARRAY_PTR) {
 375                 d(printf("got result ...\n"));
 376                 /* we use a mempool to store the strings, packed in tight as possible, and freed together */
 377                 /* because the strings are often short (like <8 bytes long), we would be wasting appx 50%
 378                    of memory just storing the size tag that malloc assigns us and alignment padding, so this
 379                    gets around that (and is faster to allocate and free as a bonus) */
 380                 pool = e_mempool_new(512, 256, E_MEMPOOL_ALIGN_BYTE);
 381                 if (search->summary) {
 382                         /* reorder result in summary order */
 383                         results = g_hash_table_new(g_str_hash, g_str_equal);
 384                         for (i=0;i<r->value.ptrarray->len;i++) {
 385                                 d(printf("adding match: %s\n", (char *)g_ptr_array_index(r->value.ptrarray, i)));
 386                                 g_hash_table_insert(results, g_ptr_array_index(r->value.ptrarray, i), GINT_TO_POINTER (1));
 387                         }
 388                         for (i=0;i<search->summary->len;i++) {
 389                                 CamelMessageInfo *info = g_ptr_array_index(search->summary, i);
 390                                 char *uid = (char *)camel_message_info_uid(info);
 391                                 if (g_hash_table_lookup(results, uid)) {
 392                                         g_ptr_array_add(matches, e_mempool_strdup(pool, uid));
 393                                 }
 394                         }
 395                         g_hash_table_destroy(results);
 396                 } else {
 397                         for (i=0;i<r->value.ptrarray->len;i++) {
 398                                 d(printf("adding match: %s\n", (char *)g_ptr_array_index(r->value.ptrarray, i)));
 399                                 g_ptr_array_add(matches, e_mempool_strdup(pool, g_ptr_array_index(r->value.ptrarray, i)));
 400                         }
 401                 }
 402                 /* instead of putting the mempool_hash in the structure, we keep the api clean by
 403                    putting a reference to it in a hashtable.  Lets us do some debugging and catch
 404                    unfree'd results as well. */
 405                 g_hash_table_insert(p->mempool_hash, matches, pool);
 406         } else {
 407                 g_warning("Search returned an invalid result type");
 408         }
 409
 410         e_sexp_result_free(search->sexp, r);
 411
 412         if (p->threads)
 413                 camel_folder_thread_messages_unref(p->threads);
 414         if (p->threads_hash)
 415                 g_hash_table_destroy(p->threads_hash);
 416
 417         p->threads = NULL;
 418         p->threads_hash = NULL;
 419         search->folder = NULL;
 420         search->summary = NULL;
 421         search->current = NULL;
 422         search->body_index = NULL;
 423
 424         return matches;
 425 }
 426
 427 /**
 428  * camel_folder_search_search:
 429  * @search:
 430  * @expr:
 431  * @uids: to search against, NULL for all uid's.
 432  * @ex:
 433  *
 434  * Run a search.  Search must have had Folder already set on it, and
 435  * it must implement summaries.
 436  *
 437  * Return value:
 438  **/
 439 GPtrArray *
 440 camel_folder_search_search(CamelFolderSearch *search, const char *expr, GPtrArray *uids, CamelException *ex)
 441 {
 442         ESExpResult *r;
 443         GPtrArray *matches = NULL, *summary_set;
 444         int i;
 445         GHashTable *results;
 446         EMemPool *pool;
 447         struct _CamelFolderSearchPrivate *p = _PRIVATE(search);
 448
 449         g_assert(search->folder);
 450
 451         p->ex = ex;
 452
 453         /* setup our search list, summary_hash only contains those we're interested in */
 454         search->summary = camel_folder_get_summary(search->folder);
 455         search->summary_hash = g_hash_table_new(g_str_hash, g_str_equal);
 456
 457         if (uids) {
 458                 GHashTable *uids_hash = g_hash_table_new(g_str_hash, g_str_equal);
 459
 460                 summary_set = search->summary_set = g_ptr_array_new();
 461                 for (i=0;i<uids->len;i++)
 462                         g_hash_table_insert(uids_hash, uids->pdata[i], uids->pdata[i]);
 463                 for (i=0;i<search->summary->len;i++)
 464                         if (g_hash_table_lookup(uids_hash, camel_message_info_uid(search->summary->pdata[i])))
 465                                 g_ptr_array_add(search->summary_set, search->summary->pdata[i]);
 466         } else {
 467                 summary_set = search->summary;
 468         }
 469
 470         for (i=0;i<summary_set->len;i++)
 471                 g_hash_table_insert(search->summary_hash, (char *)camel_message_info_uid(summary_set->pdata[i]), summary_set->pdata[i]);
 472
 473         /* only re-parse if the search has changed */
 474         if (search->last_search == NULL
 475             || strcmp(search->last_search, expr)) {
 476                 e_sexp_input_text(search->sexp, expr, strlen(expr));
 477                 if (e_sexp_parse(search->sexp) == -1) {
 478                         camel_exception_setv(ex, 1, _("Cannot parse search expression: %s:\n%s"), e_sexp_error(search->sexp), expr);
 479                         goto fail;
 480                 }
 481
 482                 g_free(search->last_search);
 483                 search->last_search = g_strdup(expr);
 484         }
 485         r = e_sexp_eval(search->sexp);
 486         if (r == NULL) {
 487                 if (!camel_exception_is_set(ex))
 488                         camel_exception_setv(ex, 1, _("Error executing search expression: %s:\n%s"), e_sexp_error(search->sexp), expr);
 489                 goto fail;
 490         }
 491
 492         matches = g_ptr_array_new();
 493
 494         /* now create a folder summary to return?? */
 495         if (r->type == ESEXP_RES_ARRAY_PTR) {
 496                 d(printf("got result ...\n"));
 497
 498                 /* we use a mempool to store the strings, packed in tight as possible, and freed together */
 499                 /* because the strings are often short (like <8 bytes long), we would be wasting appx 50%
 500                    of memory just storing the size tag that malloc assigns us and alignment padding, so this
 501                    gets around that (and is faster to allocate and free as a bonus) */
 502                 pool = e_mempool_new(512, 256, E_MEMPOOL_ALIGN_BYTE);
 503                 /* reorder result in summary order */
 504                 results = g_hash_table_new(g_str_hash, g_str_equal);
 505                 for (i=0;i<r->value.ptrarray->len;i++) {
 506                         d(printf("adding match: %s\n", (char *)g_ptr_array_index(r->value.ptrarray, i)));
 507                         g_hash_table_insert(results, g_ptr_array_index(r->value.ptrarray, i), GINT_TO_POINTER (1));
 508                 }
 509
 510                 for (i=0;i<summary_set->len;i++) {
 511                         CamelMessageInfo *info = g_ptr_array_index(summary_set, i);
 512                         char *uid = (char *)camel_message_info_uid(info);
 513                         if (g_hash_table_lookup(results, uid))
 514                                 g_ptr_array_add(matches, e_mempool_strdup(pool, uid));
 515                 }
 516                 g_hash_table_destroy(results);
 517
 518                 /* instead of putting the mempool_hash in the structure, we keep the api clean by
 519                    putting a reference to it in a hashtable.  Lets us do some debugging and catch
 520                    unfree'd results as well. */
 521                 g_hash_table_insert(p->mempool_hash, matches, pool);
 522         } else {
 523                 g_warning("Search returned an invalid result type");
 524         }
 525
 526         e_sexp_result_free(search->sexp, r);
 527 fail:
 528         /* these might be allocated by match-threads */
 529         if (p->threads)
 530                 camel_folder_thread_messages_unref(p->threads);
 531         if (p->threads_hash)
 532                 g_hash_table_destroy(p->threads_hash);
 533         if (search->summary_set)
 534                 g_ptr_array_free(search->summary_set, TRUE);
 535         g_hash_table_destroy(search->summary_hash);
 536         camel_folder_free_summary(search->folder, search->summary);
 537
 538         p->threads = NULL;
 539         p->threads_hash = NULL;
 540         search->folder = NULL;
 541         search->summary = NULL;
 542         search->summary_hash = NULL;
 543         search->summary_set = NULL;
 544         search->current = NULL;
 545         search->body_index = NULL;
 546
 547         return matches;
 548 }
 549
 550 void camel_folder_search_free_result(CamelFolderSearch *search, GPtrArray *result)
 551 {
 552         int i;
 553         struct _CamelFolderSearchPrivate *p = _PRIVATE(search);
 554         EMemPool *pool;
 555
 556         pool = g_hash_table_lookup(p->mempool_hash, result);
 557         if (pool) {
 558                 e_mempool_destroy(pool);
 559                 g_hash_table_remove(p->mempool_hash, result);
 560         } else {
 561                 for (i=0;i<result->len;i++)
 562                         g_free(g_ptr_array_index(result, i));
 563         }
 564         g_ptr_array_free(result, TRUE);
 565 }
 566
 567 /* dummy function, returns false always, or an empty match array */
 568 static ESExpResult *
 569 search_dummy(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 570 {
 571         ESExpResult *r;
 572
 573         if (search->current == NULL) {
 574                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
 575                 r->value.bool = FALSE;
 576         } else {
 577                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
 578                 r->value.ptrarray = g_ptr_array_new();
 579         }
 580
 581         return r;
 582 }
 583
 584 /* impelemnt an 'array not', i.e. everything in the summary, not in the supplied array */
 585 static ESExpResult *
 586 search_not(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 587 {
 588         ESExpResult *r;
 589         int i;
 590
 591         if (argc>0) {
 592                 if (argv[0]->type == ESEXP_RES_ARRAY_PTR) {
 593                         GPtrArray *v = argv[0]->value.ptrarray;
 594                         const char *uid;
 595
 596                         r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
 597                         r->value.ptrarray = g_ptr_array_new();
 598
 599                         /* not against a single message?*/
 600                         if (search->current) {
 601                                 int found = FALSE;
 602
 603                                 uid = camel_message_info_uid(search->current);
 604                                 for (i=0;!found && i<v->len;i++) {
 605                                         if (strcmp(uid, v->pdata[i]) == 0)
 606                                                 found = TRUE;
 607                                 }
 608
 609                                 if (!found)
 610                                         g_ptr_array_add(r->value.ptrarray, (char *)uid);
 611                         } else if (search->summary == NULL) {
 612                                 g_warning("No summary set, 'not' against an array requires a summary");
 613                         } else {
 614                                 /* 'not' against the whole summary */
 615                                 GHashTable *have = g_hash_table_new(g_str_hash, g_str_equal);
 616                                 char **s;
 617                                 CamelMessageInfo **m;
 618
 619                                 s = (char **)v->pdata;
 620                                 for (i=0;i<v->len;i++)
 621                                         g_hash_table_insert(have, s[i], s[i]);
 622
 623                                 v = search->summary_set?search->summary_set:search->summary;
 624                                 m = (CamelMessageInfo **)v->pdata;
 625                                 for (i=0;i<v->len;i++) {
 626                                         char *uid = (char *)camel_message_info_uid(m[i]);
 627
 628                                         if (g_hash_table_lookup(have, uid) == NULL)
 629                                                 g_ptr_array_add(r->value.ptrarray, uid);
 630                                 }
 631                                 g_hash_table_destroy(have);
 632                         }
 633                 } else {
 634                         int res = TRUE;
 635
 636                         if (argv[0]->type == ESEXP_RES_BOOL)
 637                                 res = ! argv[0]->value.bool;
 638
 639                         r = e_sexp_result_new(f, ESEXP_RES_BOOL);
 640                         r->value.bool = res;
 641                 }
 642         } else {
 643                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
 644                 r->value.bool = TRUE;
 645         }
 646
 647         return r;
 648 }
 649
 650 static ESExpResult *
 651 search_match_all(struct _ESExp *f, int argc, struct _ESExpTerm **argv, CamelFolderSearch *search)
 652 {
 653         int i;
 654         ESExpResult *r, *r1;
 655         GPtrArray *v;
 656
 657         if (argc>1) {
 658                 g_warning("match-all only takes a single argument, other arguments ignored");
 659         }
 660
 661         /* we are only matching a single message?  or already inside a match-all? */
 662         if (search->current) {
 663                 d(printf("matching against 1 message: %s\n", camel_message_info_subject(search->current)));
 664
 665                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
 666                 r->value.bool = FALSE;
 667
 668                 if (argc>0) {
 669                         r1 = e_sexp_term_eval(f, argv[0]);
 670                         if (r1->type == ESEXP_RES_BOOL) {
 671                                 r->value.bool = r1->value.bool;
 672                         } else {
 673                                 g_warning("invalid syntax, matches require a single bool result");
 674                                 e_sexp_fatal_error(f, _("(match-all) requires a single bool result"));
 675                         }
 676                         e_sexp_result_free(f, r1);
 677                 } else {
 678                         r->value.bool = TRUE;
 679                 }
 680                 return r;
 681         }
 682
 683         r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
 684         r->value.ptrarray = g_ptr_array_new();
 685
 686         if (search->summary == NULL) {
 687                 /* TODO: make it work - e.g. use the folder and so forth for a slower search */
 688                 g_warning("No summary supplied, match-all doesn't work with no summary");
 689                 g_assert(0);
 690                 return r;
 691         }
 692
 693         v = search->summary_set?search->summary_set:search->summary;
 694         for (i=0;i<v->len;i++) {
 695                 const char *uid;
 696
 697                 search->current = g_ptr_array_index(v, i);
 698                 uid = camel_message_info_uid(search->current);
 699
 700                 if (argc>0) {
 701                         r1 = e_sexp_term_eval(f, argv[0]);
 702                         if (r1->type == ESEXP_RES_BOOL) {
 703                                 if (r1->value.bool)
 704                                         g_ptr_array_add(r->value.ptrarray, (char *)uid);
 705                         } else {
 706                                 g_warning("invalid syntax, matches require a single bool result");
 707                                 e_sexp_fatal_error(f, _("(match-all) requires a single bool result"));
 708                         }
 709                         e_sexp_result_free(f, r1);
 710                 } else {
 711                         g_ptr_array_add(r->value.ptrarray, (char *)uid);
 712                 }
 713         }
 714         search->current = NULL;
 715
 716         return r;
 717 }
 718
 719 static void
 720 fill_thread_table(struct _CamelFolderThreadNode *root, GHashTable *id_hash)
 721 {
 722         while (root) {
 723                 g_hash_table_insert(id_hash, (char *)camel_message_info_uid(root->message), root);
 724                 if (root->child)
 725                         fill_thread_table(root->child, id_hash);
 726                 root = root->next;
 727         }
 728 }
 729
 730 static void
 731 add_thread_results(struct _CamelFolderThreadNode *root, GHashTable *result_hash)
 732 {
 733         while (root) {
 734                 g_hash_table_insert(result_hash, (char *)camel_message_info_uid(root->message), GINT_TO_POINTER (1));
 735                 if (root->child)
 736                         add_thread_results(root->child, result_hash);
 737                 root = root->next;
 738         }
 739 }
 740
 741 static void
 742 add_results(char *uid, void *dummy, GPtrArray *result)
 743 {
 744         g_ptr_array_add(result, uid);
 745 }
 746
 747 static ESExpResult *
 748 search_match_threads(struct _ESExp *f, int argc, struct _ESExpTerm **argv, CamelFolderSearch *search)
 749 {
 750         ESExpResult *r;
 751         struct _CamelFolderSearchPrivate *p = search->priv;
 752         int i, type;
 753         GHashTable *results;
 754
 755         /* not supported in match-all */
 756         if (search->current)
 757                 e_sexp_fatal_error(f, _("(match-threads) not allowed inside match-all"));
 758
 759         if (argc == 0)
 760                 e_sexp_fatal_error(f, _("(match-threads) requires a match type string"));
 761
 762         r = e_sexp_term_eval(f, argv[0]);
 763         if (r->type != ESEXP_RES_STRING)
 764                 e_sexp_fatal_error(f, _("(match-threads) requires a match type string"));
 765
 766         type = 0;
 767         if (!strcmp(r->value.string, "none"))
 768                 type = 0;
 769         else if (!strcmp(r->value.string, "all"))
 770                 type = 1;
 771         else if (!strcmp(r->value.string, "replies"))
 772                 type = 2;
 773         else if (!strcmp(r->value.string, "replies_parents"))
 774                 type = 3;
 775         else if (!strcmp(r->value.string, "single"))
 776                 type = 4;
 777         e_sexp_result_free(f, r);
 778
 779         /* behave as (begin does */
 780         r = NULL;
 781         for (i=1;i<argc;i++) {
 782                 if (r)
 783                         e_sexp_result_free(f, r);
 784                 r = e_sexp_term_eval(f, argv[i]);
 785         }
 786
 787         if (r == NULL || r->type != ESEXP_RES_ARRAY_PTR)
 788                 e_sexp_fatal_error(f, _("(match-threads) expects an array result"));
 789
 790         if (type == 0)
 791                 return r;
 792
 793         if (search->folder == NULL)
 794                 e_sexp_fatal_error(f, _("(match-threads) requires the folder set"));
 795
 796         /* cache this, so we only have to re-calculate once per search at most */
 797         if (p->threads == NULL) {
 798                 p->threads = camel_folder_thread_messages_new(search->folder, NULL, TRUE);
 799                 p->threads_hash = g_hash_table_new(g_str_hash, g_str_equal);
 800
 801                 fill_thread_table(p->threads->tree, p->threads_hash);
 802         }
 803
 804         results = g_hash_table_new(g_str_hash, g_str_equal);
 805         for (i=0;i<r->value.ptrarray->len;i++) {
 806                 struct _CamelFolderThreadNode *node, *scan;
 807
 808                 if (type != 4)
 809                         g_hash_table_insert(results, g_ptr_array_index(r->value.ptrarray, i), GINT_TO_POINTER(1));
 810
 811                 node = g_hash_table_lookup(p->threads_hash, (char *)g_ptr_array_index(r->value.ptrarray, i));
 812                 if (node == NULL) /* this shouldn't happen but why cry over spilt milk */
 813                         continue;
 814
 815                 /* select messages in thread according to search criteria */
 816                 if (type == 4) {
 817                         if (node->child == NULL && node->parent == NULL)
 818                                 g_hash_table_insert(results, (char *)camel_message_info_uid(node->message), GINT_TO_POINTER(1));
 819                 } else {
 820                         if (type == 3) {
 821                                 scan = node;
 822                                 while (scan && scan->parent) {
 823                                         scan = scan->parent;
 824                                         g_hash_table_insert(results, (char *)camel_message_info_uid(scan->message), GINT_TO_POINTER(1));
 825                                 }
 826                         } else if (type == 1) {
 827                                 while (node && node->parent)
 828                                         node = node->parent;
 829                         }
 830                         g_hash_table_insert(results, (char *)camel_message_info_uid(node->message), GINT_TO_POINTER(1));
 831                         if (node->child)
 832                                 add_thread_results(node->child, results);
 833                 }
 834         }
 835         e_sexp_result_free(f, r);
 836
 837         r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
 838         r->value.ptrarray = g_ptr_array_new();
 839
 840         g_hash_table_foreach(results, (GHFunc)add_results, r->value.ptrarray);
 841         g_hash_table_destroy(results);
 842
 843         return r;
 844 }
 845
 846 static ESExpResult *
 847 check_header(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search, camel_search_match_t how)
 848 {
 849         ESExpResult *r;
 850         int truth = FALSE;
 851
 852         r(printf("executing check-header %d\n", how));
 853
 854         /* are we inside a match-all? */
 855         if (search->current && argc>1
 856             && argv[0]->type == ESEXP_RES_STRING) {
 857                 char *headername;
 858                 const char *header = NULL;
 859                 char strbuf[32];
 860                 int i, j;
 861                 camel_search_t type = CAMEL_SEARCH_TYPE_ASIS;
 862                 struct _camel_search_words *words;
 863
 864                 /* only a subset of headers are supported .. */
 865                 headername = argv[0]->value.string;
 866                 if (!g_ascii_strcasecmp(headername, "subject")) {
 867                         header = camel_message_info_subject(search->current);
 868                 } else if (!g_ascii_strcasecmp(headername, "date")) {
 869                         /* FIXME: not a very useful form of the date */
 870                         sprintf(strbuf, "%d", (int)camel_message_info_date_sent(search->current));
 871                         header = strbuf;
 872                 } else if (!g_ascii_strcasecmp(headername, "from")) {
 873                         header = camel_message_info_from(search->current);
 874                         type = CAMEL_SEARCH_TYPE_ADDRESS;
 875                 } else if (!g_ascii_strcasecmp(headername, "to")) {
 876                         header = camel_message_info_to(search->current);
 877                         type = CAMEL_SEARCH_TYPE_ADDRESS;
 878                 } else if (!g_ascii_strcasecmp(headername, "cc")) {
 879                         header = camel_message_info_cc(search->current);
 880                         type = CAMEL_SEARCH_TYPE_ADDRESS;
 881                 } else if (!g_ascii_strcasecmp(headername, "x-camel-mlist")) {
 882                         header = camel_message_info_mlist(search->current);
 883                         type = CAMEL_SEARCH_TYPE_MLIST;
 884                 } else {
 885                         e_sexp_resultv_free(f, argc, argv);
 886                         e_sexp_fatal_error(f, _("Performing query on unknown header: %s"), headername);
 887                 }
 888
 889                 if (header == NULL)
 890                         header = "";
 891
 892                 /* performs an OR of all words */
 893                 for (i=1;i<argc && !truth;i++) {
 894                         if (argv[i]->type == ESEXP_RES_STRING) {
 895                                 if (argv[i]->value.string[0] == 0) {
 896                                         truth = TRUE;
 897                                 } else if (how == CAMEL_SEARCH_MATCH_CONTAINS) {
 898                                         /* doesn't make sense to split words on anything but contains i.e. we can't have an ending match different words */
 899                                         words = camel_search_words_split(argv[i]->value.string);
 900                                         truth = TRUE;
 901                                         for (j=0;j<words->len && truth;j++) {
 902                                                 truth = camel_search_header_match(header, words->words[j]->word, how, type, NULL);
 903                                         }
 904                                         camel_search_words_free(words);
 905                                 } else {
 906                                         truth = camel_search_header_match(header, argv[i]->value.string, how, type, NULL);
 907                                 }
 908                         }
 909                 }
 910         }
 911         /* TODO: else, find all matches */
 912
 913         r = e_sexp_result_new(f, ESEXP_RES_BOOL);
 914         r->value.bool = truth;
 915
 916         return r;
 917 }
 918
 919 static ESExpResult *
 920 search_header_contains(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 921 {
 922         return check_header(f, argc, argv, search, CAMEL_SEARCH_MATCH_CONTAINS);
 923 }
 924
 925 static ESExpResult *
 926 search_header_matches(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 927 {
 928         return check_header(f, argc, argv, search, CAMEL_SEARCH_MATCH_EXACT);
 929 }
 930
 931 static ESExpResult *
 932 search_header_starts_with (struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 933 {
 934         return check_header(f, argc, argv, search, CAMEL_SEARCH_MATCH_STARTS);
 935 }
 936
 937 static ESExpResult *
 938 search_header_ends_with (struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 939 {
 940         return check_header(f, argc, argv, search, CAMEL_SEARCH_MATCH_ENDS);
 941 }
 942
 943 static ESExpResult *
 944 search_header_exists (struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 945 {
 946         ESExpResult *r;
 947
 948         r(printf ("executing header-exists\n"));
 949
 950         if (search->current) {
 951                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
 952                 if (argc == 1 && argv[0]->type == ESEXP_RES_STRING)
 953                         r->value.bool = camel_medium_get_header(CAMEL_MEDIUM(search->current), argv[0]->value.string) != NULL;
 954
 955         } else {
 956                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
 957                 r->value.ptrarray = g_ptr_array_new();
 958         }
 959
 960         return r;
 961 }
 962
 963 /* this is just to OR results together */
 964 struct _glib_sux_donkeys {
 965         int count;
 966         GPtrArray *uids;
 967 };
 968
 969 /* or, store all unique values */
 970 static void
 971 g_lib_sux_htor(char *key, int value, struct _glib_sux_donkeys *fuckup)
 972 {
 973         g_ptr_array_add(fuckup->uids, key);
 974 }
 975
 976 /* and, only store duplicates */
 977 static void
 978 g_lib_sux_htand(char *key, int value, struct _glib_sux_donkeys *fuckup)
 979 {
 980         if (value == fuckup->count)
 981                 g_ptr_array_add(fuckup->uids, key);
 982 }
 983
 984 static int
 985 match_message_index(CamelIndex *idx, const char *uid, const char *match, CamelException *ex)
 986 {
 987         CamelIndexCursor *wc, *nc;
 988         const char *word, *name;
 989         int truth = FALSE;
 990
 991         wc = camel_index_words(idx);
 992         if (wc) {
 993                 while (!truth && (word = camel_index_cursor_next(wc))) {
 994                         if (camel_ustrstrcase(word,match) != NULL) {
 995                                 /* perf: could have the wc cursor return the name cursor */
 996                                 nc = camel_index_find(idx, word);
 997                                 if (nc) {
 998                                         while (!truth && (name = camel_index_cursor_next(nc)))
 999                                                 truth = strcmp(name, uid) == 0;
1000                                         camel_object_unref((CamelObject *)nc);
1001                                 }
1002                         }
1003                 }
1004                 camel_object_unref((CamelObject *)wc);
1005         }
1006
1007         return truth;
1008 }
1009
1010 /*
1011  "one two" "three" "four five"
1012
1013   one and two
1014 or
1015   three
1016 or
1017   four and five
1018 */
1019
1020 /* returns messages which contain all words listed in words */
1021 static GPtrArray *
1022 match_words_index(CamelFolderSearch *search, struct _camel_search_words *words, CamelException *ex)
1023 {
1024         GPtrArray *result = g_ptr_array_new();
1025         GHashTable *ht = g_hash_table_new(g_str_hash, g_str_equal);
1026         struct _glib_sux_donkeys lambdafoo;
1027         CamelIndexCursor *wc, *nc;
1028         const char *word, *name;
1029         CamelMessageInfo *mi;
1030         int i;
1031
1032         /* we can have a maximum of 32 words, as we use it as the AND mask */
1033
1034         wc = camel_index_words(search->body_index);
1035         if (wc) {
1036                 while ((word = camel_index_cursor_next(wc))) {
1037                         for (i=0;i<words->len;i++) {
1038                                 if (camel_ustrstrcase(word, words->words[i]->word) != NULL) {
1039                                         /* perf: could have the wc cursor return the name cursor */
1040                                         nc = camel_index_find(search->body_index, word);
1041                                         if (nc) {
1042                                                 while ((name = camel_index_cursor_next(nc))) {
1043                                                         mi = g_hash_table_lookup(search->summary_hash, name);
1044                                                         if (mi) {
1045                                                                 int mask;
1046                                                                 const char *uid = camel_message_info_uid(mi);
1047
1048                                                                 mask = (GPOINTER_TO_INT(g_hash_table_lookup(ht, uid))) | (1<<i);
1049                                                                 g_hash_table_insert(ht, (char *)uid, GINT_TO_POINTER(mask));
1050                                                         }
1051                                                 }
1052                                                 camel_object_unref((CamelObject *)nc);
1053                                         }
1054                                 }
1055                         }
1056                 }
1057                 camel_object_unref((CamelObject *)wc);
1058
1059                 lambdafoo.uids = result;
1060                 lambdafoo.count = (1<<words->len) - 1;
1061                 g_hash_table_foreach(ht, (GHFunc)g_lib_sux_htand, &lambdafoo);
1062                 g_hash_table_destroy(ht);
1063         }
1064
1065         return result;
1066 }
1067
1068 static gboolean
1069 match_words_1message (CamelDataWrapper *object, struct _camel_search_words *words, guint32 *mask)
1070 {
1071         CamelDataWrapper *containee;
1072         int truth = FALSE;
1073         int parts, i;
1074
1075         containee = camel_medium_get_content_object (CAMEL_MEDIUM (object));
1076
1077         if (containee == NULL)
1078                 return FALSE;
1079
1080         /* using the object types is more accurate than using the mime/types */
1081         if (CAMEL_IS_MULTIPART (containee)) {
1082                 parts = camel_multipart_get_number (CAMEL_MULTIPART (containee));
1083                 for (i = 0; i < parts && truth == FALSE; i++) {
1084                         CamelDataWrapper *part = (CamelDataWrapper *)camel_multipart_get_part (CAMEL_MULTIPART (containee), i);
1085                         if (part)
1086                                 truth = match_words_1message(part, words, mask);
1087                 }
1088         } else if (CAMEL_IS_MIME_MESSAGE (containee)) {
1089                 /* for messages we only look at its contents */
1090                 truth = match_words_1message((CamelDataWrapper *)containee, words, mask);
1091         } else if (camel_content_type_is(CAMEL_DATA_WRAPPER (containee)->mime_type, "text", "*")) {
1092                 /* for all other text parts, we look inside, otherwise we dont care */
1093                 CamelStreamMem *mem = (CamelStreamMem *)camel_stream_mem_new ();
1094
1095                 /* FIXME: The match should be part of a stream op */
1096                 camel_data_wrapper_decode_to_stream (containee, CAMEL_STREAM (mem));
1097                 camel_stream_write (CAMEL_STREAM (mem), "", 1);
1098                 for (i=0;i<words->len;i++) {
1099                         /* FIXME: This is horridly slow, and should use a real search algorithm */
1100                         if (camel_ustrstrcase(mem->buffer->data, words->words[i]->word) != NULL) {
1101                                 *mask |= (1<<i);
1102                                 /* shortcut a match */
1103                                 if (*mask == (1<<(words->len))-1)
1104                                         return TRUE;
1105                         }
1106                 }
1107
1108                 camel_object_unref (mem);
1109         }
1110
1111         return truth;
1112 }
1113
1114 static gboolean
1115 match_words_message(CamelFolder *folder, const char *uid, struct _camel_search_words *words, CamelException *ex)
1116 {
1117         guint32 mask;
1118         CamelMimeMessage *msg;
1119         CamelException x = CAMEL_EXCEPTION_INITIALISER;
1120         int truth;
1121
1122         msg = camel_folder_get_message(folder, uid, &x);
1123         if (msg) {
1124                 mask = 0;
1125                 truth = match_words_1message((CamelDataWrapper *)msg, words, &mask);
1126                 camel_object_unref((CamelObject *)msg);
1127         } else {
1128                 camel_exception_clear(&x);
1129                 truth = FALSE;
1130         }
1131
1132         return truth;
1133 }
1134
1135 static GPtrArray *
1136 match_words_messages(CamelFolderSearch *search, struct _camel_search_words *words, CamelException *ex)
1137 {
1138         int i;
1139         GPtrArray *matches = g_ptr_array_new();
1140
1141         if (search->body_index) {
1142                 GPtrArray *indexed;
1143                 struct _camel_search_words *simple;
1144
1145                 simple = camel_search_words_simple(words);
1146                 indexed = match_words_index(search, simple, ex);
1147                 camel_search_words_free(simple);
1148
1149                 for (i=0;i<indexed->len;i++) {
1150                         const char *uid = g_ptr_array_index(indexed, i);
1151
1152                         if (match_words_message(search->folder, uid, words, ex))
1153                                 g_ptr_array_add(matches, (char *)uid);
1154                 }
1155
1156                 g_ptr_array_free(indexed, TRUE);
1157         } else {
1158                 GPtrArray *v = search->summary_set?search->summary_set:search->summary;
1159
1160                 for (i=0;i<v->len;i++) {
1161                         CamelMessageInfo *info = g_ptr_array_index(v, i);
1162                         const char *uid = camel_message_info_uid(info);
1163
1164                         if (match_words_message(search->folder, uid, words, ex))
1165                                 g_ptr_array_add(matches, (char *)uid);
1166                 }
1167         }
1168
1169         return matches;
1170 }
1171
1172 static ESExpResult *
1173 search_body_contains(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
1174 {
1175         int i, j;
1176         CamelException *ex = search->priv->ex;
1177         struct _camel_search_words *words;
1178         ESExpResult *r;
1179         struct _glib_sux_donkeys lambdafoo;
1180
1181         if (search->current) {
1182                 int truth = FALSE;
1183
1184                 if (argc == 1 && argv[0]->value.string[0] == 0) {
1185                         truth = TRUE;
1186                 } else {
1187                         for (i=0;i<argc && !truth;i++) {
1188                                 if (argv[i]->type == ESEXP_RES_STRING) {
1189                                         words = camel_search_words_split(argv[i]->value.string);
1190                                         truth = TRUE;
1191                                         if ((words->type & CAMEL_SEARCH_WORD_COMPLEX) == 0 && search->body_index) {
1192                                                 for (j=0;j<words->len && truth;j++)
1193                                                         truth = match_message_index(search->body_index, camel_message_info_uid(search->current), words->words[j]->word, ex);
1194                                         } else {
1195                                                 /* TODO: cache current message incase of multiple body search terms */
1196                                                 truth = match_words_message(search->folder, camel_message_info_uid(search->current), words, ex);
1197                                         }
1198                                         camel_search_words_free(words);
1199                                 }
1200                         }
1201                 }
1202                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
1203                 r->value.bool = truth;
1204         } else {
1205                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1206                 r->value.ptrarray = g_ptr_array_new();
1207
1208                 if (argc == 1 && argv[0]->value.string[0] == 0) {
1209                         GPtrArray *v = search->summary_set?search->summary_set:search->summary;
1210
1211                         for (i=0;i<v->len;i++) {
1212                                 CamelMessageInfo *info = g_ptr_array_index(v, i);
1213
1214                                 g_ptr_array_add(r->value.ptrarray, (char *)camel_message_info_uid(info));
1215                         }
1216                 } else {
1217                         GHashTable *ht = g_hash_table_new(g_str_hash, g_str_equal);
1218                         GPtrArray *matches;
1219
1220                         for (i=0;i<argc;i++) {
1221                                 if (argv[i]->type == ESEXP_RES_STRING) {
1222                                         words = camel_search_words_split(argv[i]->value.string);
1223                                         if ((words->type & CAMEL_SEARCH_WORD_COMPLEX) == 0 && search->body_index) {
1224                                                 matches = match_words_index(search, words, ex);
1225                                         } else {
1226                                                 matches = match_words_messages(search, words, ex);
1227                                         }
1228                                         for (j=0;j<matches->len;j++)
1229                                                 g_hash_table_insert(ht, matches->pdata[j], matches->pdata[j]);
1230                                         g_ptr_array_free(matches, TRUE);
1231                                         camel_search_words_free(words);
1232                                 }
1233                         }
1234                         lambdafoo.uids = r->value.ptrarray;
1235                         g_hash_table_foreach(ht, (GHFunc)g_lib_sux_htor, &lambdafoo);
1236                         g_hash_table_destroy(ht);
1237                 }
1238         }
1239
1240         return r;
1241 }
1242
1243 static ESExpResult *
1244 search_user_flag(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
1245 {
1246         ESExpResult *r;
1247         int i;
1248
1249         r(printf("executing user-flag\n"));
1250
1251         /* are we inside a match-all? */
1252         if (search->current) {
1253                 int truth = FALSE;
1254                 /* performs an OR of all words */
1255                 for (i=0;i<argc && !truth;i++) {
1256                         if (argv[i]->type == ESEXP_RES_STRING
1257                             && camel_message_info_user_flag(search->current, argv[i]->value.string)) {
1258                                 truth = TRUE;
1259                                 break;
1260                         }
1261                 }
1262                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
1263                 r->value.bool = truth;
1264         } else {
1265                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1266                 r->value.ptrarray = g_ptr_array_new();
1267         }
1268
1269         return r;
1270 }
1271
1272 static ESExpResult *
1273 search_system_flag (struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
1274 {
1275         ESExpResult *r;
1276
1277         r(printf ("executing system-flag\n"));
1278
1279         if (search->current) {
1280                 gboolean truth = FALSE;
1281
1282                 if (argc == 1)
1283                         truth = camel_system_flag_get (camel_message_info_flags(search->current), argv[0]->value.string);
1284
1285                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
1286                 r->value.bool = truth;
1287         } else {
1288                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1289                 r->value.ptrarray = g_ptr_array_new ();
1290         }
1291
1292         return r;
1293 }
1294
1295 static ESExpResult *
1296 search_user_tag(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
1297 {
1298         const char *value = NULL;
1299         ESExpResult *r;
1300
1301         r(printf("executing user-tag\n"));
1302
1303         if (argc == 1)
1304                 value = camel_message_info_user_tag(search->current, argv[0]->value.string);
1305
1306         r = e_sexp_result_new(f, ESEXP_RES_STRING);
1307         r->value.string = g_strdup (value ? value : "");
1308
1309         return r;
1310 }
1311
1312 static ESExpResult *
1313 search_get_sent_date(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s)
1314 {
1315         ESExpResult *r;
1316
1317         r(printf("executing get-sent-date\n"));
1318
1319         /* are we inside a match-all? */
1320         if (s->current) {
1321                 r = e_sexp_result_new(f, ESEXP_RES_INT);
1322
1323                 r->value.number = camel_message_info_date_sent(s->current);
1324         } else {
1325                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1326                 r->value.ptrarray = g_ptr_array_new ();
1327         }
1328
1329         return r;
1330 }
1331
1332 static ESExpResult *
1333 search_get_received_date(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s)
1334 {
1335         ESExpResult *r;
1336
1337         r(printf("executing get-received-date\n"));
1338
1339         /* are we inside a match-all? */
1340         if (s->current) {
1341                 r = e_sexp_result_new(f, ESEXP_RES_INT);
1342
1343                 r->value.number = camel_message_info_date_received(s->current);
1344         } else {
1345                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1346                 r->value.ptrarray = g_ptr_array_new ();
1347         }
1348
1349         return r;
1350 }
1351
1352 static ESExpResult *
1353 search_get_current_date(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s)
1354 {
1355         ESExpResult *r;
1356
1357         r(printf("executing get-current-date\n"));
1358
1359         r = e_sexp_result_new(f, ESEXP_RES_INT);
1360         r->value.number = time (NULL);
1361         return r;
1362 }
1363
1364 static ESExpResult *
1365 search_get_size (struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s)
1366 {
1367         ESExpResult *r;
1368
1369         r(printf("executing get-size\n"));
1370
1371         /* are we inside a match-all? */
1372         if (s->current) {
1373                 r = e_sexp_result_new (f, ESEXP_RES_INT);
1374                 r->value.number = camel_message_info_size(s->current) / 1024;
1375         } else {
1376                 r = e_sexp_result_new (f, ESEXP_RES_ARRAY_PTR);
1377                 r->value.ptrarray = g_ptr_array_new ();
1378         }
1379
1380         return r;
1381 }
1382
1383 static ESExpResult *
1384 search_uid(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
1385 {
1386         ESExpResult *r;
1387         int i;
1388
1389         r(printf("executing uid\n"));
1390
1391         /* are we inside a match-all? */
1392         if (search->current) {
1393                 int truth = FALSE;
1394                 const char *uid = camel_message_info_uid(search->current);
1395
1396                 /* performs an OR of all words */
1397                 for (i=0;i<argc && !truth;i++) {
1398                         if (argv[i]->type == ESEXP_RES_STRING
1399                             && !strcmp(uid, argv[i]->value.string)) {
1400                                 truth = TRUE;
1401                                 break;
1402                         }
1403                 }
1404                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
1405                 r->value.bool = truth;
1406         } else {
1407                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1408                 r->value.ptrarray = g_ptr_array_new();
1409                 for (i=0;i<argc;i++) {
1410                         if (argv[i]->type == ESEXP_RES_STRING)
1411                                 g_ptr_array_add(r->value.ptrarray, argv[i]->value.string);
1412                 }
1413         }
1414
1415         return r;
1416 }