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 "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         e_sexp_result_free(f, r);
 776
 777         /* behave as (begin does */
 778         r = NULL;
 779         for (i=1;i<argc;i++) {
 780                 if (r)
 781                         e_sexp_result_free(f, r);
 782                 r = e_sexp_term_eval(f, argv[i]);
 783         }
 784
 785         if (r == NULL || r->type != ESEXP_RES_ARRAY_PTR)
 786                 e_sexp_fatal_error(f, _("(match-threads) expects an array result"));
 787
 788         if (type == 0)
 789                 return r;
 790
 791         if (search->folder == NULL)
 792                 e_sexp_fatal_error(f, _("(match-threads) requires the folder set"));
 793
 794         /* cache this, so we only have to re-calculate once per search at most */
 795         if (p->threads == NULL) {
 796                 p->threads = camel_folder_thread_messages_new(search->folder, NULL, TRUE);
 797                 p->threads_hash = g_hash_table_new(g_str_hash, g_str_equal);
 798
 799                 fill_thread_table(p->threads->tree, p->threads_hash);
 800         }
 801
 802         results = g_hash_table_new(g_str_hash, g_str_equal);
 803         for (i=0;i<r->value.ptrarray->len;i++) {
 804                 d(printf("adding match: %s\n", (char *)g_ptr_array_index(r->value.ptrarray, i)));
 805                 g_hash_table_insert(results, g_ptr_array_index(r->value.ptrarray, i), GINT_TO_POINTER (1));
 806         }
 807
 808         for (i=0;i<r->value.ptrarray->len;i++) {
 809                 struct _CamelFolderThreadNode *node, *scan;
 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 == 3) {
 817                         scan = node;
 818                         while (scan && scan->parent) {
 819                                 scan = scan->parent;
 820                                 g_hash_table_insert(results, (char *)camel_message_info_uid(scan->message), GINT_TO_POINTER(1));
 821                         }
 822                 } else if (type == 1) {
 823                         while (node && node->parent)
 824                                 node = node->parent;
 825                 }
 826                 g_hash_table_insert(results, (char *)camel_message_info_uid(node->message), GINT_TO_POINTER(1));
 827                 if (node->child)
 828                         add_thread_results(node->child, results);
 829         }
 830         e_sexp_result_free(f, r);
 831
 832         r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
 833         r->value.ptrarray = g_ptr_array_new();
 834
 835         g_hash_table_foreach(results, (GHFunc)add_results, r->value.ptrarray);
 836         g_hash_table_destroy(results);
 837
 838         return r;
 839 }
 840
 841 static ESExpResult *
 842 check_header(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search, camel_search_match_t how)
 843 {
 844         ESExpResult *r;
 845         int truth = FALSE;
 846
 847         r(printf("executing check-header %d\n", how));
 848
 849         /* are we inside a match-all? */
 850         if (search->current && argc>1
 851             && argv[0]->type == ESEXP_RES_STRING) {
 852                 char *headername;
 853                 const char *header = NULL;
 854                 char strbuf[32];
 855                 int i, j;
 856                 camel_search_t type = CAMEL_SEARCH_TYPE_ASIS;
 857                 struct _camel_search_words *words;
 858
 859                 /* only a subset of headers are supported .. */
 860                 headername = argv[0]->value.string;
 861                 if (!strcasecmp(headername, "subject")) {
 862                         header = camel_message_info_subject(search->current);
 863                 } else if (!strcasecmp(headername, "date")) {
 864                         /* FIXME: not a very useful form of the date */
 865                         sprintf(strbuf, "%d", (int)camel_message_info_date_sent(search->current));
 866                         header = strbuf;
 867                 } else if (!strcasecmp(headername, "from")) {
 868                         header = camel_message_info_from(search->current);
 869                         type = CAMEL_SEARCH_TYPE_ADDRESS;
 870                 } else if (!strcasecmp(headername, "to")) {
 871                         header = camel_message_info_to(search->current);
 872                         type = CAMEL_SEARCH_TYPE_ADDRESS;
 873                 } else if (!strcasecmp(headername, "cc")) {
 874                         header = camel_message_info_cc(search->current);
 875                         type = CAMEL_SEARCH_TYPE_ADDRESS;
 876                 } else if (!g_ascii_strcasecmp(headername, "x-camel-mlist")) {
 877                         header = camel_message_info_mlist(search->current);
 878                         type = CAMEL_SEARCH_TYPE_MLIST;
 879                 } else {
 880                         e_sexp_resultv_free(f, argc, argv);
 881                         e_sexp_fatal_error(f, _("Performing query on unknown header: %s"), headername);
 882                 }
 883
 884                 if (header) {
 885                         /* performs an OR of all words */
 886                         for (i=1;i<argc && !truth;i++) {
 887                                 if (argv[i]->type == ESEXP_RES_STRING) {
 888                                         if (argv[i]->value.string[0] == 0) {
 889                                                 truth = TRUE;
 890                                         } else if (how == CAMEL_SEARCH_MATCH_CONTAINS) {
 891                                                 /* doesn't make sense to split words on anything but contains i.e. we can't have an ending match different words */
 892                                                 words = camel_search_words_split(argv[i]->value.string);
 893                                                 truth = TRUE;
 894                                                 for (j=0;j<words->len && truth;j++) {
 895                                                         truth = camel_search_header_match(header, words->words[j]->word, how, type, NULL);
 896                                                 }
 897                                                 camel_search_words_free(words);
 898                                         } else {
 899                                                 truth = camel_search_header_match(header, argv[i]->value.string, how, type, NULL);
 900                                         }
 901                                 }
 902                         }
 903                 }
 904         }
 905         /* TODO: else, find all matches */
 906
 907         r = e_sexp_result_new(f, ESEXP_RES_BOOL);
 908         r->value.bool = truth;
 909
 910         return r;
 911 }
 912
 913 static ESExpResult *
 914 search_header_contains(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 915 {
 916         return check_header(f, argc, argv, search, CAMEL_SEARCH_MATCH_CONTAINS);
 917 }
 918
 919 static ESExpResult *
 920 search_header_matches(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 921 {
 922         return check_header(f, argc, argv, search, CAMEL_SEARCH_MATCH_EXACT);
 923 }
 924
 925 static ESExpResult *
 926 search_header_starts_with (struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 927 {
 928         return check_header(f, argc, argv, search, CAMEL_SEARCH_MATCH_STARTS);
 929 }
 930
 931 static ESExpResult *
 932 search_header_ends_with (struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 933 {
 934         return check_header(f, argc, argv, search, CAMEL_SEARCH_MATCH_ENDS);
 935 }
 936
 937 static ESExpResult *
 938 search_header_exists (struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
 939 {
 940         ESExpResult *r;
 941
 942         r(printf ("executing header-exists\n"));
 943
 944         if (search->current) {
 945                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
 946                 if (argc == 1 && argv[0]->type == ESEXP_RES_STRING)
 947                         r->value.bool = camel_medium_get_header(CAMEL_MEDIUM(search->current), argv[0]->value.string) != NULL;
 948
 949         } else {
 950                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
 951                 r->value.ptrarray = g_ptr_array_new();
 952         }
 953
 954         return r;
 955 }
 956
 957 /* this is just to OR results together */
 958 struct _glib_sux_donkeys {
 959         int count;
 960         GPtrArray *uids;
 961 };
 962
 963 /* or, store all unique values */
 964 static void
 965 g_lib_sux_htor(char *key, int value, struct _glib_sux_donkeys *fuckup)
 966 {
 967         g_ptr_array_add(fuckup->uids, key);
 968 }
 969
 970 /* and, only store duplicates */
 971 static void
 972 g_lib_sux_htand(char *key, int value, struct _glib_sux_donkeys *fuckup)
 973 {
 974         if (value == fuckup->count)
 975                 g_ptr_array_add(fuckup->uids, key);
 976 }
 977
 978 static int
 979 match_message_index(CamelIndex *idx, const char *uid, const char *match, CamelException *ex)
 980 {
 981         CamelIndexCursor *wc, *nc;
 982         const char *word, *name;
 983         int truth = FALSE;
 984
 985         wc = camel_index_words(idx);
 986         if (wc) {
 987                 while (!truth && (word = camel_index_cursor_next(wc))) {
 988                         if (camel_ustrstrcase(word,match) != NULL) {
 989                                 /* perf: could have the wc cursor return the name cursor */
 990                                 nc = camel_index_find(idx, word);
 991                                 if (nc) {
 992                                         while (!truth && (name = camel_index_cursor_next(nc)))
 993                                                 truth = strcmp(name, uid) == 0;
 994                                         camel_object_unref((CamelObject *)nc);
 995                                 }
 996                         }
 997                 }
 998                 camel_object_unref((CamelObject *)wc);
 999         }
1000
1001         return truth;
1002 }
1003
1004 /*
1005  "one two" "three" "four five"
1006
1007   one and two
1008 or
1009   three
1010 or
1011   four and five
1012 */
1013
1014 /* returns messages which contain all words listed in words */
1015 static GPtrArray *
1016 match_words_index(CamelFolderSearch *search, struct _camel_search_words *words, CamelException *ex)
1017 {
1018         GPtrArray *result = g_ptr_array_new();
1019         GHashTable *ht = g_hash_table_new(g_str_hash, g_str_equal);
1020         struct _glib_sux_donkeys lambdafoo;
1021         CamelIndexCursor *wc, *nc;
1022         const char *word, *name;
1023         CamelMessageInfo *mi;
1024         int i;
1025
1026         /* we can have a maximum of 32 words, as we use it as the AND mask */
1027
1028         wc = camel_index_words(search->body_index);
1029         if (wc) {
1030                 while ((word = camel_index_cursor_next(wc))) {
1031                         for (i=0;i<words->len;i++) {
1032                                 if (camel_ustrstrcase(word, words->words[i]->word) != NULL) {
1033                                         /* perf: could have the wc cursor return the name cursor */
1034                                         nc = camel_index_find(search->body_index, word);
1035                                         if (nc) {
1036                                                 while ((name = camel_index_cursor_next(nc))) {
1037                                                         mi = g_hash_table_lookup(search->summary_hash, name);
1038                                                         if (mi) {
1039                                                                 int mask;
1040                                                                 const char *uid = camel_message_info_uid(mi);
1041
1042                                                                 mask = (GPOINTER_TO_INT(g_hash_table_lookup(ht, uid))) | (1<<i);
1043                                                                 g_hash_table_insert(ht, (char *)uid, GINT_TO_POINTER(mask));
1044                                                         }
1045                                                 }
1046                                                 camel_object_unref((CamelObject *)nc);
1047                                         }
1048                                 }
1049                         }
1050                 }
1051                 camel_object_unref((CamelObject *)wc);
1052
1053                 lambdafoo.uids = result;
1054                 lambdafoo.count = (1<<words->len) - 1;
1055                 g_hash_table_foreach(ht, (GHFunc)g_lib_sux_htand, &lambdafoo);
1056                 g_hash_table_destroy(ht);
1057         }
1058
1059         return result;
1060 }
1061
1062 static gboolean
1063 match_words_1message (CamelDataWrapper *object, struct _camel_search_words *words, guint32 *mask)
1064 {
1065         CamelDataWrapper *containee;
1066         int truth = FALSE;
1067         int parts, i;
1068
1069         containee = camel_medium_get_content_object (CAMEL_MEDIUM (object));
1070
1071         if (containee == NULL)
1072                 return FALSE;
1073
1074         /* using the object types is more accurate than using the mime/types */
1075         if (CAMEL_IS_MULTIPART (containee)) {
1076                 parts = camel_multipart_get_number (CAMEL_MULTIPART (containee));
1077                 for (i = 0; i < parts && truth == FALSE; i++) {
1078                         CamelDataWrapper *part = (CamelDataWrapper *)camel_multipart_get_part (CAMEL_MULTIPART (containee), i);
1079                         if (part)
1080                                 truth = match_words_1message(part, words, mask);
1081                 }
1082         } else if (CAMEL_IS_MIME_MESSAGE (containee)) {
1083                 /* for messages we only look at its contents */
1084                 truth = match_words_1message((CamelDataWrapper *)containee, words, mask);
1085         } else if (camel_content_type_is(CAMEL_DATA_WRAPPER (containee)->mime_type, "text", "*")) {
1086                 /* for all other text parts, we look inside, otherwise we dont care */
1087                 CamelStreamMem *mem = (CamelStreamMem *)camel_stream_mem_new ();
1088
1089                 /* FIXME: The match should be part of a stream op */
1090                 camel_data_wrapper_decode_to_stream (containee, CAMEL_STREAM (mem));
1091                 camel_stream_write (CAMEL_STREAM (mem), "", 1);
1092                 for (i=0;i<words->len;i++) {
1093                         /* FIXME: This is horridly slow, and should use a real search algorithm */
1094                         if (camel_ustrstrcase(mem->buffer->data, words->words[i]->word) != NULL) {
1095                                 *mask |= (1<<i);
1096                                 /* shortcut a match */
1097                                 if (*mask == (1<<(words->len))-1)
1098                                         return TRUE;
1099                         }
1100                 }
1101
1102                 camel_object_unref (mem);
1103         }
1104
1105         return truth;
1106 }
1107
1108 static gboolean
1109 match_words_message(CamelFolder *folder, const char *uid, struct _camel_search_words *words, CamelException *ex)
1110 {
1111         guint32 mask;
1112         CamelMimeMessage *msg;
1113         CamelException x = CAMEL_EXCEPTION_INITIALISER;
1114         int truth;
1115
1116         msg = camel_folder_get_message(folder, uid, &x);
1117         if (msg) {
1118                 mask = 0;
1119                 truth = match_words_1message((CamelDataWrapper *)msg, words, &mask);
1120                 camel_object_unref((CamelObject *)msg);
1121         } else {
1122                 camel_exception_clear(&x);
1123                 truth = FALSE;
1124         }
1125
1126         return truth;
1127 }
1128
1129 static GPtrArray *
1130 match_words_messages(CamelFolderSearch *search, struct _camel_search_words *words, CamelException *ex)
1131 {
1132         int i;
1133         GPtrArray *matches = g_ptr_array_new();
1134
1135         if (search->body_index) {
1136                 GPtrArray *indexed;
1137                 struct _camel_search_words *simple;
1138
1139                 simple = camel_search_words_simple(words);
1140                 indexed = match_words_index(search, simple, ex);
1141                 camel_search_words_free(simple);
1142
1143                 for (i=0;i<indexed->len;i++) {
1144                         const char *uid = g_ptr_array_index(indexed, i);
1145
1146                         if (match_words_message(search->folder, uid, words, ex))
1147                                 g_ptr_array_add(matches, (char *)uid);
1148                 }
1149
1150                 g_ptr_array_free(indexed, TRUE);
1151         } else {
1152                 GPtrArray *v = search->summary_set?search->summary_set:search->summary;
1153
1154                 for (i=0;i<v->len;i++) {
1155                         CamelMessageInfo *info = g_ptr_array_index(v, i);
1156                         const char *uid = camel_message_info_uid(info);
1157
1158                         if (match_words_message(search->folder, uid, words, ex))
1159                                 g_ptr_array_add(matches, (char *)uid);
1160                 }
1161         }
1162
1163         return matches;
1164 }
1165
1166 static ESExpResult *
1167 search_body_contains(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
1168 {
1169         int i, j;
1170         CamelException *ex = search->priv->ex;
1171         struct _camel_search_words *words;
1172         ESExpResult *r;
1173         struct _glib_sux_donkeys lambdafoo;
1174
1175         if (search->current) {
1176                 int truth = FALSE;
1177
1178                 if (argc == 1 && argv[0]->value.string[0] == 0) {
1179                         truth = TRUE;
1180                 } else {
1181                         for (i=0;i<argc && !truth;i++) {
1182                                 if (argv[i]->type == ESEXP_RES_STRING) {
1183                                         words = camel_search_words_split(argv[i]->value.string);
1184                                         truth = TRUE;
1185                                         if ((words->type & CAMEL_SEARCH_WORD_COMPLEX) == 0 && search->body_index) {
1186                                                 for (j=0;j<words->len && truth;j++)
1187                                                         truth = match_message_index(search->body_index, camel_message_info_uid(search->current), words->words[j]->word, ex);
1188                                         } else {
1189                                                 /* TODO: cache current message incase of multiple body search terms */
1190                                                 truth = match_words_message(search->folder, camel_message_info_uid(search->current), words, ex);
1191                                         }
1192                                         camel_search_words_free(words);
1193                                 }
1194                         }
1195                 }
1196                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
1197                 r->value.bool = truth;
1198         } else {
1199                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1200                 r->value.ptrarray = g_ptr_array_new();
1201
1202                 if (argc == 1 && argv[0]->value.string[0] == 0) {
1203                         GPtrArray *v = search->summary_set?search->summary_set:search->summary;
1204
1205                         for (i=0;i<v->len;i++) {
1206                                 CamelMessageInfo *info = g_ptr_array_index(v, i);
1207
1208                                 g_ptr_array_add(r->value.ptrarray, (char *)camel_message_info_uid(info));
1209                         }
1210                 } else {
1211                         GHashTable *ht = g_hash_table_new(g_str_hash, g_str_equal);
1212                         GPtrArray *matches;
1213
1214                         for (i=0;i<argc;i++) {
1215                                 if (argv[i]->type == ESEXP_RES_STRING) {
1216                                         words = camel_search_words_split(argv[i]->value.string);
1217                                         if ((words->type & CAMEL_SEARCH_WORD_COMPLEX) == 0 && search->body_index) {
1218                                                 matches = match_words_index(search, words, ex);
1219                                         } else {
1220                                                 matches = match_words_messages(search, words, ex);
1221                                         }
1222                                         for (j=0;j<matches->len;j++)
1223                                                 g_hash_table_insert(ht, matches->pdata[j], matches->pdata[j]);
1224                                         g_ptr_array_free(matches, TRUE);
1225                                         camel_search_words_free(words);
1226                                 }
1227                         }
1228                         lambdafoo.uids = r->value.ptrarray;
1229                         g_hash_table_foreach(ht, (GHFunc)g_lib_sux_htor, &lambdafoo);
1230                         g_hash_table_destroy(ht);
1231                 }
1232         }
1233
1234         return r;
1235 }
1236
1237 static ESExpResult *
1238 search_user_flag(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
1239 {
1240         ESExpResult *r;
1241         int i;
1242
1243         r(printf("executing user-flag\n"));
1244
1245         /* are we inside a match-all? */
1246         if (search->current) {
1247                 int truth = FALSE;
1248                 /* performs an OR of all words */
1249                 for (i=0;i<argc && !truth;i++) {
1250                         if (argv[i]->type == ESEXP_RES_STRING
1251                             && camel_message_info_user_flag(search->current, argv[i]->value.string)) {
1252                                 truth = TRUE;
1253                                 break;
1254                         }
1255                 }
1256                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
1257                 r->value.bool = truth;
1258         } else {
1259                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1260                 r->value.ptrarray = g_ptr_array_new();
1261         }
1262
1263         return r;
1264 }
1265
1266 static ESExpResult *
1267 search_system_flag (struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
1268 {
1269         ESExpResult *r;
1270
1271         r(printf ("executing system-flag\n"));
1272
1273         if (search->current) {
1274                 gboolean truth = FALSE;
1275
1276                 if (argc == 1)
1277                         truth = camel_system_flag_get (camel_message_info_flags(search->current), argv[0]->value.string);
1278
1279                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
1280                 r->value.bool = truth;
1281         } else {
1282                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1283                 r->value.ptrarray = g_ptr_array_new ();
1284         }
1285
1286         return r;
1287 }
1288
1289 static ESExpResult *
1290 search_user_tag(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
1291 {
1292         const char *value = NULL;
1293         ESExpResult *r;
1294
1295         r(printf("executing user-tag\n"));
1296
1297         if (argc == 1)
1298                 value = camel_message_info_user_tag(search->current, argv[0]->value.string);
1299
1300         r = e_sexp_result_new(f, ESEXP_RES_STRING);
1301         r->value.string = g_strdup (value ? value : "");
1302
1303         return r;
1304 }
1305
1306 static ESExpResult *
1307 search_get_sent_date(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s)
1308 {
1309         ESExpResult *r;
1310
1311         r(printf("executing get-sent-date\n"));
1312
1313         /* are we inside a match-all? */
1314         if (s->current) {
1315                 r = e_sexp_result_new(f, ESEXP_RES_INT);
1316
1317                 r->value.number = camel_message_info_date_sent(s->current);
1318         } else {
1319                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1320                 r->value.ptrarray = g_ptr_array_new ();
1321         }
1322
1323         return r;
1324 }
1325
1326 static ESExpResult *
1327 search_get_received_date(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s)
1328 {
1329         ESExpResult *r;
1330
1331         r(printf("executing get-received-date\n"));
1332
1333         /* are we inside a match-all? */
1334         if (s->current) {
1335                 r = e_sexp_result_new(f, ESEXP_RES_INT);
1336
1337                 r->value.number = camel_message_info_date_received(s->current);
1338         } else {
1339                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1340                 r->value.ptrarray = g_ptr_array_new ();
1341         }
1342
1343         return r;
1344 }
1345
1346 static ESExpResult *
1347 search_get_current_date(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s)
1348 {
1349         ESExpResult *r;
1350
1351         r(printf("executing get-current-date\n"));
1352
1353         r = e_sexp_result_new(f, ESEXP_RES_INT);
1354         r->value.number = time (NULL);
1355         return r;
1356 }
1357
1358 static ESExpResult *
1359 search_get_size (struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *s)
1360 {
1361         ESExpResult *r;
1362
1363         r(printf("executing get-size\n"));
1364
1365         /* are we inside a match-all? */
1366         if (s->current) {
1367                 r = e_sexp_result_new (f, ESEXP_RES_INT);
1368                 r->value.number = camel_message_info_size(s->current) / 1024;
1369         } else {
1370                 r = e_sexp_result_new (f, ESEXP_RES_ARRAY_PTR);
1371                 r->value.ptrarray = g_ptr_array_new ();
1372         }
1373
1374         return r;
1375 }
1376
1377 static ESExpResult *
1378 search_uid(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
1379 {
1380         ESExpResult *r;
1381         int i;
1382
1383         r(printf("executing uid\n"));
1384
1385         /* are we inside a match-all? */
1386         if (search->current) {
1387                 int truth = FALSE;
1388                 const char *uid = camel_message_info_uid(search->current);
1389
1390                 /* performs an OR of all words */
1391                 for (i=0;i<argc && !truth;i++) {
1392                         if (argv[i]->type == ESEXP_RES_STRING
1393                             && !strcmp(uid, argv[i]->value.string)) {
1394                                 truth = TRUE;
1395                                 break;
1396                         }
1397                 }
1398                 r = e_sexp_result_new(f, ESEXP_RES_BOOL);
1399                 r->value.bool = truth;
1400         } else {
1401                 r = e_sexp_result_new(f, ESEXP_RES_ARRAY_PTR);
1402                 r->value.ptrarray = g_ptr_array_new();
1403                 for (i=0;i<argc;i++) {
1404                         if (argv[i]->type == ESEXP_RES_STRING)
1405                                 g_ptr_array_add(r->value.ptrarray, argv[i]->value.string);
1406                 }
1407         }
1408
1409         return r;
1410 }