X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=pattern.c;h=94c1f9c03cd96a019f9310bd7d6932645eae675f;hp=7d7086897a0610bc8ab3174cae077324b3e93746;hb=7db27b8f24670fd40cf24755f2782a104ad24594;hpb=96d53ff49c308769efbf708e1e65819077cb7af6 diff --git a/pattern.c b/pattern.c index 7d70868..94c1f9c 100644 --- a/pattern.c +++ b/pattern.c @@ -7,87 +7,76 @@ * please see the file GPL in the top level source directory. */ -#if HAVE_CONFIG_H -# include "config.h" -#endif +#include -#include "mutt.h" -#include "mx.h" -#include "mapping.h" +#include +#include +#include +#include + +#include "pattern.h" +#include "alias.h" +#include "crypt.h" +#include "handler.h" #include "keymap.h" #include "copy.h" -#include "lib/mem.h" -#include "lib/intl.h" -#include "lib/str.h" - -#include -#include -#include -#include -#include -#include - -#include "mutt_crypt.h" - static int eat_regexp (pattern_t * pat, BUFFER *, BUFFER *); static int eat_date (pattern_t * pat, BUFFER *, BUFFER *); static int eat_range (pattern_t * pat, BUFFER *, BUFFER *); +static int patmatch (const pattern_t* pat, const char* buf); -struct pattern_flags { +static struct pattern_flags { int tag; /* character used to represent this op */ int op; /* operation to perform */ int class; - int (*eat_arg) (pattern_t *, BUFFER *, BUFFER *); -} Flags[] = { - { - 'A', M_ALL, 0, NULL}, { - 'b', M_BODY, M_FULL_MSG, eat_regexp}, { - 'B', M_WHOLE_MSG, M_FULL_MSG, eat_regexp}, { - 'c', M_CC, 0, eat_regexp}, { - 'C', M_RECIPIENT, 0, eat_regexp}, { - 'd', M_DATE, 0, eat_date}, { - 'D', M_DELETED, 0, NULL}, { - 'e', M_SENDER, 0, eat_regexp}, { - 'E', M_EXPIRED, 0, NULL}, { - 'f', M_FROM, 0, eat_regexp}, { - 'F', M_FLAG, 0, NULL}, { - 'g', M_CRYPT_SIGN, 0, NULL}, { - 'G', M_CRYPT_ENCRYPT, 0, NULL}, { - 'h', M_HEADER, M_FULL_MSG, eat_regexp}, { - 'H', M_HORMEL, 0, eat_regexp}, { - 'i', M_ID, 0, eat_regexp}, { - 'k', M_PGP_KEY, 0, NULL}, { - 'L', M_ADDRESS, 0, eat_regexp}, { - 'l', M_LIST, 0, NULL}, { - 'm', M_MESSAGE, 0, eat_range}, { - 'n', M_SCORE, 0, eat_range}, { - 'N', M_NEW, 0, NULL}, { - 'O', M_OLD, 0, NULL}, { - 'p', M_PERSONAL_RECIP, 0, NULL}, { - 'P', M_PERSONAL_FROM, 0, NULL}, { - 'Q', M_REPLIED, 0, NULL}, { - 'R', M_READ, 0, NULL}, { - 'r', M_DATE_RECEIVED, 0, eat_date}, { - 's', M_SUBJECT, 0, eat_regexp}, { - 'S', M_SUPERSEDED, 0, NULL}, { - 'T', M_TAG, 0, NULL}, { - 't', M_TO, 0, eat_regexp}, { - 'U', M_UNREAD, 0, NULL}, { - 'v', M_COLLAPSED, 0, NULL}, { - 'V', M_CRYPT_VERIFIED, 0, NULL}, -#ifdef USE_NNTP - { - 'w', M_NEWSGROUPS, 0, eat_regexp}, -#endif - { - 'x', M_REFERENCE, 0, eat_regexp}, { - 'y', M_XLABEL, 0, eat_regexp}, { - 'z', M_SIZE, 0, eat_range}, { - '=', M_DUPLICATED, 0, NULL}, { - '$', M_UNREFERENCED, 0, NULL}, { - '*', M_REALNAME, 0, NULL}, { - 0} + int (*eat_arg)(pattern_t *, BUFFER *, BUFFER *); +} const Flags[] = { + {'A', M_ALL, 0, NULL}, + {'b', M_BODY, M_FULL_MSG, eat_regexp}, + {'B', M_WHOLE_MSG, M_FULL_MSG, eat_regexp}, + {'c', M_CC, 0, eat_regexp}, + {'C', M_RECIPIENT, 0, eat_regexp}, + {'d', M_DATE, 0, eat_date}, + {'D', M_DELETED, 0, NULL}, + {'e', M_SENDER, 0, eat_regexp}, + {'E', M_EXPIRED, 0, NULL}, + {'f', M_FROM, 0, eat_regexp}, + {'F', M_FLAG, 0, NULL}, + {'g', M_CRYPT_SIGN, 0, NULL}, + {'G', M_CRYPT_ENCRYPT, 0, NULL}, + {'h', M_HEADER, M_FULL_MSG, eat_regexp}, + {'H', M_HORMEL, 0, eat_regexp}, + {'i', M_ID, 0, eat_regexp}, + {'k', M_PGP_KEY, 0, NULL}, + {'L', M_ADDRESS, 0, eat_regexp}, + {'l', M_LIST, 0, NULL}, + {'m', M_MESSAGE, 0, eat_range}, + {'M', M_MULTIPART, 0, NULL}, + {'n', M_SCORE, 0, eat_range}, + {'N', M_NEW, 0, NULL}, + {'O', M_OLD, 0, NULL}, + {'p', M_PERSONAL_RECIP, 0, NULL}, + {'P', M_PERSONAL_FROM, 0, NULL}, + {'Q', M_REPLIED, 0, NULL}, + {'R', M_READ, 0, NULL}, + {'r', M_DATE_RECEIVED, 0, eat_date}, + {'s', M_SUBJECT, 0, eat_regexp}, + {'S', M_SUPERSEDED, 0, NULL}, + {'T', M_TAG, 0, NULL}, + {'t', M_TO, 0, eat_regexp}, + {'U', M_UNREAD, 0, NULL}, + {'u', M_SUBSCRIBED_LIST, 0, NULL}, + {'v', M_COLLAPSED, 0, NULL}, + {'V', M_CRYPT_VERIFIED, 0, NULL}, + {'x', M_REFERENCE, 0, eat_regexp}, + {'X', M_MIMEATTACH, 0, eat_range}, + {'y', M_XLABEL, 0, eat_regexp}, + {'z', M_SIZE, 0, eat_range}, + {'=', M_DUPLICATED, 0, NULL}, + {'$', M_UNREFERENCED, 0, NULL}, + {'*', M_REALNAME, 0, NULL}, + {0, 0, 0, NULL} }; static pattern_t *SearchPattern = NULL; /* current search pattern */ @@ -107,17 +96,14 @@ static char LastSearchExpn[LONG_STRING] = { 0 }; /* expanded version of #define M_PDR_ERROR 0x0100 #define M_PDR_ERRORDONE (M_PDR_ERROR | M_PDR_DONE) - -int mutt_getvaluebychar (char ch, struct mapping_t *table) +void pattern_wipe(pattern_t *pat) { - int i; - - for (i = 0; table[i].name; i++) { - if (ch == table[i].name[0]) - return table[i].value; - } - - return (-1); + if (pat->rx) { + regfree (pat->rx); + p_delete(&pat->rx); + } + p_delete(&pat->str); + pattern_list_wipe(&pat->child); } /* if no uppercase letters are given, do a case-insensitive search */ @@ -132,8 +118,7 @@ int mutt_which_case (const char *s) } static int -msg_search (CONTEXT * ctx, regex_t * rx, char *buf, size_t blen, int op, - int msgno) +msg_search (CONTEXT *ctx, pattern_t* pat, int msgno) { char tempfile[_POSIX_PATH_MAX]; MESSAGE *msg = NULL; @@ -143,74 +128,72 @@ msg_search (CONTEXT * ctx, regex_t * rx, char *buf, size_t blen, int op, long lng = 0; int match = 0; HEADER *h = ctx->hdrs[msgno]; + char* buf; + ssize_t blen; if ((msg = mx_open_message (ctx, msgno)) != NULL) { if (option (OPTTHOROUGHSRC)) { /* decode the header / body */ - memset (&s, 0, sizeof (s)); + p_clear(&s, 1); s.fpin = msg->fp; s.flags = M_CHARCONV; - mutt_mktemp (tempfile); - if ((s.fpout = safe_fopen (tempfile, "w+")) == NULL) { - mutt_perror (tempfile); - return (0); + s.fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(mod_core.tmpdir), NULL); + if (!s.fpout) { + mutt_error(_("Could not create temporary file")); + return 0; } - if (op != M_BODY) + if (pat->op != M_BODY) mutt_copy_header (msg->fp, h, s.fpout, CH_FROM | CH_DECODE, NULL); - if (op != M_HEADER) { + if (pat->op != M_HEADER) { mutt_parse_mime_message (ctx, h); - - if (WithCrypto && (h->security & ENCRYPT) - && !crypt_valid_passphrase (h->security)) { - mx_close_message (&msg); - if (fp) { - fclose (fp); - unlink (tempfile); - } - return (0); - } - - fseek (msg->fp, h->offset, 0); + fseeko (msg->fp, h->offset, 0); mutt_body_handler (h->content, &s); } fp = s.fpout; fflush (fp); - fseek (fp, 0, 0); + fseeko (fp, 0, 0); fstat (fileno (fp), &st); lng = (long) st.st_size; } else { /* raw header / body */ fp = msg->fp; - if (op != M_BODY) { - fseek (fp, h->offset, 0); + if (pat->op != M_BODY) { + fseeko (fp, h->offset, 0); lng = h->content->offset - h->offset; } - if (op != M_HEADER) { - if (op == M_BODY) - fseek (fp, h->content->offset, 0); + if (pat->op != M_HEADER) { + if (pat->op == M_BODY) + fseeko (fp, h->content->offset, 0); lng += h->content->length; } } + buf = p_new(char, blen = STRING); + /* search the file "fp" */ while (lng > 0) { - if (fgets (buf, blen - 1, fp) == NULL) + if (pat->op == M_HEADER) { + if (!mutt_read_rfc822_line(fp, &buf, &blen)) + break; + } else if (fgets (buf, blen - 1, fp) == NULL) break; /* don't loop forever */ - if (regexec (rx, buf, 0, NULL, 0) == 0) { + if (patmatch (pat, buf) == 0) { match = 1; break; } - lng -= mutt_strlen (buf); + lng -= m_strlen(buf); } + p_delete(&buf); + mx_close_message (&msg); if (option (OPTTHOROUGHSRC)) { - fclose (fp); + m_fclose(&fp); unlink (tempfile); } } @@ -223,27 +206,44 @@ int eat_regexp (pattern_t * pat, BUFFER * s, BUFFER * err) BUFFER buf; int r; - memset (&buf, 0, sizeof (buf)); + p_clear(&buf, 1); + if (mutt_extract_token (&buf, s, M_TOKEN_PATTERN | M_TOKEN_COMMENT) != 0 || !buf.data) { snprintf (err->data, err->dsize, _("Error in expression: %s"), s->dptr); - return (-1); + return -1; } - pat->rx = safe_malloc (sizeof (regex_t)); - r = - REGCOMP (pat->rx, buf.data, - REG_NEWLINE | REG_NOSUB | mutt_which_case (buf.data)); - FREE (&buf.data); - if (r) { - regerror (r, pat->rx, err->data, err->dsize); - regfree (pat->rx); - FREE (&pat->rx); - return (-1); + + if (!*buf.data) { + snprintf (err->data, err->dsize, _("Empty expression")); + return -1; + } + + if (pat->stringmatch) { + pat->str = m_strdup(buf.data); + p_delete(&buf.data); + } else { + pat->rx = p_new(regex_t, 1); + r = REGCOMP (pat->rx, buf.data, REG_NEWLINE | REG_NOSUB | mutt_which_case (buf.data)); + p_delete(&buf.data); + if (r) { + regerror (r, pat->rx, err->data, err->dsize); + regfree (pat->rx); + p_delete(&pat->rx); + return -1; + } } return 0; } -int eat_range (pattern_t * pat, BUFFER * s, BUFFER * err) +static int patmatch (const pattern_t* pat, const char* buf) { + if (pat->stringmatch) + return !strstr (buf, pat->str); + else + return regexec (pat->rx, buf, 0, NULL, 0); +} + +int eat_range (pattern_t * pat, BUFFER * s, BUFFER * err __attribute__ ((unused))) { char *tmp; int do_exclusive = 0; @@ -312,8 +312,7 @@ int eat_range (pattern_t * pat, BUFFER * s, BUFFER * err) if (skip_quote && *tmp == '"') tmp++; - SKIPWS (tmp); - s->dptr = tmp; + s->dptr = vskipspaces(tmp); return 0; } @@ -381,8 +380,8 @@ static const char *get_offset (struct tm *tm, const char *s, int sign) default: return s; } - mutt_normalize_time (tm); - return (ps + 1); + mktime(tm); + return ps + 1; } static void adjust_date_range (struct tm *min, struct tm *max) @@ -421,7 +420,7 @@ static const char *parse_date_range (const char *pc, struct tm *min, const char *pt; char ch = *pc++; - SKIPWS (pc); + pc = vskipspaces(pc); switch (ch) { case '-': { @@ -477,12 +476,12 @@ static const char *parse_date_range (const char *pc, struct tm *min, default: flag |= M_PDR_ERRORDONE; } - SKIPWS (pc); + pc = vskipspaces(pc); } if ((flag & M_PDR_ERROR) && !(flag & M_PDR_ABSOLUTE)) { /* getDate has its own error message, don't overwrite it here */ snprintf (err->data, err->dsize, _("Invalid relative date: %s"), pc - 1); } - return ((flag & M_PDR_ERROR) ? NULL : pc); + return (flag & M_PDR_ERROR) ? NULL : pc; } static int eat_date (pattern_t * pat, BUFFER * s, BUFFER * err) @@ -490,21 +489,21 @@ static int eat_date (pattern_t * pat, BUFFER * s, BUFFER * err) BUFFER buffer; struct tm min, max; - memset (&buffer, 0, sizeof (buffer)); + p_clear(&buffer, 1); if (mutt_extract_token (&buffer, s, M_TOKEN_COMMENT | M_TOKEN_PATTERN) != 0 || !buffer.data) { - strfcpy (err->data, _("error in expression"), err->dsize); - return (-1); + m_strcpy(err->data, err->dsize, _("error in expression")); + return -1; } - memset (&min, 0, sizeof (min)); + p_clear(&min, 1); /* the `0' time is Jan 1, 1970 UTC, so in order to prevent a negative time when doing timezone conversion, we use Jan 2, 1970 UTC as the base here */ min.tm_mday = 2; min.tm_year = 70; - memset (&max, 0, sizeof (max)); + p_clear(&max, 1); /* Arbitrary year in the future. Don't set this too high or mutt_mktime() returns something larger than will @@ -557,15 +556,15 @@ static int eat_date (pattern_t * pat, BUFFER * s, BUFFER * err) if (isdigit ((unsigned char) *pc)) { /* mininum date specified */ if ((pc = getDate (pc, &min, err)) == NULL) { - FREE (&buffer.data); - return (-1); + p_delete(&buffer.data); + return -1; } haveMin = TRUE; - SKIPWS (pc); + pc = vskipspaces(pc); if (*pc == '-') { - const char *pt = pc + 1; + const char *pt; - SKIPWS (pt); + pt = skipspaces(pc + 1); untilNow = (*pt == '\0'); } } @@ -590,8 +589,8 @@ static int eat_date (pattern_t * pat, BUFFER * s, BUFFER * err) max.tm_mday = min.tm_mday; if (!parse_date_range (pc, &min, &max, haveMin, &baseMin, err)) { /* bail out on any parsing error */ - FREE (&buffer.data); - return (-1); + p_delete(&buffer.data); + return -1; } } } @@ -599,59 +598,37 @@ static int eat_date (pattern_t * pat, BUFFER * s, BUFFER * err) /* Since we allow two dates to be specified we'll have to adjust that. */ adjust_date_range (&min, &max); - pat->min = mutt_mktime (&min, 1); - pat->max = mutt_mktime (&max, 1); + pat->min = mktime(&min); + pat->max = mktime(&max); - FREE (&buffer.data); + p_delete(&buffer.data); return 0; } -static struct pattern_flags *lookup_tag (char tag) +static const struct pattern_flags *lookup_tag (char tag) { int i; for (i = 0; Flags[i].tag; i++) if (Flags[i].tag == tag) - return (&Flags[i]); + return &Flags[i]; return NULL; } -static /* const */ char *find_matching_paren ( /* const */ char *s) -{ - int level = 1; - - for (; *s; s++) { - if (*s == '(') - level++; - else if (*s == ')') { - level--; - if (!level) - break; - } - } - return s; -} - -void mutt_pattern_free (pattern_t ** pat) +static const char *find_matching_paren (const char *s) { - pattern_t *tmp; - - while (*pat) { - tmp = *pat; - *pat = (*pat)->next; + int level = 1; - if (tmp->rx) { - regfree (tmp->rx); - FREE (&tmp->rx); + for (; *s; s++) { + level += (*s == '(') - (*s == ')'); + if (!level) + break; } - if (tmp->child) - mutt_pattern_free (&tmp->child); - FREE (&tmp); - } + return s; } -pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) +pattern_t *mutt_pattern_comp(const char *s, int flags, BUFFER *err) { pattern_t *curlist = NULL; pattern_t *tmp; @@ -660,17 +637,17 @@ pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) int alladdr = 0; int or = 0; int implicit = 1; /* used to detect logical AND operator */ - struct pattern_flags *entry; + const struct pattern_flags *entry; char *p; char *buf; BUFFER ps; - memset (&ps, 0, sizeof (ps)); - ps.dptr = s; - ps.dsize = mutt_strlen (s); + p_clear(&ps, 1); + ps.dptr = s; + ps.dsize = m_strlen(s); while (*ps.dptr) { - SKIPWS (ps.dptr); + ps.dptr = vskipspaces(ps.dptr); switch (*ps.dptr) { case '^': ps.dptr++; @@ -689,7 +666,7 @@ pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) } if (curlist->next) { /* A & B | C == (A & B) | C */ - tmp = new_pattern (); + tmp = pattern_new(); tmp->op = M_AND; tmp->child = curlist; @@ -704,10 +681,12 @@ pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) not = 0; alladdr = 0; break; + case '=': + /* fallthrough */ case '~': if (implicit && or) { /* A | B & C == (A | B) & C */ - tmp = new_pattern (); + tmp = pattern_new(); tmp->op = M_OR; tmp->child = curlist; curlist = tmp; @@ -715,9 +694,10 @@ pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) or = 0; } - tmp = new_pattern (); + tmp = pattern_new(); tmp->not = not; tmp->alladdr = alladdr; + tmp->stringmatch = (*ps.dptr == '=') ? 1 : 0; not = 0; alladdr = 0; @@ -730,28 +710,27 @@ pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) ps.dptr++; /* move past the ~ */ if ((entry = lookup_tag (*ps.dptr)) == NULL) { snprintf (err->data, err->dsize, _("%c: invalid command"), *ps.dptr); - mutt_pattern_free (&curlist); + pattern_list_wipe(&curlist); return NULL; } if (entry->class && (flags & entry->class) == 0) { snprintf (err->data, err->dsize, _("%c: not supported in this mode"), *ps.dptr); - mutt_pattern_free (&curlist); + pattern_list_wipe(&curlist); return NULL; } tmp->op = entry->op; - ps.dptr++; /* eat the operator and any optional whitespace */ - SKIPWS (ps.dptr); + ps.dptr = vskipspaces(ps.dptr + 1); if (entry->eat_arg) { if (!*ps.dptr) { snprintf (err->data, err->dsize, _("missing parameter")); - mutt_pattern_free (&curlist); + pattern_list_wipe(&curlist); return NULL; } if (entry->eat_arg (tmp, &ps, err) == -1) { - mutt_pattern_free (&curlist); + pattern_list_wipe(&curlist); return NULL; } } @@ -762,17 +741,17 @@ pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) if (*p != ')') { snprintf (err->data, err->dsize, _("mismatched parenthesis: %s"), ps.dptr); - mutt_pattern_free (&curlist); + pattern_list_wipe(&curlist); return NULL; } /* compile the sub-expression */ - buf = str_substrdup (ps.dptr + 1, p); + buf = p_dupstr(ps.dptr + 1, p - ps.dptr - 1); if ((tmp = mutt_pattern_comp (buf, flags, err)) == NULL) { - FREE (&buf); - mutt_pattern_free (&curlist); + p_delete(&buf); + pattern_list_wipe(&curlist); return NULL; } - FREE (&buf); + p_delete(&buf); if (last) last->next = tmp; else @@ -786,21 +765,21 @@ pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) break; default: snprintf (err->data, err->dsize, _("error in pattern at: %s"), ps.dptr); - mutt_pattern_free (&curlist); + pattern_list_wipe(&curlist); return NULL; } } if (!curlist) { - strfcpy (err->data, _("empty pattern"), err->dsize); + m_strcpy(err->data, err->dsize, _("empty pattern")); return NULL; } if (curlist->next) { - tmp = new_pattern (); + tmp = pattern_new(); tmp->op = or ? M_OR : M_AND; tmp->child = curlist; curlist = tmp; } - return (curlist); + return curlist; } static int @@ -823,66 +802,66 @@ perform_or (struct pattern_t *pat, pattern_exec_flag flags, CONTEXT * ctx, return 0; } -static int match_adrlist (regex_t * rx, int match_personal, int alladdr, +static int match_adrlist (pattern_t* pat, int match_personal, int alladdr __attribute__ ((unused)), int n, ...) { va_list ap; - ADDRESS *a; + address_t *a; va_start (ap, n); for (; n; n--) { - for (a = va_arg (ap, ADDRESS *); a; a = a->next) { - if (alladdr ^ - ((a->mailbox && regexec (rx, a->mailbox, 0, NULL, 0) == 0) || + for (a = va_arg (ap, address_t *); a; a = a->next) { + if (pat->alladdr ^ + ((a->mailbox && patmatch (pat, a->mailbox) == 0) || (match_personal && a->personal && - regexec (rx, a->personal, 0, NULL, 0) == 0))) { + patmatch (pat, a->personal) == 0))) { va_end (ap); - return (!alladdr); /* Found match, or non-match if alladdr */ + return !pat->alladdr; /* Found match, or non-match if alladdr */ } } } va_end (ap); - return alladdr; /* No matches, or all matches if alladdr */ + return pat->alladdr; /* No matches, or all matches if alladdr */ } -static int match_reference (regex_t * rx, LIST * refs) +static int match_reference (pattern_t* pat, string_list_t * refs) { for (; refs; refs = refs->next) - if (regexec (rx, refs->data, 0, NULL, 0) == 0) + if (patmatch (pat, refs->data) == 0) return 1; return 0; } -int mutt_is_list_recipient (int alladdr, ADDRESS * a1, ADDRESS * a2) +int mutt_is_list_recipient (int alladdr, address_t * a1, address_t * a2) { for (; a1; a1 = a1->next) if (alladdr ^ mutt_is_subscribed_list (a1)) - return (!alladdr); + return !alladdr; for (; a2; a2 = a2->next) if (alladdr ^ mutt_is_subscribed_list (a2)) - return (!alladdr); + return !alladdr; return alladdr; } -int mutt_is_list_cc (int alladdr, ADDRESS * a1, ADDRESS * a2) +int mutt_is_list_cc (int alladdr, address_t * a1, address_t * a2) { for (; a1; a1 = a1->next) if (alladdr ^ mutt_is_mail_list (a1)) - return (!alladdr); + return !alladdr; for (; a2; a2 = a2->next) if (alladdr ^ mutt_is_mail_list (a2)) - return (!alladdr); + return !alladdr; return alladdr; } -static int match_user (int alladdr, ADDRESS * a1, ADDRESS * a2) +static int match_user (int alladdr, address_t * a1, address_t * a2) { for (; a1; a1 = a1->next) if (alladdr ^ mutt_addr_is_user (a1)) - return (!alladdr); + return !alladdr; for (; a2; a2 = a2->next) if (alladdr ^ mutt_addr_is_user (a2)) - return (!alladdr); + return !alladdr; return alladdr; } @@ -902,7 +881,7 @@ static int valid_realname (const char *name) ret--; p++; } - return (ret >= 1); + return ret >= 1; } /* flags @@ -911,35 +890,33 @@ int mutt_pattern_exec (struct pattern_t *pat, pattern_exec_flag flags, CONTEXT * ctx, HEADER * h) { - char buf[STRING]; - switch (pat->op) { case M_AND: - return (pat->not ^ (perform_and (pat->child, flags, ctx, h) > 0)); + return pat->not ^ (perform_and (pat->child, flags, ctx, h) > 0); case M_OR: - return (pat->not ^ (perform_or (pat->child, flags, ctx, h) > 0)); + return pat->not ^ (perform_or (pat->child, flags, ctx, h) > 0); case M_ALL: - return (!pat->not); + return !pat->not; case M_EXPIRED: - return (pat->not ^ h->expired); + return pat->not ^ h->expired; case M_SUPERSEDED: - return (pat->not ^ h->superseded); + return pat->not ^ h->superseded; case M_FLAG: - return (pat->not ^ h->flagged); + return pat->not ^ h->flagged; case M_TAG: - return (pat->not ^ h->tagged); + return pat->not ^ h->tagged; case M_NEW: - return (pat->not ? h->old || h->read : !(h->old || h->read)); + return pat->not ? h->old || h->read : !(h->old || h->read); case M_UNREAD: - return (pat->not ? h->read : !h->read); + return pat->not ? h->read : !h->read; case M_REPLIED: - return (pat->not ^ h->replied); + return pat->not ^ h->replied; case M_OLD: - return (pat->not ? (!h->old || h->read) : (h->old && !h->read)); + return pat->not ? (!h->old || h->read) : (h->old && !h->read); case M_READ: - return (pat->not ^ h->read); + return pat->not ^ h->read; case M_DELETED: - return (pat->not ^ h->deleted); + return pat->not ^ h->deleted; case M_MESSAGE: return (pat->not ^ (h->msgno >= pat->min - 1 && (pat->max == M_MAXRANGE || h->msgno <= @@ -948,34 +925,34 @@ mutt_pattern_exec (struct pattern_t *pat, pattern_exec_flag flags, return (pat-> not ^ (h->date_sent >= pat->min && h->date_sent <= pat->max)); case M_DATE_RECEIVED: - return (pat->not ^ (h->received >= pat->min && h->received <= pat->max)); + return pat->not ^ (h->received >= pat->min && h->received <= pat->max); case M_BODY: case M_HEADER: case M_WHOLE_MSG: - return (pat-> - not ^ msg_search (ctx, pat->rx, buf, sizeof (buf), pat->op, - h->msgno)); + /* IMAP search sets h->matched at search compile time */ + if (ctx->magic == M_IMAP && pat->stringmatch) + return h->matched; + return pat->not ^ msg_search (ctx, pat, h->msgno); case M_SENDER: - return (pat->not ^ match_adrlist (pat->rx, flags & M_MATCH_FULL_ADDRESS, + return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, pat->alladdr, 1, h->env->sender)); case M_FROM: - return (pat->not ^ match_adrlist (pat->rx, flags & M_MATCH_FULL_ADDRESS, + return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, pat->alladdr, 1, h->env->from)); case M_TO: - return (pat->not ^ match_adrlist (pat->rx, flags & M_MATCH_FULL_ADDRESS, + return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, pat->alladdr, 1, h->env->to)); case M_CC: - return (pat->not ^ match_adrlist (pat->rx, flags & M_MATCH_FULL_ADDRESS, + return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, pat->alladdr, 1, h->env->cc)); case M_SUBJECT: return (pat-> not ^ (h->env && h->env->subject - && regexec (pat->rx, h->env->subject, 0, NULL, 0) == 0)); + && patmatch (pat, h->env->subject) == 0)); case M_ID: return (pat-> not ^ (h->env && h->env->message_id - && regexec (pat->rx, h->env->message_id, 0, NULL, - 0) == 0)); + && patmatch (pat, h->env->message_id) == 0)); case M_SCORE: return (pat->not ^ (h->score >= pat->min && (pat->max == M_MAXRANGE || h->score <= pat->max))); @@ -985,21 +962,26 @@ mutt_pattern_exec (struct pattern_t *pat, pattern_exec_flag flags, && (pat->max == M_MAXRANGE || h->content->length <= pat->max))); case M_REFERENCE: - return (pat->not ^ match_reference (pat->rx, h->env->references)); + return pat->not ^ match_reference (pat, h->env->references); case M_ADDRESS: return (pat-> not ^ (h->env - && match_adrlist (pat->rx, flags & M_MATCH_FULL_ADDRESS, + && match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, pat->alladdr, 4, h->env->from, h->env->sender, h->env->to, h->env->cc))); case M_RECIPIENT: return (pat-> not ^ (h->env - && match_adrlist (pat->rx, flags & M_MATCH_FULL_ADDRESS, + && match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, pat->alladdr, 2, h->env->to, h->env->cc))); case M_LIST: + return (pat-> + not ^ (h->env + && mutt_is_list_cc (pat->alladdr, h->env->to, + h->env->cc))); + case M_SUBSCRIBED_LIST: return (pat-> not ^ (h->env && mutt_is_list_recipient (pat->alladdr, h->env->to, @@ -1012,37 +994,47 @@ mutt_pattern_exec (struct pattern_t *pat, pattern_exec_flag flags, return (pat-> not ^ (h->env && match_user (pat->alladdr, h->env->from, NULL))); case M_COLLAPSED: - return (pat->not ^ (h->collapsed && h->num_hidden > 1)); + return pat->not ^ (h->collapsed && h->num_hidden > 1); case M_CRYPT_SIGN: - if (!WithCrypto) - break; - return (pat->not ^ ((h->security & SIGN) ? 1 : 0)); + return pat->not ^ ((h->security & SIGN) ? 1 : 0); case M_CRYPT_VERIFIED: - if (!WithCrypto) - break; - return (pat->not ^ ((h->security & GOODSIGN) ? 1 : 0)); + return pat->not ^ ((h->security & GOODSIGN) ? 1 : 0); case M_CRYPT_ENCRYPT: - if (!WithCrypto) - break; - return (pat->not ^ ((h->security & ENCRYPT) ? 1 : 0)); + return pat->not ^ ((h->security & ENCRYPT) ? 1 : 0); case M_PGP_KEY: - if (!(WithCrypto & APPLICATION_PGP)) - break; return (pat->not ^ ((h->security & APPLICATION_PGP) && (h->security & PGPKEY))); case M_XLABEL: return (pat-> not ^ (h->env->x_label - && regexec (pat->rx, h->env->x_label, 0, NULL, 0) == 0)); + && patmatch (pat, h->env->x_label) == 0)); case M_HORMEL: return (pat-> not ^ (h->env->spam && h->env->spam->data - && regexec (pat->rx, h->env->spam->data, 0, NULL, - 0) == 0)); + && patmatch (pat, h->env->spam->data) == 0)); case M_DUPLICATED: - return (pat->not ^ (h->thread && h->thread->duplicate_thread)); + return pat->not ^ (h->thread && h->thread->duplicate_thread); + + case M_MIMEATTACH: + { + int count; + + if (h->content->parts) + count = mutt_count_body_parts(h, 0); + else { + mutt_parse_mime_message(ctx, h); + count = mutt_count_body_parts(h, 0); + body_list_wipe(&h->content->parts); + } + + return (pat->not ^ (count >= pat->min && (pat->max == M_MAXRANGE || + count <= pat->max))); + } + case M_UNREFERENCED: - return (pat->not ^ (h->thread && !h->thread->child)); + return pat->not ^ (h->thread && !h->thread->child); + case M_MULTIPART: + return pat->not ^ (h->content && h->content->type == TYPEMULTIPART); case M_REALNAME: /* realname filter: * we have a match if @@ -1050,32 +1042,21 @@ mutt_pattern_exec (struct pattern_t *pat, pattern_exec_flag flags, * - or we have an alias for current address * - or From: contains valid email address _and_ name has >= 2 fields */ - return (pat-> - not ^ (h->env && h->env->from && (mutt_addr_is_user (h->env->from) - || - (alias_reverse_lookup - (h->env->from) != NULL) - || (h->env->from->personal - && valid_realname (h->env-> - from-> - personal) - && h->env->from->mailbox) - ))); -#ifdef USE_NNTP - case M_NEWSGROUPS: - return (pat-> - not ^ (h->env->newsgroups - && regexec (pat->rx, h->env->newsgroups, 0, NULL, - 0) == 0)); -#endif + return (h->env && h->env->from + && (mutt_addr_is_user(h->env->from) + || alias_reverse_lookup(h->env->from) + || (h->env->from->personal + && valid_realname(h->env-> from->personal) + && h->env->from->mailbox) + )) ^ pat->not; } mutt_error (_("error: unknown op %d (report this error)."), pat->op); - return (-1); + return -1; } -static void quote_simple (char *tmp, size_t len, const char *p) +static void quote_simple (char *tmp, ssize_t len, const char *p) { - int i = 0; + ssize_t i = 0; tmp[i++] = '"'; while (*p && i < len - 3) { @@ -1088,7 +1069,7 @@ static void quote_simple (char *tmp, size_t len, const char *p) } /* convert a simple search into a real request */ -void mutt_check_simple (char *s, size_t len, const char *simple) +void mutt_check_simple (char *s, ssize_t len, const char *simple) { char tmp[LONG_STRING]; @@ -1096,59 +1077,61 @@ void mutt_check_simple (char *s, size_t len, const char *simple) * equivalences? */ - if (!strchr (s, '~')) { /* yup, so spoof a real request */ + if (!strchr (s, '~') && !strchr (s, '=')) { /* yup, so spoof a real request */ /* convert old tokens into the new format */ - if (ascii_strcasecmp ("all", s) == 0 || !mutt_strcmp ("^", s) || !mutt_strcmp (".", s)) /* ~A is more efficient */ - strfcpy (s, "~A", len); + if (ascii_strcasecmp ("all", s) == 0 || !m_strcmp("^", s) || !m_strcmp(".", s)) /* ~A is more efficient */ + m_strcpy(s, len, "~A"); else if (ascii_strcasecmp ("del", s) == 0) - strfcpy (s, "~D", len); + m_strcpy(s, len, "~D"); else if (ascii_strcasecmp ("flag", s) == 0) - strfcpy (s, "~F", len); + m_strcpy(s, len, "~F"); else if (ascii_strcasecmp ("new", s) == 0) - strfcpy (s, "~N", len); + m_strcpy(s, len, "~N"); else if (ascii_strcasecmp ("old", s) == 0) - strfcpy (s, "~O", len); + m_strcpy(s, len, "~O"); else if (ascii_strcasecmp ("repl", s) == 0) - strfcpy (s, "~Q", len); + m_strcpy(s, len, "~Q"); else if (ascii_strcasecmp ("read", s) == 0) - strfcpy (s, "~R", len); + m_strcpy(s, len, "~R"); else if (ascii_strcasecmp ("tag", s) == 0) - strfcpy (s, "~T", len); + m_strcpy(s, len, "~T"); else if (ascii_strcasecmp ("unread", s) == 0) - strfcpy (s, "~U", len); + m_strcpy(s, len, "~U"); else { quote_simple (tmp, sizeof (tmp), s); - mutt_expand_fmt (s, len, simple, tmp); + m_file_fmt(s, len, simple, tmp); } } } -int mutt_pattern_func (int op, char *prompt) +int mutt_pattern_func (int op, const char *prompt) { pattern_t *pat; char buf[LONG_STRING] = "", *simple, error[STRING]; BUFFER err; int i; - strfcpy (buf, NONULL (Context->pattern), sizeof (buf)); + m_strcpy(buf, sizeof(buf), NONULL(Context->pattern)); if (prompt || op != M_LIMIT) - if (mutt_get_field (prompt, buf, sizeof (buf), M_PATTERN | M_CLEAR) != 0 - || !buf[0]) - return (-1); + if (mutt_get_field (prompt, buf, sizeof (buf), M_PATTERN | M_CLEAR) != 0 || !buf[0]) + return -1; mutt_message _("Compiling search pattern..."); - simple = safe_strdup (buf); + simple = m_strdup(buf); mutt_check_simple (buf, sizeof (buf), NONULL (SimpleSearch)); err.data = error; err.dsize = sizeof (error); if ((pat = mutt_pattern_comp (buf, M_FULL_MSG, &err)) == NULL) { - FREE (&simple); + p_delete(&simple); mutt_error ("%s", err.data); - return (-1); + return -1; } + if (Context->magic == M_IMAP && imap_search (Context, pat) < 0) + return -1; + mutt_message _("Executing command on matching messages..."); #define THIS_BODY Context->hdrs[i]->content @@ -1203,29 +1186,23 @@ int mutt_pattern_func (int op, char *prompt) mutt_clear_error (); if (op == M_LIMIT) { - FREE (&Context->pattern); + /* drop previous limit pattern */ + p_delete(&Context->pattern); if (Context->limit_pattern) - mutt_pattern_free (&Context->limit_pattern); - if (!Context->vcount) { + pattern_list_wipe(&Context->limit_pattern); + if (Context->msgcount && !Context->vcount) { mutt_error _("No messages matched criteria."); - -#if 0 - Context->vcount = Context->msgcount; - /* restore full display */ - for (i = 0; i < Context->msgcount; i++) { - Context->hdrs[i]->virtual = i; - Context->v2r[i] = i; - } -#endif } - else if (safe_strncmp (buf, "~A", 2) != 0) { + + /* record new limit pattern, unless match all */ + if (m_strncmp(buf, "~A", 2) != 0) { Context->pattern = simple; simple = NULL; /* don't clobber it */ Context->limit_pattern = mutt_pattern_comp (buf, M_FULL_MSG, &err); } } - FREE (&simple); - mutt_pattern_free (&pat); + p_delete(&simple); + pattern_list_wipe(&pat); return 0; } @@ -1240,11 +1217,11 @@ int mutt_search_command (int cur, int op) HEADER *h; if (op != OP_SEARCH_NEXT && op != OP_SEARCH_OPPOSITE) { - strfcpy (buf, LastSearch, sizeof (buf)); + m_strcpy(buf, sizeof(buf), LastSearch); if (mutt_get_field ((op == OP_SEARCH) ? _("Search for: ") : _("Reverse search for: "), buf, sizeof (buf), M_CLEAR | M_PATTERN) != 0 || !buf[0]) - return (-1); + return -1; if (op == OP_SEARCH) unset_option (OPTSEARCHREVERSE); @@ -1253,21 +1230,21 @@ int mutt_search_command (int cur, int op) /* compare the *expanded* version of the search pattern in case $simple_search has changed while we were searching */ - strfcpy (temp, buf, sizeof (temp)); + m_strcpy(temp, sizeof(temp), buf); mutt_check_simple (temp, sizeof (temp), NONULL (SimpleSearch)); - if (!SearchPattern || mutt_strcmp (temp, LastSearchExpn)) { + if (!SearchPattern || m_strcmp(temp, LastSearchExpn)) { set_option (OPTSEARCHINVALID); - strfcpy (LastSearch, buf, sizeof (LastSearch)); + m_strcpy(LastSearch, sizeof(LastSearch), buf); mutt_message _("Compiling search pattern..."); - mutt_pattern_free (&SearchPattern); + pattern_list_wipe(&SearchPattern); err.data = error; err.dsize = sizeof (error); if ((SearchPattern = mutt_pattern_comp (temp, M_FULL_MSG, &err)) == NULL) { mutt_error ("%s", error); - return (-1); + return -1; } mutt_clear_error (); } @@ -1275,12 +1252,14 @@ int mutt_search_command (int cur, int op) else if (!SearchPattern) { mutt_error _("No search pattern."); - return (-1); + return -1; } if (option (OPTSEARCHINVALID)) { for (i = 0; i < Context->msgcount; i++) Context->hdrs[i]->searched = 0; + if (Context->magic == M_IMAP && imap_search (Context, SearchPattern) < 0) + return -1; unset_option (OPTSEARCHINVALID); } @@ -1297,7 +1276,7 @@ int mutt_search_command (int cur, int op) else { mutt_message _("Search hit bottom without finding match"); - return (-1); + return -1; } } else if (i < 0) { @@ -1308,7 +1287,7 @@ int mutt_search_command (int cur, int op) else { mutt_message _("Search hit top without finding match"); - return (-1); + return -1; } } @@ -1331,7 +1310,7 @@ int mutt_search_command (int cur, int op) mutt_error _("Search interrupted."); SigInt = 0; - return (-1); + return -1; } i += incr; @@ -1339,5 +1318,5 @@ int mutt_search_command (int cur, int op) mutt_error _("Not found."); - return (-1); + return -1; }