pattern.c

   1 /*
   2  * Copyright (C) 1996-2000,2006-7 Michael R. Elkins <me@mutt.org>, and others
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     This program is distributed in the hope that it will be useful,
  10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *     GNU General Public License for more details.
  13  *
  14  *     You should have received a copy of the GNU General Public License
  15  *     along with this program; if not, write to the Free Software
  16  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 # include "config.h"
  21 #endif
  22
  23 #include "mutt.h"
  24 #include "mapping.h"
  25 #include "keymap.h"
  26 #include "mailbox.h"
  27 #include "copy.h"
  28
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <ctype.h>
  32 #include <sys/stat.h>
  33 #include <unistd.h>
  34 #include <stdarg.h>
  35
  36 #include "mutt_crypt.h"
  37 #include "mutt_curses.h"
  38
  39 #ifdef USE_IMAP
  40 #include "mx.h"
  41 #include "imap/imap.h"
  42 #endif
  43
  44 static int eat_regexp (pattern_t *pat, BUFFER *, BUFFER *);
  45 static int eat_date (pattern_t *pat, BUFFER *, BUFFER *);
  46 static int eat_range (pattern_t *pat, BUFFER *, BUFFER *);
  47 static int patmatch (const pattern_t *pat, const char *buf);
  48
  49 static struct pattern_flags
  50 {
  51   int tag;      /* character used to represent this op */
  52   int op;       /* operation to perform */
  53   int class;
  54   int (*eat_arg) (pattern_t *, BUFFER *, BUFFER *);
  55 }
  56 Flags[] =
  57 {
  58   { 'A', M_ALL,                 0,              NULL },
  59   { 'b', M_BODY,                M_FULL_MSG,     eat_regexp },
  60   { 'B', M_WHOLE_MSG,           M_FULL_MSG,     eat_regexp },
  61   { 'c', M_CC,                  0,              eat_regexp },
  62   { 'C', M_RECIPIENT,           0,              eat_regexp },
  63   { 'd', M_DATE,                0,              eat_date },
  64   { 'D', M_DELETED,             0,              NULL },
  65   { 'e', M_SENDER,              0,              eat_regexp },
  66   { 'E', M_EXPIRED,             0,              NULL },
  67   { 'f', M_FROM,                0,              eat_regexp },
  68   { 'F', M_FLAG,                0,              NULL },
  69   { 'g', M_CRYPT_SIGN,          0,              NULL },
  70   { 'G', M_CRYPT_ENCRYPT,       0,              NULL },
  71   { 'h', M_HEADER,              M_FULL_MSG,     eat_regexp },
  72   { 'H', M_HORMEL,              0,              eat_regexp },
  73   { 'i', M_ID,                  0,              eat_regexp },
  74   { 'k', M_PGP_KEY,             0,              NULL },
  75   { 'l', M_LIST,                0,              NULL },
  76   { 'L', M_ADDRESS,             0,              eat_regexp },
  77   { 'm', M_MESSAGE,             0,              eat_range },
  78   { 'n', M_SCORE,               0,              eat_range },
  79   { 'N', M_NEW,                 0,              NULL },
  80   { 'O', M_OLD,                 0,              NULL },
  81   { 'p', M_PERSONAL_RECIP,      0,              NULL },
  82   { 'P', M_PERSONAL_FROM,       0,              NULL },
  83   { 'Q', M_REPLIED,             0,              NULL },
  84   { 'r', M_DATE_RECEIVED,       0,              eat_date },
  85   { 'R', M_READ,                0,              NULL },
  86   { 's', M_SUBJECT,             0,              eat_regexp },
  87   { 'S', M_SUPERSEDED,          0,              NULL },
  88   { 't', M_TO,                  0,              eat_regexp },
  89   { 'T', M_TAG,                 0,              NULL },
  90   { 'u', M_SUBSCRIBED_LIST,     0,              NULL },
  91   { 'U', M_UNREAD,              0,              NULL },
  92   { 'v', M_COLLAPSED,           0,              NULL },
  93   { 'V', M_CRYPT_VERIFIED,      0,              NULL },
  94   { 'x', M_REFERENCE,           0,              eat_regexp },
  95   { 'X', M_MIMEATTACH,          0,              eat_range },
  96   { 'y', M_XLABEL,              0,              eat_regexp },
  97   { 'z', M_SIZE,                0,              eat_range },
  98   { '=', M_DUPLICATED,          0,              NULL },
  99   { '$', M_UNREFERENCED,        0,              NULL },
 100   { 0,   0,                     0,              NULL }
 101 };
 102
 103 static pattern_t *SearchPattern = NULL; /* current search pattern */
 104 static char LastSearch[STRING] = { 0 }; /* last pattern searched for */
 105 static char LastSearchExpn[LONG_STRING] = { 0 }; /* expanded version of
 106                                                     LastSearch */
 107
 108 #define M_MAXRANGE -1
 109
 110 /* constants for parse_date_range() */
 111 #define M_PDR_NONE      0x0000
 112 #define M_PDR_MINUS     0x0001
 113 #define M_PDR_PLUS      0x0002
 114 #define M_PDR_WINDOW    0x0004
 115 #define M_PDR_ABSOLUTE  0x0008
 116 #define M_PDR_DONE      0x0010
 117 #define M_PDR_ERROR     0x0100
 118 #define M_PDR_ERRORDONE (M_PDR_ERROR | M_PDR_DONE)
 119
 120
 121 /* if no uppercase letters are given, do a case-insensitive search */
 122 int mutt_which_case (const char *s)
 123 {
 124   wchar_t w;
 125   mbstate_t mb;
 126   size_t l;
 127
 128   memset (&mb, 0, sizeof (mb));
 129
 130   for (; (l = mbrtowc (&w, s, MB_CUR_MAX, &mb)) != 0; s += l)
 131   {
 132     if (l == (size_t) -2)
 133       continue; /* shift sequences */
 134     if (l == (size_t) -1)
 135       return 0; /* error; assume case-sensitive */
 136     if (iswalpha ((wint_t) w) && iswupper ((wint_t) w))
 137       return 0; /* case-sensitive */
 138   }
 139
 140   return REG_ICASE; /* case-insensitive */
 141 }
 142
 143 static int
 144 msg_search (CONTEXT *ctx, pattern_t* pat, int msgno)
 145 {
 146   char tempfile[_POSIX_PATH_MAX];
 147   MESSAGE *msg = NULL;
 148   STATE s;
 149   struct stat st;
 150   FILE *fp = NULL;
 151   long lng = 0;
 152   int match = 0;
 153   HEADER *h = ctx->hdrs[msgno];
 154   char *buf;
 155   size_t blen;
 156
 157   if ((msg = mx_open_message (ctx, msgno)) != NULL)
 158   {
 159     if (option (OPTTHOROUGHSRC))
 160     {
 161       /* decode the header / body */
 162       memset (&s, 0, sizeof (s));
 163       s.fpin = msg->fp;
 164       s.flags = M_CHARCONV;
 165       mutt_mktemp (tempfile);
 166       if ((s.fpout = safe_fopen (tempfile, "w+")) == NULL)
 167       {
 168         mutt_perror (tempfile);
 169         return (0);
 170       }
 171
 172       if (pat->op != M_BODY)
 173         mutt_copy_header (msg->fp, h, s.fpout, CH_FROM | CH_DECODE, NULL);
 174
 175       if (pat->op != M_HEADER)
 176       {
 177         mutt_parse_mime_message (ctx, h);
 178
 179         if (WithCrypto && (h->security & ENCRYPT)
 180             && !crypt_valid_passphrase(h->security))
 181         {
 182           mx_close_message (&msg);
 183           if (s.fpout)
 184           {
 185             safe_fclose (&s.fpout);
 186             unlink (tempfile);
 187           }
 188           return (0);
 189         }
 190
 191         fseeko (msg->fp, h->offset, 0);
 192         mutt_body_handler (h->content, &s);
 193       }
 194
 195       fp = s.fpout;
 196       fflush (fp);
 197       fseek (fp, 0, 0);
 198       fstat (fileno (fp), &st);
 199       lng = (long) st.st_size;
 200     }
 201     else
 202     {
 203       /* raw header / body */
 204       fp = msg->fp;
 205       if (pat->op != M_BODY)
 206       {
 207         fseeko (fp, h->offset, 0);
 208         lng = h->content->offset - h->offset;
 209       }
 210       if (pat->op != M_HEADER)
 211       {
 212         if (pat->op == M_BODY)
 213           fseeko (fp, h->content->offset, 0);
 214         lng += h->content->length;
 215       }
 216     }
 217
 218     blen = STRING;
 219     buf = safe_malloc (blen);
 220
 221     /* search the file "fp" */
 222     while (lng > 0)
 223     {
 224       if (pat->op == M_HEADER)
 225       {
 226         if (*(buf = mutt_read_rfc822_line (fp, buf, &blen)) == '\0')
 227           break;
 228       }
 229       else if (fgets (buf, blen - 1, fp) == NULL)
 230         break; /* don't loop forever */
 231       if (patmatch (pat, buf) == 0)
 232       {
 233         match = 1;
 234         break;
 235       }
 236       lng -= mutt_strlen (buf);
 237     }
 238
 239     FREE (&buf);
 240
 241     mx_close_message (&msg);
 242
 243     if (option (OPTTHOROUGHSRC))
 244     {
 245       safe_fclose (&fp);
 246       unlink (tempfile);
 247     }
 248   }
 249
 250   return match;
 251 }
 252
 253 static int eat_regexp (pattern_t *pat, BUFFER *s, BUFFER *err)
 254 {
 255   BUFFER buf;
 256   int r;
 257
 258   memset (&buf, 0, sizeof (buf));
 259   if (mutt_extract_token (&buf, s, M_TOKEN_PATTERN | M_TOKEN_COMMENT) != 0 ||
 260       !buf.data)
 261   {
 262     snprintf (err->data, err->dsize, _("Error in expression: %s"), s->dptr);
 263     return (-1);
 264   }
 265   if (!*buf.data)
 266   {
 267     snprintf (err->data, err->dsize, _("Empty expression"));
 268     return (-1);
 269   }
 270
 271 #if 0
 272   /* If there are no RE metacharacters, use simple search anyway */
 273   if (!pat->stringmatch && !strpbrk (buf.data, "|[{.*+?^$"))
 274     pat->stringmatch = 1;
 275 #endif
 276
 277   if (pat->stringmatch)
 278   {
 279     pat->p.str = safe_strdup (buf.data);
 280     pat->ign_case = mutt_which_case (buf.data) == REG_ICASE;
 281     FREE (&buf.data);
 282   }
 283   else if (pat->groupmatch)
 284   {
 285     pat->p.g = mutt_pattern_group (buf.data);
 286     FREE (&buf.data);
 287   }
 288   else
 289   {
 290     pat->p.rx = safe_malloc (sizeof (regex_t));
 291     r = REGCOMP (pat->p.rx, buf.data, REG_NEWLINE | REG_NOSUB | mutt_which_case (buf.data));
 292     FREE (&buf.data);
 293     if (r)
 294     {
 295       regerror (r, pat->p.rx, err->data, err->dsize);
 296       regfree (pat->p.rx);
 297       FREE (&pat->p.rx);
 298       return (-1);
 299     }
 300   }
 301
 302   return 0;
 303 }
 304
 305 int eat_range (pattern_t *pat, BUFFER *s, BUFFER *err)
 306 {
 307   char *tmp;
 308   int do_exclusive = 0;
 309   int skip_quote = 0;
 310
 311   /*
 312    * If simple_search is set to "~m %s", the range will have double quotes
 313    * around it...
 314    */
 315   if (*s->dptr == '"')
 316   {
 317     s->dptr++;
 318     skip_quote = 1;
 319   }
 320   if (*s->dptr == '<')
 321     do_exclusive = 1;
 322   if ((*s->dptr != '-') && (*s->dptr != '<'))
 323   {
 324     /* range minimum */
 325     if (*s->dptr == '>')
 326     {
 327       pat->max = M_MAXRANGE;
 328       pat->min = strtol (s->dptr + 1, &tmp, 0) + 1; /* exclusive range */
 329     }
 330     else
 331       pat->min = strtol (s->dptr, &tmp, 0);
 332     if (toupper ((unsigned char) *tmp) == 'K') /* is there a prefix? */
 333     {
 334       pat->min *= 1024;
 335       tmp++;
 336     }
 337     else if (toupper ((unsigned char) *tmp) == 'M')
 338     {
 339       pat->min *= 1048576;
 340       tmp++;
 341     }
 342     if (*s->dptr == '>')
 343     {
 344       s->dptr = tmp;
 345       return 0;
 346     }
 347     if (*tmp != '-')
 348     {
 349       /* exact value */
 350       pat->max = pat->min;
 351       s->dptr = tmp;
 352       return 0;
 353     }
 354     tmp++;
 355   }
 356   else
 357   {
 358     s->dptr++;
 359     tmp = s->dptr;
 360   }
 361
 362   if (isdigit ((unsigned char) *tmp))
 363   {
 364     /* range maximum */
 365     pat->max = strtol (tmp, &tmp, 0);
 366     if (toupper ((unsigned char) *tmp) == 'K')
 367     {
 368       pat->max *= 1024;
 369       tmp++;
 370     }
 371     else if (toupper ((unsigned char) *tmp) == 'M')
 372     {
 373       pat->max *= 1048576;
 374       tmp++;
 375     }
 376     if (do_exclusive)
 377       (pat->max)--;
 378   }
 379   else
 380     pat->max = M_MAXRANGE;
 381
 382   if (skip_quote && *tmp == '"')
 383     tmp++;
 384
 385   SKIPWS (tmp);
 386   s->dptr = tmp;
 387   return 0;
 388 }
 389
 390 static const char *getDate (const char *s, struct tm *t, BUFFER *err)
 391 {
 392   char *p;
 393   time_t now = time (NULL);
 394   struct tm *tm = localtime (&now);
 395
 396   t->tm_mday = strtol (s, &p, 10);
 397   if (t->tm_mday < 1 || t->tm_mday > 31)
 398   {
 399     snprintf (err->data, err->dsize, _("Invalid day of month: %s"), s);
 400     return NULL;
 401   }
 402   if (*p != '/')
 403   {
 404     /* fill in today's month and year */
 405     t->tm_mon = tm->tm_mon;
 406     t->tm_year = tm->tm_year;
 407     return p;
 408   }
 409   p++;
 410   t->tm_mon = strtol (p, &p, 10) - 1;
 411   if (t->tm_mon < 0 || t->tm_mon > 11)
 412   {
 413     snprintf (err->data, err->dsize, _("Invalid month: %s"), p);
 414     return NULL;
 415   }
 416   if (*p != '/')
 417   {
 418     t->tm_year = tm->tm_year;
 419     return p;
 420   }
 421   p++;
 422   t->tm_year = strtol (p, &p, 10);
 423   if (t->tm_year < 70) /* year 2000+ */
 424     t->tm_year += 100;
 425   else if (t->tm_year > 1900)
 426     t->tm_year -= 1900;
 427   return p;
 428 }
 429
 430 /* Ny   years
 431    Nm   months
 432    Nw   weeks
 433    Nd   days */
 434 static const char *get_offset (struct tm *tm, const char *s, int sign)
 435 {
 436   char *ps;
 437   int offset = strtol (s, &ps, 0);
 438   if ((sign < 0 && offset > 0) || (sign > 0 && offset < 0))
 439     offset = -offset;
 440
 441   switch (*ps)
 442   {
 443     case 'y':
 444       tm->tm_year += offset;
 445       break;
 446     case 'm':
 447       tm->tm_mon += offset;
 448       break;
 449     case 'w':
 450       tm->tm_mday += 7 * offset;
 451       break;
 452     case 'd':
 453       tm->tm_mday += offset;
 454       break;
 455     default:
 456       return s;
 457   }
 458   mutt_normalize_time (tm);
 459   return (ps + 1);
 460 }
 461
 462 static void adjust_date_range (struct tm *min, struct tm *max)
 463 {
 464   if (min->tm_year > max->tm_year
 465       || (min->tm_year == max->tm_year && min->tm_mon > max->tm_mon)
 466       || (min->tm_year == max->tm_year && min->tm_mon == max->tm_mon
 467         && min->tm_mday > max->tm_mday))
 468   {
 469     int tmp;
 470
 471     tmp = min->tm_year;
 472     min->tm_year = max->tm_year;
 473     max->tm_year = tmp;
 474
 475     tmp = min->tm_mon;
 476     min->tm_mon = max->tm_mon;
 477     max->tm_mon = tmp;
 478
 479     tmp = min->tm_mday;
 480     min->tm_mday = max->tm_mday;
 481     max->tm_mday = tmp;
 482
 483     min->tm_hour = min->tm_min = min->tm_sec = 0;
 484     max->tm_hour = 23;
 485     max->tm_min = max->tm_sec = 59;
 486   }
 487 }
 488
 489 static const char * parse_date_range (const char* pc, struct tm *min,
 490     struct tm *max, int haveMin, struct tm *baseMin, BUFFER *err)
 491 {
 492   int flag = M_PDR_NONE;
 493   while (*pc && ((flag & M_PDR_DONE) == 0))
 494   {
 495     const char *pt;
 496     char ch = *pc++;
 497     SKIPWS (pc);
 498     switch (ch)
 499     {
 500       case '-':
 501       {
 502         /* try a range of absolute date minus offset of Ndwmy */
 503         pt = get_offset (min, pc, -1);
 504         if (pc == pt)
 505         {
 506           if (flag == M_PDR_NONE)
 507           { /* nothing yet and no offset parsed => absolute date? */
 508             if (!getDate (pc, max, err))
 509               flag |= (M_PDR_ABSOLUTE | M_PDR_ERRORDONE);  /* done bad */
 510             else
 511             {
 512               /* reestablish initial base minimum if not specified */
 513               if (!haveMin)
 514                 memcpy (min, baseMin, sizeof(struct tm));
 515               flag |= (M_PDR_ABSOLUTE | M_PDR_DONE);  /* done good */
 516             }
 517           }
 518           else
 519             flag |= M_PDR_ERRORDONE;
 520         }
 521         else
 522         {
 523           pc = pt;
 524           if (flag == M_PDR_NONE && !haveMin)
 525           { /* the very first "-3d" without a previous absolute date */
 526             max->tm_year = min->tm_year;
 527             max->tm_mon = min->tm_mon;
 528             max->tm_mday = min->tm_mday;
 529           }
 530           flag |= M_PDR_MINUS;
 531         }
 532       }
 533       break;
 534       case '+':
 535       { /* enlarge plusRange */
 536         pt = get_offset (max, pc, 1);
 537         if (pc == pt)
 538           flag |= M_PDR_ERRORDONE;
 539         else
 540         {
 541           pc = pt;
 542           flag |= M_PDR_PLUS;
 543         }
 544       }
 545       break;
 546       case '*':
 547       { /* enlarge window in both directions */
 548         pt = get_offset (min, pc, -1);
 549         if (pc == pt)
 550           flag |= M_PDR_ERRORDONE;
 551         else
 552         {
 553           pc = get_offset (max, pc, 1);
 554           flag |= M_PDR_WINDOW;
 555         }
 556       }
 557       break;
 558       default:
 559         flag |= M_PDR_ERRORDONE;
 560     }
 561     SKIPWS (pc);
 562   }
 563   if ((flag & M_PDR_ERROR) && !(flag & M_PDR_ABSOLUTE))
 564   { /* getDate has its own error message, don't overwrite it here */
 565     snprintf (err->data, err->dsize, _("Invalid relative date: %s"), pc-1);
 566   }
 567   return ((flag & M_PDR_ERROR) ? NULL : pc);
 568 }
 569
 570 static int eat_date (pattern_t *pat, BUFFER *s, BUFFER *err)
 571 {
 572   BUFFER buffer;
 573   struct tm min, max;
 574
 575   memset (&buffer, 0, sizeof (buffer));
 576   if (mutt_extract_token (&buffer, s, M_TOKEN_COMMENT | M_TOKEN_PATTERN) != 0
 577       || !buffer.data)
 578   {
 579     strfcpy (err->data, _("error in expression"), err->dsize);
 580     return (-1);
 581   }
 582
 583   memset (&min, 0, sizeof (min));
 584   /* the `0' time is Jan 1, 1970 UTC, so in order to prevent a negative time
 585      when doing timezone conversion, we use Jan 2, 1970 UTC as the base
 586      here */
 587   min.tm_mday = 2;
 588   min.tm_year = 70;
 589
 590   memset (&max, 0, sizeof (max));
 591
 592   /* Arbitrary year in the future.  Don't set this too high
 593      or mutt_mktime() returns something larger than will
 594      fit in a time_t on some systems */
 595   max.tm_year = 130;
 596   max.tm_mon = 11;
 597   max.tm_mday = 31;
 598   max.tm_hour = 23;
 599   max.tm_min = 59;
 600   max.tm_sec = 59;
 601
 602   if (strchr ("<>=", buffer.data[0]))
 603   {
 604     /* offset from current time
 605        <3d      less than three days ago
 606        >3d      more than three days ago
 607        =3d      exactly three days ago */
 608     time_t now = time (NULL);
 609     struct tm *tm = localtime (&now);
 610     int exact = 0;
 611
 612     if (buffer.data[0] == '<')
 613     {
 614       memcpy (&min, tm, sizeof (min));
 615       tm = &min;
 616     }
 617     else
 618     {
 619       memcpy (&max, tm, sizeof (max));
 620       tm = &max;
 621
 622       if (buffer.data[0] == '=')
 623         exact++;
 624     }
 625     tm->tm_hour = 23;
 626     tm->tm_min = tm->tm_sec = 59;
 627
 628     /* force negative offset */
 629     get_offset (tm, buffer.data + 1, -1);
 630
 631     if (exact)
 632     {
 633       /* start at the beginning of the day in question */
 634       memcpy (&min, &max, sizeof (max));
 635       min.tm_hour = min.tm_sec = min.tm_min = 0;
 636     }
 637   }
 638   else
 639   {
 640     const char *pc = buffer.data;
 641
 642     int haveMin = FALSE;
 643     int untilNow = FALSE;
 644     if (isdigit ((unsigned char)*pc))
 645     {
 646       /* mininum date specified */
 647       if ((pc = getDate (pc, &min, err)) == NULL)
 648       {
 649         FREE (&buffer.data);
 650         return (-1);
 651       }
 652       haveMin = TRUE;
 653       SKIPWS (pc);
 654       if (*pc == '-')
 655       {
 656         const char *pt = pc + 1;
 657         SKIPWS (pt);
 658         untilNow = (*pt == '\0');
 659       }
 660     }
 661
 662     if (!untilNow)
 663     { /* max date or relative range/window */
 664
 665       struct tm baseMin;
 666
 667       if (!haveMin)
 668       { /* save base minimum and set current date, e.g. for "-3d+1d" */
 669         time_t now = time (NULL);
 670         struct tm *tm = localtime (&now);
 671         memcpy (&baseMin, &min, sizeof(baseMin));
 672         memcpy (&min, tm, sizeof (min));
 673         min.tm_hour = min.tm_sec = min.tm_min = 0;
 674       }
 675
 676       /* preset max date for relative offsets,
 677          if nothing follows we search for messages on a specific day */
 678       max.tm_year = min.tm_year;
 679       max.tm_mon = min.tm_mon;
 680       max.tm_mday = min.tm_mday;
 681
 682       if (!parse_date_range (pc, &min, &max, haveMin, &baseMin, err))
 683       { /* bail out on any parsing error */
 684         FREE (&buffer.data);
 685         return (-1);
 686       }
 687     }
 688   }
 689
 690   /* Since we allow two dates to be specified we'll have to adjust that. */
 691   adjust_date_range (&min, &max);
 692
 693   pat->min = mutt_mktime (&min, 1);
 694   pat->max = mutt_mktime (&max, 1);
 695
 696   FREE (&buffer.data);
 697
 698   return 0;
 699 }
 700
 701 static int patmatch (const pattern_t* pat, const char* buf)
 702 {
 703   if (pat->stringmatch)
 704     return pat->ign_case ? !strcasestr (buf, pat->p.str) :
 705                            !strstr (buf, pat->p.str);
 706   else if (pat->groupmatch)
 707     return !mutt_group_match (pat->p.g, buf);
 708   else
 709     return regexec (pat->p.rx, buf, 0, NULL, 0);
 710 }
 711
 712 static struct pattern_flags *lookup_tag (char tag)
 713 {
 714   int i;
 715
 716   for (i = 0; Flags[i].tag; i++)
 717     if (Flags[i].tag == tag)
 718       return (&Flags[i]);
 719   return NULL;
 720 }
 721
 722 static /* const */ char *find_matching_paren (/* const */ char *s)
 723 {
 724   int level = 1;
 725
 726   for (; *s; s++)
 727   {
 728     if (*s == '(')
 729       level++;
 730     else if (*s == ')')
 731     {
 732       level--;
 733       if (!level)
 734         break;
 735     }
 736   }
 737   return s;
 738 }
 739
 740 void mutt_pattern_free (pattern_t **pat)
 741 {
 742   pattern_t *tmp;
 743
 744   while (*pat)
 745   {
 746     tmp = *pat;
 747     *pat = (*pat)->next;
 748
 749     if (tmp->stringmatch)
 750       FREE (&tmp->p.str);
 751     else if (tmp->groupmatch)
 752       tmp->p.g = NULL;
 753     else if (tmp->p.rx)
 754     {
 755       regfree (tmp->p.rx);
 756       FREE (&tmp->p.rx);
 757     }
 758
 759     if (tmp->child)
 760       mutt_pattern_free (&tmp->child);
 761     FREE (&tmp);
 762   }
 763 }
 764
 765 pattern_t *mutt_pattern_comp (/* const */ char *s, int flags, BUFFER *err)
 766 {
 767   pattern_t *curlist = NULL;
 768   pattern_t *tmp, *tmp2;
 769   pattern_t *last = NULL;
 770   int not = 0;
 771   int alladdr = 0;
 772   int or = 0;
 773   int implicit = 1;     /* used to detect logical AND operator */
 774   struct pattern_flags *entry;
 775   char *p;
 776   char *buf;
 777   BUFFER ps;
 778
 779   memset (&ps, 0, sizeof (ps));
 780   ps.dptr = s;
 781   ps.dsize = mutt_strlen (s);
 782
 783   while (*ps.dptr)
 784   {
 785     SKIPWS (ps.dptr);
 786     switch (*ps.dptr)
 787     {
 788       case '^':
 789         ps.dptr++;
 790         alladdr = !alladdr;
 791         break;
 792       case '!':
 793         ps.dptr++;
 794         not = !not;
 795         break;
 796       case '|':
 797         if (!or)
 798         {
 799           if (!curlist)
 800           {
 801             snprintf (err->data, err->dsize, _("error in pattern at: %s"), ps.dptr);
 802             return NULL;
 803           }
 804           if (curlist->next)
 805           {
 806             /* A & B | C == (A & B) | C */
 807             tmp = new_pattern ();
 808             tmp->op = M_AND;
 809             tmp->child = curlist;
 810
 811             curlist = tmp;
 812             last = curlist;
 813           }
 814
 815           or = 1;
 816         }
 817         ps.dptr++;
 818         implicit = 0;
 819         not = 0;
 820         alladdr = 0;
 821         break;
 822       case '%':
 823       case '=':
 824       case '~':
 825         if (*(ps.dptr + 1) == '(')
 826         {
 827           ps.dptr ++; /* skip ~ */
 828           p = find_matching_paren (ps.dptr + 1);
 829           if (*p != ')')
 830           {
 831             snprintf (err->data, err->dsize, _("mismatched brackets: %s"), ps.dptr);
 832             mutt_pattern_free (&curlist);
 833             return NULL;
 834           }
 835           tmp = new_pattern ();
 836           tmp->op = M_THREAD;
 837           if (last)
 838             last->next = tmp;
 839           else
 840             curlist = tmp;
 841           last = tmp;
 842           tmp->not ^= not;
 843           tmp->alladdr |= alladdr;
 844           not = 0;
 845           alladdr = 0;
 846           /* compile the sub-expression */
 847           buf = mutt_substrdup (ps.dptr + 1, p);
 848           if ((tmp2 = mutt_pattern_comp (buf, flags, err)) == NULL)
 849           {
 850             FREE (&buf);
 851             mutt_pattern_free (&curlist);
 852             return NULL;
 853           }
 854           FREE (&buf);
 855           tmp->child = tmp2;
 856           ps.dptr = p + 1; /* restore location */
 857           break;
 858         }
 859         if (implicit && or)
 860         {
 861           /* A | B & C == (A | B) & C */
 862           tmp = new_pattern ();
 863           tmp->op = M_OR;
 864           tmp->child = curlist;
 865           curlist = tmp;
 866           last = tmp;
 867           or = 0;
 868         }
 869
 870         tmp = new_pattern ();
 871         tmp->not = not;
 872         tmp->alladdr = alladdr;
 873         tmp->stringmatch = (*ps.dptr == '=') ? 1 : 0;
 874         tmp->groupmatch  = (*ps.dptr == '%') ? 1 : 0;
 875         not = 0;
 876         alladdr = 0;
 877
 878         if (last)
 879           last->next = tmp;
 880         else
 881           curlist = tmp;
 882         last = tmp;
 883
 884         ps.dptr++; /* move past the ~ */
 885         if ((entry = lookup_tag (*ps.dptr)) == NULL)
 886         {
 887           snprintf (err->data, err->dsize, _("%c: invalid pattern modifier"), *ps.dptr);
 888           mutt_pattern_free (&curlist);
 889           return NULL;
 890         }
 891         if (entry->class && (flags & entry->class) == 0)
 892         {
 893           snprintf (err->data, err->dsize, _("%c: not supported in this mode"), *ps.dptr);
 894           mutt_pattern_free (&curlist);
 895           return NULL;
 896         }
 897         tmp->op = entry->op;
 898
 899         ps.dptr++; /* eat the operator and any optional whitespace */
 900         SKIPWS (ps.dptr);
 901
 902         if (entry->eat_arg)
 903         {
 904           if (!*ps.dptr)
 905           {
 906             snprintf (err->data, err->dsize, _("missing parameter"));
 907             mutt_pattern_free (&curlist);
 908             return NULL;
 909           }
 910           if (entry->eat_arg (tmp, &ps, err) == -1)
 911           {
 912             mutt_pattern_free (&curlist);
 913             return NULL;
 914           }
 915         }
 916         implicit = 1;
 917         break;
 918       case '(':
 919         p = find_matching_paren (ps.dptr + 1);
 920         if (*p != ')')
 921         {
 922           snprintf (err->data, err->dsize, _("mismatched parenthesis: %s"), ps.dptr);
 923           mutt_pattern_free (&curlist);
 924           return NULL;
 925         }
 926         /* compile the sub-expression */
 927         buf = mutt_substrdup (ps.dptr + 1, p);
 928         if ((tmp = mutt_pattern_comp (buf, flags, err)) == NULL)
 929         {
 930           FREE (&buf);
 931           mutt_pattern_free (&curlist);
 932           return NULL;
 933         }
 934         FREE (&buf);
 935         if (last)
 936           last->next = tmp;
 937         else
 938           curlist = tmp;
 939         last = tmp;
 940         tmp->not ^= not;
 941         tmp->alladdr |= alladdr;
 942         not = 0;
 943         alladdr = 0;
 944         ps.dptr = p + 1; /* restore location */
 945         break;
 946       default:
 947         snprintf (err->data, err->dsize, _("error in pattern at: %s"), ps.dptr);
 948         mutt_pattern_free (&curlist);
 949         return NULL;
 950     }
 951   }
 952   if (!curlist)
 953   {
 954     strfcpy (err->data, _("empty pattern"), err->dsize);
 955     return NULL;
 956   }
 957   if (curlist->next)
 958   {
 959     tmp = new_pattern ();
 960     tmp->op = or ? M_OR : M_AND;
 961     tmp->child = curlist;
 962     curlist = tmp;
 963   }
 964   return (curlist);
 965 }
 966
 967 static int
 968 perform_and (pattern_t *pat, pattern_exec_flag flags, CONTEXT *ctx, HEADER *hdr)
 969 {
 970   for (; pat; pat = pat->next)
 971     if (mutt_pattern_exec (pat, flags, ctx, hdr) <= 0)
 972       return 0;
 973   return 1;
 974 }
 975
 976 static int
 977 perform_or (struct pattern_t *pat, pattern_exec_flag flags, CONTEXT *ctx, HEADER *hdr)
 978 {
 979   for (; pat; pat = pat->next)
 980     if (mutt_pattern_exec (pat, flags, ctx, hdr) > 0)
 981       return 1;
 982   return 0;
 983 }
 984
 985 static int match_adrlist (pattern_t *pat, int match_personal, int n, ...)
 986 {
 987   va_list ap;
 988   ADDRESS *a;
 989
 990   va_start (ap, n);
 991   for ( ; n ; n --)
 992   {
 993     for (a = va_arg (ap, ADDRESS *) ; a ; a = a->next)
 994     {
 995       if (pat->alladdr ^ ((a->mailbox && patmatch (pat, a->mailbox) == 0) ||
 996            (match_personal && a->personal && patmatch (pat, a->personal) == 0)))
 997       {
 998         va_end (ap);
 999         return (! pat->alladdr); /* Found match, or non-match if alladdr */
1000       }
1001     }
1002   }
1003   va_end (ap);
1004   return pat->alladdr; /* No matches, or all matches if alladdr */
1005 }
1006
1007 static int match_reference (pattern_t *pat, LIST *refs)
1008 {
1009   for (; refs; refs = refs->next)
1010     if (patmatch (pat, refs->data) == 0)
1011       return 1;
1012   return 0;
1013 }
1014
1015 /*
1016  * Matches subscribed mailing lists
1017  */
1018 int mutt_is_list_recipient (int alladdr, ADDRESS *a1, ADDRESS *a2)
1019 {
1020   for (; a1 ; a1 = a1->next)
1021     if (alladdr ^ mutt_is_subscribed_list (a1))
1022       return (! alladdr);
1023   for (; a2 ; a2 = a2->next)
1024     if (alladdr ^ mutt_is_subscribed_list (a2))
1025       return (! alladdr);
1026   return alladdr;
1027 }
1028
1029 /*
1030  * Matches known mailing lists
1031  * The function name may seem a little bit misleading: It checks all
1032  * recipients in To and Cc for known mailing lists, subscribed or not.
1033  */
1034 int mutt_is_list_cc (int alladdr, ADDRESS *a1, ADDRESS *a2)
1035 {
1036   for (; a1 ; a1 = a1->next)
1037     if (alladdr ^ mutt_is_mail_list (a1))
1038       return (! alladdr);
1039   for (; a2 ; a2 = a2->next)
1040     if (alladdr ^ mutt_is_mail_list (a2))
1041       return (! alladdr);
1042   return alladdr;
1043 }
1044
1045 static int match_user (int alladdr, ADDRESS *a1, ADDRESS *a2)
1046 {
1047   for (; a1 ; a1 = a1->next)
1048     if (alladdr ^ mutt_addr_is_user (a1))
1049       return (! alladdr);
1050   for (; a2 ; a2 = a2->next)
1051     if (alladdr ^ mutt_addr_is_user (a2))
1052       return (! alladdr);
1053   return alladdr;
1054 }
1055
1056 static int match_threadcomplete(struct pattern_t *pat, pattern_exec_flag flags, CONTEXT *ctx, THREAD *t,int left,int up,int right,int down)
1057 {
1058   int a;
1059   HEADER *h;
1060
1061   if(!t)
1062     return 0;
1063   h = t->message;
1064   if(h)
1065     if(mutt_pattern_exec(pat, flags, ctx, h))
1066       return 1;
1067
1068   if(up && (a=match_threadcomplete(pat, flags, ctx, t->parent,1,1,1,0)))
1069     return a;
1070   if(right && t->parent && (a=match_threadcomplete(pat, flags, ctx, t->next,0,0,1,1)))
1071     return a;
1072   if(left && t->parent && (a=match_threadcomplete(pat, flags, ctx, t->prev,1,0,0,1)))
1073     return a;
1074   if(down && (a=match_threadcomplete(pat, flags, ctx, t->child,1,0,1,1)))
1075     return a;
1076   return 0;
1077 }
1078
1079 /* flags
1080         M_MATCH_FULL_ADDRESS    match both personal and machine address */
1081 int
1082 mutt_pattern_exec (struct pattern_t *pat, pattern_exec_flag flags, CONTEXT *ctx, HEADER *h)
1083 {
1084   switch (pat->op)
1085   {
1086     case M_AND:
1087       return (pat->not ^ (perform_and (pat->child, flags, ctx, h) > 0));
1088     case M_OR:
1089       return (pat->not ^ (perform_or (pat->child, flags, ctx, h) > 0));
1090     case M_THREAD:
1091       return (pat->not ^ match_threadcomplete(pat->child, flags, ctx, h->thread, 1, 1, 1, 1));
1092     case M_ALL:
1093       return (!pat->not);
1094     case M_EXPIRED:
1095       return (pat->not ^ h->expired);
1096     case M_SUPERSEDED:
1097       return (pat->not ^ h->superseded);
1098     case M_FLAG:
1099       return (pat->not ^ h->flagged);
1100     case M_TAG:
1101       return (pat->not ^ h->tagged);
1102     case M_NEW:
1103       return (pat->not ? h->old || h->read : !(h->old || h->read));
1104     case M_UNREAD:
1105       return (pat->not ? h->read : !h->read);
1106     case M_REPLIED:
1107       return (pat->not ^ h->replied);
1108     case M_OLD:
1109       return (pat->not ? (!h->old || h->read) : (h->old && !h->read));
1110     case M_READ:
1111       return (pat->not ^ h->read);
1112     case M_DELETED:
1113       return (pat->not ^ h->deleted);
1114     case M_MESSAGE:
1115       return (pat->not ^ (h->msgno >= pat->min - 1 && (pat->max == M_MAXRANGE ||
1116                                                    h->msgno <= pat->max - 1)));
1117     case M_DATE:
1118       return (pat->not ^ (h->date_sent >= pat->min && h->date_sent <= pat->max));
1119     case M_DATE_RECEIVED:
1120       return (pat->not ^ (h->received >= pat->min && h->received <= pat->max));
1121     case M_BODY:
1122     case M_HEADER:
1123     case M_WHOLE_MSG:
1124       /*
1125        * ctx can be NULL in certain cases, such as when replying to a message from the attachment menu and
1126        * the user has a reply-hook using "~h" (bug #2190).
1127        */
1128       if (!ctx)
1129               return 0;
1130 #ifdef USE_IMAP
1131       /* IMAP search sets h->matched at search compile time */
1132       if (ctx->magic == M_IMAP && pat->stringmatch)
1133         return (h->matched);
1134 #endif
1135       return (pat->not ^ msg_search (ctx, pat, h->msgno));
1136     case M_SENDER:
1137       return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, 1,
1138                                         h->env->sender));
1139     case M_FROM:
1140       return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, 1,
1141                                         h->env->from));
1142     case M_TO:
1143       return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, 1,
1144                                         h->env->to));
1145     case M_CC:
1146       return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, 1,
1147                                         h->env->cc));
1148     case M_SUBJECT:
1149       return (pat->not ^ (h->env->subject && patmatch (pat, h->env->subject) == 0));
1150     case M_ID:
1151       return (pat->not ^ (h->env->message_id && patmatch (pat, h->env->message_id) == 0));
1152     case M_SCORE:
1153       return (pat->not ^ (h->score >= pat->min && (pat->max == M_MAXRANGE ||
1154                                                    h->score <= pat->max)));
1155     case M_SIZE:
1156       return (pat->not ^ (h->content->length >= pat->min && (pat->max == M_MAXRANGE || h->content->length <= pat->max)));
1157     case M_REFERENCE:
1158       return (pat->not ^ (match_reference (pat, h->env->references) ||
1159                           match_reference (pat, h->env->in_reply_to)));
1160     case M_ADDRESS:
1161       return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, 4,
1162                                         h->env->from, h->env->sender,
1163                                         h->env->to, h->env->cc));
1164     case M_RECIPIENT:
1165            return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS,
1166                                              2, h->env->to, h->env->cc));
1167     case M_LIST:        /* known list, subscribed or not */
1168       return (pat->not ^ mutt_is_list_cc (pat->alladdr, h->env->to, h->env->cc));
1169     case M_SUBSCRIBED_LIST:
1170       return (pat->not ^ mutt_is_list_recipient (pat->alladdr, h->env->to, h->env->cc));
1171     case M_PERSONAL_RECIP:
1172       return (pat->not ^ match_user (pat->alladdr, h->env->to, h->env->cc));
1173     case M_PERSONAL_FROM:
1174       return (pat->not ^ match_user (pat->alladdr, h->env->from, NULL));
1175     case M_COLLAPSED:
1176       return (pat->not ^ (h->collapsed && h->num_hidden > 1));
1177    case M_CRYPT_SIGN:
1178      if (!WithCrypto)
1179        break;
1180      return (pat->not ^ ((h->security & SIGN) ? 1 : 0));
1181    case M_CRYPT_VERIFIED:
1182      if (!WithCrypto)
1183        break;
1184      return (pat->not ^ ((h->security & GOODSIGN) ? 1 : 0));
1185    case M_CRYPT_ENCRYPT:
1186      if (!WithCrypto)
1187        break;
1188      return (pat->not ^ ((h->security & ENCRYPT) ? 1 : 0));
1189    case M_PGP_KEY:
1190      if (!(WithCrypto & APPLICATION_PGP))
1191        break;
1192      return (pat->not ^ ((h->security & APPLICATION_PGP) && (h->security & PGPKEY)));
1193     case M_XLABEL:
1194       return (pat->not ^ (h->env->x_label && patmatch (pat, h->env->x_label) == 0));
1195     case M_HORMEL:
1196       return (pat->not ^ (h->env->spam && h->env->spam->data && patmatch (pat, h->env->spam->data) == 0));
1197     case M_DUPLICATED:
1198       return (pat->not ^ (h->thread && h->thread->duplicate_thread));
1199     case M_MIMEATTACH:
1200       {
1201       int count = mutt_count_body_parts (ctx, h);
1202       return (pat->not ^ (count >= pat->min && (pat->max == M_MAXRANGE ||
1203                                                 count <= pat->max)));
1204       }
1205     case M_UNREFERENCED:
1206       return (pat->not ^ (h->thread && !h->thread->child));
1207   }
1208   mutt_error (_("error: unknown op %d (report this error)."), pat->op);
1209   return (-1);
1210 }
1211
1212 static void quote_simple(char *tmp, size_t len, const char *p)
1213 {
1214   int i = 0;
1215
1216   tmp[i++] = '"';
1217   while (*p && i < len - 3)
1218   {
1219     if (*p == '\\' || *p == '"')
1220       tmp[i++] = '\\';
1221     tmp[i++] = *p++;
1222   }
1223   tmp[i++] = '"';
1224   tmp[i] = 0;
1225 }
1226
1227 /* convert a simple search into a real request */
1228 void mutt_check_simple (char *s, size_t len, const char *simple)
1229 {
1230   char tmp[LONG_STRING];
1231   int do_simple = 1;
1232   char *p;
1233
1234   for (p = s; p && *p; p++)
1235   {
1236     if (*p == '\\' && *(p + 1))
1237       p++;
1238     else if (*p == '~' || *p == '=' || *p == '%')
1239     {
1240       do_simple = 0;
1241       break;
1242     }
1243   }
1244
1245   /* XXX - is ascii_strcasecmp() right here, or should we use locale's
1246    * equivalences?
1247    */
1248
1249   if (do_simple) /* yup, so spoof a real request */
1250   {
1251     /* convert old tokens into the new format */
1252     if (ascii_strcasecmp ("all", s) == 0 ||
1253         !mutt_strcmp ("^", s) || !mutt_strcmp (".", s)) /* ~A is more efficient */
1254       strfcpy (s, "~A", len);
1255     else if (ascii_strcasecmp ("del", s) == 0)
1256       strfcpy (s, "~D", len);
1257     else if (ascii_strcasecmp ("flag", s) == 0)
1258       strfcpy (s, "~F", len);
1259     else if (ascii_strcasecmp ("new", s) == 0)
1260       strfcpy (s, "~N", len);
1261     else if (ascii_strcasecmp ("old", s) == 0)
1262       strfcpy (s, "~O", len);
1263     else if (ascii_strcasecmp ("repl", s) == 0)
1264       strfcpy (s, "~Q", len);
1265     else if (ascii_strcasecmp ("read", s) == 0)
1266       strfcpy (s, "~R", len);
1267     else if (ascii_strcasecmp ("tag", s) == 0)
1268       strfcpy (s, "~T", len);
1269     else if (ascii_strcasecmp ("unread", s) == 0)
1270       strfcpy (s, "~U", len);
1271     else
1272     {
1273       quote_simple (tmp, sizeof(tmp), s);
1274       mutt_expand_fmt (s, len, simple, tmp);
1275     }
1276   }
1277 }
1278
1279 int mutt_pattern_func (int op, char *prompt)
1280 {
1281   pattern_t *pat;
1282   char buf[LONG_STRING] = "", *simple, error[STRING];
1283   BUFFER err;
1284   int i;
1285   progress_t progress;
1286
1287   strfcpy (buf, NONULL (Context->pattern), sizeof (buf));
1288   if (mutt_get_field (prompt, buf, sizeof (buf), M_PATTERN | M_CLEAR) != 0 || !buf[0])
1289     return (-1);
1290
1291   mutt_message _("Compiling search pattern...");
1292
1293   simple = safe_strdup (buf);
1294   mutt_check_simple (buf, sizeof (buf), NONULL (SimpleSearch));
1295
1296   err.data = error;
1297   err.dsize = sizeof (error);
1298   if ((pat = mutt_pattern_comp (buf, M_FULL_MSG, &err)) == NULL)
1299   {
1300     FREE (&simple);
1301     mutt_error ("%s", err.data);
1302     return (-1);
1303   }
1304
1305 #ifdef USE_IMAP
1306   if (Context->magic == M_IMAP && imap_search (Context, pat) < 0)
1307     return -1;
1308 #endif
1309
1310   mutt_progress_init (&progress, _("Executing command on matching messages..."),
1311                       M_PROGRESS_MSG, ReadInc,
1312                       (op == M_LIMIT) ? Context->msgcount : Context->vcount);
1313
1314 #define THIS_BODY Context->hdrs[i]->content
1315
1316   if (op == M_LIMIT)
1317   {
1318     Context->vcount    = 0;
1319     Context->vsize     = 0;
1320     Context->collapsed = 0;
1321
1322     for (i = 0; i < Context->msgcount; i++)
1323     {
1324       mutt_progress_update (&progress, i, -1);
1325       /* new limit pattern implicitly uncollapses all threads */
1326       Context->hdrs[i]->virtual = -1;
1327       Context->hdrs[i]->limited = 0;
1328       Context->hdrs[i]->collapsed = 0;
1329       Context->hdrs[i]->num_hidden = 0;
1330       if (mutt_pattern_exec (pat, M_MATCH_FULL_ADDRESS, Context, Context->hdrs[i]))
1331       {
1332         Context->hdrs[i]->virtual = Context->vcount;
1333         Context->hdrs[i]->limited = 1;
1334         Context->v2r[Context->vcount] = i;
1335         Context->vcount++;
1336         Context->vsize+=THIS_BODY->length + THIS_BODY->offset -
1337           THIS_BODY->hdr_offset;
1338       }
1339     }
1340   }
1341   else
1342   {
1343     for (i = 0; i < Context->vcount; i++)
1344     {
1345       mutt_progress_update (&progress, i, -1);
1346       if (mutt_pattern_exec (pat, M_MATCH_FULL_ADDRESS, Context, Context->hdrs[Context->v2r[i]]))
1347       {
1348         switch (op)
1349         {
1350           case M_DELETE:
1351           case M_UNDELETE:
1352             mutt_set_flag (Context, Context->hdrs[Context->v2r[i]], M_DELETE,
1353                           (op == M_DELETE));
1354             break;
1355           case M_TAG:
1356           case M_UNTAG:
1357             mutt_set_flag (Context, Context->hdrs[Context->v2r[i]], M_TAG,
1358                            (op == M_TAG));
1359             break;
1360         }
1361       }
1362     }
1363   }
1364
1365 #undef THIS_BODY
1366
1367   mutt_clear_error ();
1368
1369   if (op == M_LIMIT)
1370   {
1371     /* drop previous limit pattern */
1372     FREE (&Context->pattern);
1373     if (Context->limit_pattern)
1374       mutt_pattern_free (&Context->limit_pattern);
1375
1376     if (Context->msgcount && !Context->vcount)
1377       mutt_error _("No messages matched criteria.");
1378
1379     /* record new limit pattern, unless match all */
1380     if (mutt_strcmp (buf, "~A") != 0)
1381     {
1382       Context->pattern = simple;
1383       simple = NULL; /* don't clobber it */
1384       Context->limit_pattern = mutt_pattern_comp (buf, M_FULL_MSG, &err);
1385     }
1386   }
1387   FREE (&simple);
1388   mutt_pattern_free (&pat);
1389   return 0;
1390 }
1391
1392 int mutt_search_command (int cur, int op)
1393 {
1394   int i, j;
1395   char buf[STRING];
1396   char temp[LONG_STRING];
1397   char error[STRING];
1398   BUFFER err;
1399   int incr;
1400   HEADER *h;
1401   progress_t progress;
1402   const char* msg = NULL;
1403
1404   if (!*LastSearch || (op != OP_SEARCH_NEXT && op != OP_SEARCH_OPPOSITE))
1405   {
1406     strfcpy (buf, *LastSearch ? LastSearch : "", sizeof (buf));
1407     if (mutt_get_field ((op == OP_SEARCH || op == OP_SEARCH_NEXT) ?
1408                         _("Search for: ") : _("Reverse search for: "),
1409                         buf, sizeof (buf),
1410                       M_CLEAR | M_PATTERN) != 0 || !buf[0])
1411       return (-1);
1412
1413     if (op == OP_SEARCH || op == OP_SEARCH_NEXT)
1414       unset_option (OPTSEARCHREVERSE);
1415     else
1416       set_option (OPTSEARCHREVERSE);
1417
1418     /* compare the *expanded* version of the search pattern in case
1419        $simple_search has changed while we were searching */
1420     strfcpy (temp, buf, sizeof (temp));
1421     mutt_check_simple (temp, sizeof (temp), NONULL (SimpleSearch));
1422
1423     if (!SearchPattern || mutt_strcmp (temp, LastSearchExpn))
1424      {
1425       set_option (OPTSEARCHINVALID);
1426       strfcpy (LastSearch, buf, sizeof (LastSearch));
1427       mutt_message _("Compiling search pattern...");
1428       mutt_pattern_free (&SearchPattern);
1429       err.data = error;
1430       err.dsize = sizeof (error);
1431       if ((SearchPattern = mutt_pattern_comp (temp, M_FULL_MSG, &err)) == NULL)
1432        {
1433         mutt_error ("%s", error);
1434         return (-1);
1435       }
1436       mutt_clear_error ();
1437     }
1438   }
1439
1440   if (option (OPTSEARCHINVALID))
1441   {
1442     for (i = 0; i < Context->msgcount; i++)
1443       Context->hdrs[i]->searched = 0;
1444 #ifdef USE_IMAP
1445     if (Context->magic == M_IMAP && imap_search (Context, SearchPattern) < 0)
1446       return -1;
1447 #endif
1448     unset_option (OPTSEARCHINVALID);
1449   }
1450
1451   incr = (option (OPTSEARCHREVERSE)) ? -1 : 1;
1452   if (op == OP_SEARCH_OPPOSITE)
1453     incr = -incr;
1454
1455   mutt_progress_init (&progress, _("Searching..."), M_PROGRESS_MSG,
1456                       ReadInc, Context->vcount);
1457
1458   for (i = cur + incr, j = 0 ; j != Context->vcount; j++)
1459   {
1460     mutt_progress_update (&progress, j, -1);
1461     if (i > Context->vcount - 1)
1462     {
1463       i = 0;
1464       if (option (OPTWRAPSEARCH))
1465         msg = _("Search wrapped to top.");
1466       else
1467       {
1468         mutt_message _("Search hit bottom without finding match");
1469         return (-1);
1470       }
1471     }
1472     else if (i < 0)
1473     {
1474       i = Context->vcount - 1;
1475       if (option (OPTWRAPSEARCH))
1476         msg = _("Search wrapped to bottom.");
1477       else
1478       {
1479         mutt_message _("Search hit top without finding match");
1480         return (-1);
1481       }
1482     }
1483
1484     h = Context->hdrs[Context->v2r[i]];
1485     if (h->searched)
1486     {
1487       /* if we've already evaulated this message, use the cached value */
1488       if (h->matched)
1489       {
1490         mutt_clear_error();
1491         if (msg && *msg)
1492           mutt_message (msg);
1493         return i;
1494       }
1495     }
1496     else
1497     {
1498       /* remember that we've already searched this message */
1499       h->searched = 1;
1500       if ((h->matched = (mutt_pattern_exec (SearchPattern, M_MATCH_FULL_ADDRESS, Context, h) > 0)))
1501       {
1502         mutt_clear_error();
1503         if (msg && *msg)
1504           mutt_message (msg);
1505         return i;
1506       }
1507     }
1508
1509     if (SigInt)
1510     {
1511       mutt_error _("Search interrupted.");
1512       SigInt = 0;
1513       return (-1);
1514     }
1515
1516     i += incr;
1517   }
1518
1519   mutt_error _("Not found.");
1520   return (-1);
1521 }