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