X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=pattern.c;h=35cdbd91f3e8bf419483f01c37e13dee8d1561e2;hp=c40f9cac6aa45cece8e663f519b5610a39548a94;hb=63b91e68a864bbd052b4b421cb77a0fd2a748ea4;hpb=ecaab35b973fbceb58b5ed174971c82762cc0199 diff --git a/pattern.c b/pattern.c index c40f9ca..35cdbd9 100644 --- a/pattern.c +++ b/pattern.c @@ -15,22 +15,20 @@ #include #include #include +#include +#include +#include + +#include #include "mutt.h" -#include "buffer.h" #include "handler.h" #include "enter.h" #include "mx.h" -#include "mapping.h" #include "keymap.h" #include "copy.h" -#include "mime.h" - -#ifdef USE_IMAP -#include "mx.h" -#include "imap/imap.h" -#endif +#include #include #include @@ -39,7 +37,7 @@ #include #include -#include "mutt_crypt.h" +#include static int eat_regexp (pattern_t * pat, BUFFER *, BUFFER *); static int eat_date (pattern_t * pat, BUFFER *, BUFFER *); @@ -158,12 +156,12 @@ msg_search (CONTEXT *ctx, pattern_t* pat, int msgno) int match = 0; HEADER *h = ctx->hdrs[msgno]; char* buf; - size_t blen; + 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); @@ -178,8 +176,8 @@ msg_search (CONTEXT *ctx, pattern_t* pat, int msgno) if (pat->op != M_HEADER) { mutt_parse_mime_message (ctx, h); - if (WithCrypto && (h->security & ENCRYPT) - && !crypt_valid_passphrase (h->security)) { + if ((h->security & ENCRYPT) && !crypt_valid_passphrase (h->security)) + { mx_close_message (&msg); if (fp) { fclose (fp); @@ -217,7 +215,7 @@ msg_search (CONTEXT *ctx, pattern_t* pat, int msgno) /* search the file "fp" */ while (lng > 0) { if (pat->op == M_HEADER) { - if (*(buf = mutt_read_rfc822_line (fp, buf, &blen)) == '\0') + if (!mutt_read_rfc822_line(fp, &buf, &blen)) break; } else if (fgets (buf, blen - 1, fp) == NULL) break; /* don't loop forever */ @@ -246,7 +244,7 @@ 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) { @@ -289,7 +287,7 @@ static int patmatch (const pattern_t* pat, const char* buf) { return regexec (pat->rx, buf, 0, NULL, 0); } -int eat_range (pattern_t * pat, BUFFER * s, BUFFER * err) +int eat_range (pattern_t * pat, BUFFER * s, BUFFER * err __attribute__ ((unused))) { char *tmp; int do_exclusive = 0; @@ -358,8 +356,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; } @@ -467,7 +464,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 '-': { @@ -523,7 +520,7 @@ 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); @@ -536,21 +533,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); + 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 @@ -607,11 +604,11 @@ static int eat_date (pattern_t * pat, BUFFER * s, BUFFER * err) 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'); } } @@ -712,12 +709,12 @@ pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) char *buf; BUFFER ps; - memset (&ps, 0, sizeof (ps)); + 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++; @@ -791,8 +788,7 @@ pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) } 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) { @@ -816,7 +812,7 @@ pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) 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) { p_delete(&buf); mutt_pattern_free (&curlist); @@ -841,7 +837,7 @@ pattern_t *mutt_pattern_comp ( /* const */ char *s, int flags, BUFFER * err) } } if (!curlist) { - strfcpy (err->data, _("empty pattern"), err->dsize); + m_strcpy(err->data, err->dsize, _("empty pattern")); return NULL; } if (curlist->next) { @@ -873,15 +869,15 @@ perform_or (struct pattern_t *pat, pattern_exec_flag flags, CONTEXT * ctx, return 0; } -static int match_adrlist (pattern_t* pat, 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) { + 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 && @@ -903,7 +899,7 @@ static int match_reference (pattern_t* pat, LIST * refs) 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)) @@ -914,7 +910,7 @@ int mutt_is_list_recipient (int alladdr, ADDRESS * a1, ADDRESS * a2) 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)) @@ -925,7 +921,7 @@ int mutt_is_list_cc (int alladdr, ADDRESS * a1, ADDRESS * a2) 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)) @@ -1000,11 +996,9 @@ mutt_pattern_exec (struct pattern_t *pat, pattern_exec_flag flags, case M_BODY: case M_HEADER: case M_WHOLE_MSG: -#ifdef USE_IMAP /* IMAP search sets h->matched at search compile time */ if (ctx->magic == M_IMAP && pat->stringmatch) return (h->matched); -#endif return (pat->not ^ msg_search (ctx, pat, h->msgno)); case M_SENDER: return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, @@ -1069,20 +1063,12 @@ mutt_pattern_exec (struct pattern_t *pat, pattern_exec_flag flags, case M_COLLAPSED: return (pat->not ^ (h->collapsed && h->num_hidden > 1)); case M_CRYPT_SIGN: - if (!WithCrypto) - break; return (pat->not ^ ((h->security & SIGN) ? 1 : 0)); case M_CRYPT_VERIFIED: - if (!WithCrypto) - break; return (pat->not ^ ((h->security & GOODSIGN) ? 1 : 0)); case M_CRYPT_ENCRYPT: - if (!WithCrypto) - break; 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: @@ -1145,9 +1131,9 @@ mutt_pattern_exec (struct pattern_t *pat, pattern_exec_flag flags, 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) { @@ -1170,24 +1156,24 @@ void mutt_check_simple (char *s, size_t len, const char *simple) if (!strchr (s, '~') && !strchr (s, '=')) { /* yup, so spoof a real request */ /* convert old tokens into the new format */ - if (ascii_strcasecmp ("all", s) == 0 || !str_cmp ("^", s) || !str_cmp (".", 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); @@ -1202,7 +1188,7 @@ int mutt_pattern_func (int op, char *prompt) 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); @@ -1220,10 +1206,8 @@ int mutt_pattern_func (int op, char *prompt) return (-1); } -#ifdef USE_IMAP if (Context->magic == M_IMAP && imap_search (Context, pat) < 0) return -1; -#endif mutt_message _("Executing command on matching messages..."); @@ -1288,7 +1272,7 @@ int mutt_pattern_func (int op, char *prompt) } /* record new limit pattern, unless match all */ - if (str_ncmp (buf, "~A", 2) != 0) { + 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); @@ -1310,7 +1294,7 @@ 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]) @@ -1323,12 +1307,12 @@ 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 || str_cmp (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); @@ -1351,10 +1335,8 @@ int mutt_search_command (int cur, int op) if (option (OPTSEARCHINVALID)) { for (i = 0; i < Context->msgcount; i++) Context->hdrs[i]->searched = 0; -#ifdef USE_IMAP if (Context->magic == M_IMAP && imap_search (Context, SearchPattern) < 0) return -1; -#endif unset_option (OPTSEARCHINVALID); }