X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=muttlib.c;h=06767293648d35f6c522450c3be1b3f7794c1a1f;hp=0340d20d67a4ad9987de509e74056abd0c50238f;hb=b2a6a9673e124c222f921650a6f0025b64ab2145;hpb=079475507f097b263fcd3037c8ee10f4b0dae325 diff --git a/muttlib.c b/muttlib.c index 0340d20..0676729 100644 --- a/muttlib.c +++ b/muttlib.c @@ -1,21 +1,12 @@ /* + * Copyright notice from original mutt: * Copyright (C) 1996-2000 Michael R. Elkins * Copyright (C) 1999-2000 Thomas Roessler - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. - */ + * + * This file is part of mutt-ng, see http://www.muttng.org/. + * It's licensed under the GNU General Public License, + * please see the file GPL in the top level source directory. + */ #if HAVE_CONFIG_H # include "config.h" @@ -24,7 +15,6 @@ #include "mutt.h" #include "mutt_curses.h" #include "mime.h" -#include "mailbox.h" #include "mx.h" #include "url.h" @@ -32,10 +22,15 @@ #ifdef USE_IMAP #include "imap.h" +#include "imap/mx_imap.h" #endif #include "mutt_crypt.h" +#include "lib/mem.h" +#include "lib/intl.h" +#include "lib/str.h" + #include #include #include @@ -51,7 +46,7 @@ BODY *mutt_new_body (void) { BODY *p = (BODY *) safe_calloc (1, sizeof (BODY)); - + p->disposition = DISPATTACH; p->use_disp = 1; return (p); @@ -71,16 +66,14 @@ void mutt_adv_mktemp (char *s, size_t l) char *period; size_t sl; struct stat sb; - + strfcpy (buf, NONULL (Tempdir), sizeof (buf)); mutt_expand_path (buf, sizeof (buf)); - if (s[0] == '\0') - { + if (s[0] == '\0') { snprintf (s, l, "%s/muttXXXXXX", buf); mktemp (s); } - else - { + else { strfcpy (tmp, s, sizeof (tmp)); mutt_sanitize_filename (tmp, 1); snprintf (s, l, "%s/%s", buf, tmp); @@ -90,33 +83,30 @@ void mutt_adv_mktemp (char *s, size_t l) *period = 0; snprintf (s, l, "%s/%s.XXXXXX", buf, tmp); mktemp (s); - if (period != NULL) - { + if (period != NULL) { *period = '.'; - sl = mutt_strlen(s); - strfcpy(s + sl, period, l - sl); + sl = safe_strlen (s); + strfcpy (s + sl, period, l - sl); } } } /* create a send-mode duplicate from a receive-mode body */ -int mutt_copy_body (FILE *fp, BODY **tgt, BODY *src) +int mutt_copy_body (FILE * fp, BODY ** tgt, BODY * src) { char tmp[_POSIX_PATH_MAX]; BODY *b; PARAMETER *par, **ppar; - + short use_disp; - if (src->filename) - { + if (src->filename) { use_disp = 1; strfcpy (tmp, src->filename, sizeof (tmp)); } - else - { + else { use_disp = 0; tmp[0] = '\0'; } @@ -124,13 +114,13 @@ int mutt_copy_body (FILE *fp, BODY **tgt, BODY *src) mutt_adv_mktemp (tmp, sizeof (tmp)); if (mutt_save_attachment (fp, src, tmp, 0, NULL) == -1) return -1; - + *tgt = mutt_new_body (); b = *tgt; memcpy (b, src, sizeof (BODY)); b->parts = NULL; - b->next = NULL; + b->next = NULL; b->filename = safe_strdup (tmp); b->use_disp = use_disp; @@ -151,41 +141,42 @@ int mutt_copy_body (FILE *fp, BODY **tgt, BODY *src) * XXX - this may change in the future */ - if (b->hdr) b->hdr = NULL; - + if (b->hdr) + b->hdr = NULL; + /* copy parameters */ - for (par = b->parameter, ppar = &b->parameter; par; ppar = &(*ppar)->next, par = par->next) - { + for (par = b->parameter, ppar = &b->parameter; par; + ppar = &(*ppar)->next, par = par->next) { *ppar = mutt_new_parameter (); (*ppar)->attribute = safe_strdup (par->attribute); (*ppar)->value = safe_strdup (par->value); } mutt_stamp_attachment (b); - + return 0; } -void mutt_free_body (BODY **p) +void mutt_free_body (BODY ** p) { BODY *a = *p, *b; - while (a) - { + while (a) { b = a; - a = a->next; + a = a->next; if (b->parameter) mutt_free_parameter (&b->parameter); - if (b->unlink && b->filename) - { + if (b->unlink && b->filename) { dprint (1, (debugfile, "mutt_free_body: Unlinking %s.\n", b->filename)); unlink (b->filename); } - else if (b->filename) - dprint (1, (debugfile, "mutt_free_body: Not unlinking %s.\n", b->filename)); + else if (b->filename) + dprint (1, + (debugfile, "mutt_free_body: Not unlinking %s.\n", + b->filename)); FREE (&b->filename); FREE (&b->content); @@ -194,11 +185,10 @@ void mutt_free_body (BODY **p) FREE (&b->description); FREE (&b->form_name); - if (b->hdr) - { + if (b->hdr) { /* Don't free twice (b->hdr->content = b->parts) */ b->hdr->content = NULL; - mutt_free_header(&b->hdr); + mutt_free_header (&b->hdr); } if (b->parts) @@ -210,13 +200,12 @@ void mutt_free_body (BODY **p) *p = 0; } -void mutt_free_parameter (PARAMETER **p) +void mutt_free_parameter (PARAMETER ** p) { PARAMETER *t = *p; PARAMETER *o; - while (t) - { + while (t) { FREE (&t->attribute); FREE (&t->value); o = t; @@ -226,14 +215,12 @@ void mutt_free_parameter (PARAMETER **p) *p = 0; } -LIST *mutt_add_list (LIST *head, const char *data) +LIST *mutt_add_list (LIST * head, const char *data) { LIST *tmp; - for (tmp = head; tmp && tmp->next; tmp = tmp->next) - ; - if (tmp) - { + for (tmp = head; tmp && tmp->next; tmp = tmp->next); + if (tmp) { tmp->next = safe_malloc (sizeof (LIST)); tmp = tmp->next; } @@ -245,13 +232,13 @@ LIST *mutt_add_list (LIST *head, const char *data) return head; } -void mutt_free_list (LIST **list) +void mutt_free_list (LIST ** list) { LIST *p; - - if (!list) return; - while (*list) - { + + if (!list) + return; + while (*list) { p = *list; *list = (*list)->next; FREE (&p->data); @@ -259,18 +246,19 @@ void mutt_free_list (LIST **list) } } -HEADER *mutt_dup_header(HEADER *h) +HEADER *mutt_dup_header (HEADER * h) { HEADER *hnew; - hnew = mutt_new_header(); - memcpy(hnew, h, sizeof (HEADER)); + hnew = mutt_new_header (); + memcpy (hnew, h, sizeof (HEADER)); return hnew; } -void mutt_free_header (HEADER **h) +void mutt_free_header (HEADER ** h) { - if(!h || !*h) return; + if (!h || !*h) + return; mutt_free_envelope (&(*h)->env); mutt_free_body (&(*h)->content); FREE (&(*h)->maildir_flags); @@ -286,11 +274,11 @@ void mutt_free_header (HEADER **h) } /* returns true if the header contained in "s" is in list "t" */ -int mutt_matches_ignore (const char *s, LIST *t) +int mutt_matches_ignore (const char *s, LIST * t) { - for (; t; t = t->next) - { - if (!ascii_strncasecmp (s, t->data, mutt_strlen (t->data)) || *t->data == '*') + for (; t; t = t->next) { + if (!ascii_strncasecmp (s, t->data, safe_strlen (t->data)) + || *t->data == '*') return 1; } return 0; @@ -303,14 +291,12 @@ void mutt_expand_link (char *newpath, const char *path, const char *link) size_t len; /* link is full path */ - if (*link == '/') - { + if (*link == '/') { strfcpy (newpath, link, _POSIX_PATH_MAX); return; } - if ((lb = strrchr (path, '/')) == NULL) - { + if ((lb = strrchr (path, '/')) == NULL) { /* no path in link */ strfcpy (newpath, link, _POSIX_PATH_MAX); return; @@ -333,144 +319,141 @@ char *_mutt_expand_path (char *s, size_t slen, int rx) char tmp[_POSIX_PATH_MAX]; char *t; - char *tail = ""; + char *tail = ""; int recurse = 0; - - do - { + + do { recurse = 0; - switch (*s) - { - case '~': + switch (*s) { + case '~': { - if (*(s + 1) == '/' || *(s + 1) == 0) - { - strfcpy (p, NONULL(Homedir), sizeof (p)); - tail = s + 1; - } - else - { - struct passwd *pw; - if ((t = strchr (s + 1, '/'))) - *t = 0; - - if ((pw = getpwnam (s + 1))) - { - strfcpy (p, pw->pw_dir, sizeof (p)); - if (t) - { - *t = '/'; - tail = t; - } - else - tail = ""; - } - else - { - /* user not found! */ - if (t) - *t = '/'; - *p = '\0'; - tail = s; - } - } + if (*(s + 1) == '/' || *(s + 1) == 0) { + strfcpy (p, NONULL (Homedir), sizeof (p)); + tail = s + 1; + } + else { + struct passwd *pw; + + if ((t = strchr (s + 1, '/'))) + *t = 0; + + if ((pw = getpwnam (s + 1))) { + strfcpy (p, pw->pw_dir, sizeof (p)); + if (t) { + *t = '/'; + tail = t; + } + else + tail = ""; + } + else { + /* user not found! */ + if (t) + *t = '/'; + *p = '\0'; + tail = s; + } + } } break; - - case '=': - case '+': + + case '=': + case '+': { #ifdef USE_IMAP - /* if folder = {host} or imap[s]://host/: don't append slash */ - if (mx_is_imap (NONULL (Maildir)) && - (Maildir[strlen (Maildir) - 1] == '}' || - Maildir[strlen (Maildir) - 1] == '/')) - strfcpy (p, NONULL (Maildir), sizeof (p)); - else + /* if folder = {host} or imap[s]://host/: don't append slash */ + if (imap_is_magic (NONULL (Maildir), NULL) == M_IMAP && + (Maildir[safe_strlen (Maildir) - 1] == '}' || + Maildir[safe_strlen (Maildir) - 1] == '/')) + strfcpy (p, NONULL (Maildir), sizeof (p)); + else #endif - snprintf (p, sizeof (p), "%s/", NONULL (Maildir)); - - tail = s + 1; + snprintf (p, sizeof (p), "%s/", NONULL (Maildir)); + + tail = s + 1; } break; - + /* elm compatibility, @ expands alias to user name */ - - case '@': + + case '@': { - HEADER *h; - ADDRESS *alias; - - if ((alias = mutt_lookup_alias (s + 1))) - { - h = mutt_new_header(); - h->env = mutt_new_envelope(); - h->env->from = h->env->to = alias; - mutt_default_save (p, sizeof (p), h); - h->env->from = h->env->to = NULL; - mutt_free_header (&h); - /* Avoid infinite recursion if the resulting folder starts with '@' */ - if (*p != '@') - recurse = 1; - - tail = ""; - } + HEADER *h; + ADDRESS *alias; + + if ((alias = mutt_lookup_alias (s + 1))) { + h = mutt_new_header (); + h->env = mutt_new_envelope (); + h->env->from = h->env->to = alias; + mutt_default_save (p, sizeof (p), h); + h->env->from = h->env->to = NULL; + mutt_free_header (&h); + /* Avoid infinite recursion if the resulting folder starts with '@' */ + if (*p != '@') + recurse = 1; + + tail = ""; + } } break; - - case '>': + + case '>': { - strfcpy (p, NONULL(Inbox), sizeof (p)); - tail = s + 1; + strfcpy (p, NONULL (Inbox), sizeof (p)); + tail = s + 1; } break; - - case '<': + + case '<': { - strfcpy (p, NONULL(Outbox), sizeof (p)); - tail = s + 1; + strfcpy (p, NONULL (Outbox), sizeof (p)); + tail = s + 1; } break; - - case '!': + + case '!': { - if (*(s+1) == '!') - { - strfcpy (p, NONULL(LastFolder), sizeof (p)); - tail = s + 2; - } - else - { - strfcpy (p, NONULL(Spoolfile), sizeof (p)); - tail = s + 1; - } + if (*(s + 1) == '!') { + strfcpy (p, NONULL (LastFolder), sizeof (p)); + tail = s + 2; + } + else { + strfcpy (p, NONULL (Spoolfile), sizeof (p)); + tail = s + 1; + } } break; - - case '-': + + case '-': { - strfcpy (p, NONULL(LastFolder), sizeof (p)); - tail = s + 1; + strfcpy (p, NONULL (LastFolder), sizeof (p)); + tail = s + 1; } break; - - default: + + case '^': + { + strfcpy (p, NONULL (CurrentFolder), sizeof (p)); + tail = s + 1; + } + break; + + default: { - *p = '\0'; - tail = s; + *p = '\0'; + tail = s; } } - if (rx && *p && !recurse) - { + if (rx && *p && !recurse) { mutt_rx_sanitize_string (q, sizeof (q), p); snprintf (tmp, sizeof (tmp), "%s%s", q, tail); } else snprintf (tmp, sizeof (tmp), "%s%s", p, tail); - + strfcpy (s, tmp, slen); } while (recurse); @@ -478,7 +461,7 @@ char *_mutt_expand_path (char *s, size_t slen, int rx) #ifdef USE_IMAP /* Rewrite IMAP path in canonical form - aids in string comparisons of * folders. May possibly fail, in which case s should be the same. */ - if (mx_is_imap (s)) + if (imap_is_magic (s, NULL) == M_IMAP) imap_expand_path (s, slen); #endif @@ -499,41 +482,38 @@ char *mutt_gecos_name (char *dest, size_t destlen, struct passwd *pw) size_t pwnl; int idx; char *p; - - if (!pw || !pw->pw_gecos) + + if (!pw || !pw->pw_gecos) return NULL; memset (dest, 0, destlen); - - if (GecosMask.rx) - { + + if (GecosMask.rx) { if (regexec (GecosMask.rx, pw->pw_gecos, 1, pat_match, 0) == 0) - strfcpy (dest, pw->pw_gecos + pat_match[0].rm_so, - MIN (pat_match[0].rm_eo - pat_match[0].rm_so + 1, destlen)); + strfcpy (dest, pw->pw_gecos + pat_match[0].rm_so, + MIN (pat_match[0].rm_eo - pat_match[0].rm_so + 1, destlen)); } else if ((p = strchr (pw->pw_gecos, ','))) strfcpy (dest, pw->pw_gecos, MIN (destlen, p - pw->pw_gecos + 1)); else strfcpy (dest, pw->pw_gecos, destlen); - pwnl = strlen (pw->pw_name); + pwnl = safe_strlen (pw->pw_name); - for (idx = 0; dest[idx]; idx++) - { - if (dest[idx] == '&') - { + for (idx = 0; dest[idx]; idx++) { + if (dest[idx] == '&') { memmove (&dest[idx + pwnl], &dest[idx + 1], - MAX(destlen - idx - pwnl - 1, 0)); - memcpy (&dest[idx], pw->pw_name, MIN(destlen - idx - 1, pwnl)); + MAX (destlen - idx - pwnl - 1, 0)); + memcpy (&dest[idx], pw->pw_name, MIN (destlen - idx - 1, pwnl)); dest[idx] = toupper ((unsigned char) dest[idx]); } } - + return dest; } - -char *mutt_get_parameter (const char *s, PARAMETER *p) + +char *mutt_get_parameter (const char *s, PARAMETER * p) { for (; p; p = p->next) if (ascii_strcasecmp (s, p->attribute) == 0) @@ -542,40 +522,36 @@ char *mutt_get_parameter (const char *s, PARAMETER *p) return NULL; } -void mutt_set_parameter (const char *attribute, const char *value, PARAMETER **p) +void mutt_set_parameter (const char *attribute, const char *value, + PARAMETER ** p) { PARAMETER *q; - if (!value) - { + if (!value) { mutt_delete_parameter (attribute, p); return; } - - for(q = *p; q; q = q->next) - { - if (ascii_strcasecmp (attribute, q->attribute) == 0) - { - mutt_str_replace (&q->value, value); + + for (q = *p; q; q = q->next) { + if (ascii_strcasecmp (attribute, q->attribute) == 0) { + str_replace (&q->value, value); return; } } - - q = mutt_new_parameter(); - q->attribute = safe_strdup(attribute); - q->value = safe_strdup(value); + + q = mutt_new_parameter (); + q->attribute = safe_strdup (attribute); + q->value = safe_strdup (value); q->next = *p; *p = q; } -void mutt_delete_parameter (const char *attribute, PARAMETER **p) +void mutt_delete_parameter (const char *attribute, PARAMETER ** p) { PARAMETER *q; - - for (q = *p; q; p = &q->next, q = q->next) - { - if (ascii_strcasecmp (attribute, q->attribute) == 0) - { + + for (q = *p; q; p = &q->next, q = q->next) { + if (ascii_strcasecmp (attribute, q->attribute) == 0) { *p = q->next; q->next = NULL; mutt_free_parameter (&q); @@ -585,52 +561,49 @@ void mutt_delete_parameter (const char *attribute, PARAMETER **p) } /* returns 1 if Mutt can't display this type of data, 0 otherwise */ -int mutt_needs_mailcap (BODY *m) +int mutt_needs_mailcap (BODY * m) { - switch (m->type) - { - case TYPETEXT: - - if (!ascii_strcasecmp ("plain", m->subtype) || - !ascii_strcasecmp ("rfc822-headers", m->subtype) || - !ascii_strcasecmp ("enriched", m->subtype)) - return 0; - break; + switch (m->type) { + case TYPETEXT: - case TYPEAPPLICATION: - if((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp(m)) - return 0; - if((WithCrypto & APPLICATION_SMIME) && mutt_is_application_smime(m)) - return 0; - break; + if (!ascii_strcasecmp ("plain", m->subtype) || + !ascii_strcasecmp ("rfc822-headers", m->subtype) || + !ascii_strcasecmp ("enriched", m->subtype)) + return 0; + break; - case TYPEMULTIPART: - case TYPEMESSAGE: + case TYPEAPPLICATION: + if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp (m)) + return 0; + if ((WithCrypto & APPLICATION_SMIME) && mutt_is_application_smime (m)) return 0; + break; + + case TYPEMULTIPART: + case TYPEMESSAGE: + return 0; } return 1; } -int mutt_is_text_part (BODY *b) +int mutt_is_text_part (BODY * b) { int t = b->type; char *s = b->subtype; - + if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp (b)) return 0; if (t == TYPETEXT) return 1; - if (t == TYPEMESSAGE) - { + if (t == TYPEMESSAGE) { if (!ascii_strcasecmp ("delivery-status", s)) return 1; } - if ((WithCrypto & APPLICATION_PGP) && t == TYPEAPPLICATION) - { + if ((WithCrypto & APPLICATION_PGP) && t == TYPEAPPLICATION) { if (!ascii_strcasecmp ("pgp-keys", s)) return 1; } @@ -638,9 +611,10 @@ int mutt_is_text_part (BODY *b) return 0; } -void mutt_free_envelope (ENVELOPE **p) +void mutt_free_envelope (ENVELOPE ** p) { - if (!*p) return; + if (!*p) + return; rfc822_free_address (&(*p)->return_path); rfc822_free_address (&(*p)->from); rfc822_free_address (&(*p)->to); @@ -674,17 +648,18 @@ void mutt_free_envelope (ENVELOPE **p) void _mutt_mktemp (char *s, const char *src, int line) { - snprintf (s, _POSIX_PATH_MAX, "%s/mutt-%s-%d-%d-%d", NONULL (Tempdir), NONULL(Hostname), (int) getuid(), (int) getpid (), Counter++); - dprint (1, (debugfile, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, s)); + snprintf (s, _POSIX_PATH_MAX, "%s/muttng-%s-%d-%d-%d", NONULL (Tempdir), + NONULL (Hostname), (int) getuid (), (int) getpid (), Counter++); + dprint (1, + (debugfile, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, s)); unlink (s); } -void mutt_free_alias (ALIAS **p) +void mutt_free_alias (ALIAS ** p) { ALIAS *t; - while (*p) - { + while (*p) { t = *p; *p = (*p)->next; FREE (&t->name); @@ -703,34 +678,29 @@ void mutt_pretty_mailbox (char *s) scheme = url_check_scheme (s); #ifdef USE_IMAP - if (scheme == U_IMAP || scheme == U_IMAPS) - { + if (scheme == U_IMAP || scheme == U_IMAPS) { imap_pretty_mailbox (s); return; } #endif /* if s is an url, only collapse path component */ - if (scheme != U_UNKNOWN) - { - p = strchr(s, ':')+1; + if (scheme != U_UNKNOWN) { + p = strchr (s, ':') + 1; if (!strncmp (p, "//", 2)) - q = strchr (p+2, '/'); + q = strchr (p + 2, '/'); if (!q) q = strchr (p, '\0'); p = q; } - + /* first attempt to collapse the pathname */ - while (*p) - { - if (*p == '/' && p[1] == '/') - { + while (*p) { + if (*p == '/' && p[1] == '/') { *q++ = '/'; p += 2; } - else if (p[0] == '/' && p[1] == '.' && p[2] == '/') - { + else if (p[0] == '/' && p[1] == '.' && p[2] == '/') { *q++ = '/'; p += 3; } @@ -739,17 +709,15 @@ void mutt_pretty_mailbox (char *s) } *q = 0; - if (mutt_strncmp (s, Maildir, (len = mutt_strlen (Maildir))) == 0 && - s[len] == '/') - { + if (safe_strncmp (s, Maildir, (len = safe_strlen (Maildir))) == 0 && + s[len] == '/') { *s++ = '='; - memmove (s, s + len, mutt_strlen (s + len) + 1); + memmove (s, s + len, safe_strlen (s + len) + 1); } - else if (mutt_strncmp (s, Homedir, (len = mutt_strlen (Homedir))) == 0 && - s[len] == '/') - { + else if (safe_strncmp (s, Homedir, (len = safe_strlen (Homedir))) == 0 && + s[len] == '/') { *s++ = '~'; - memmove (s, s + len - 1, mutt_strlen (s + len - 1) + 1); + memmove (s, s + len - 1, safe_strlen (s + len - 1) + 1); } } @@ -757,83 +725,80 @@ void mutt_pretty_size (char *s, size_t len, long n) { if (n == 0) strfcpy (s, "0K", len); - else if (n < 10189) /* 0.1K - 9.9K */ + else if (n < 10189) /* 0.1K - 9.9K */ snprintf (s, len, "%3.1fK", (n < 103) ? 0.1 : n / 1024.0); - else if (n < 1023949) /* 10K - 999K */ - { + else if (n < 1023949) { /* 10K - 999K */ /* 51 is magic which causes 10189/10240 to be rounded up to 10 */ snprintf (s, len, "%ldK", (n + 51) / 1024); } - else if (n < 10433332) /* 1.0M - 9.9M */ + else if (n < 10433332) /* 1.0M - 9.9M */ snprintf (s, len, "%3.1fM", n / 1048576.0); - else /* 10M+ */ - { + else { /* 10M+ */ + /* (10433332 + 52428) / 1048576 = 10 */ snprintf (s, len, "%ldM", (n + 52428) / 1048576); } } -void mutt_expand_file_fmt (char *dest, size_t destlen, const char *fmt, const char *src) +void mutt_expand_file_fmt (char *dest, size_t destlen, const char *fmt, + const char *src) { char tmp[LONG_STRING]; - + mutt_quote_filename (tmp, sizeof (tmp), src); mutt_expand_fmt (dest, destlen, fmt, tmp); } -void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt, const char *src) +void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt, + const char *src) { const char *p; char *d; size_t slen; int found = 0; - slen = mutt_strlen (src); + slen = safe_strlen (src); destlen--; - - for (p = fmt, d = dest; destlen && *p; p++) - { - if (*p == '%') - { - switch (p[1]) - { - case '%': - *d++ = *p++; - destlen--; - break; - case 's': - found = 1; - strfcpy (d, src, destlen + 1); - d += destlen > slen ? slen : destlen; - destlen -= destlen > slen ? slen : destlen; - p++; - break; - default: - *d++ = *p; - destlen--; - break; + + for (p = fmt, d = dest; destlen && *p; p++) { + if (*p == '%') { + switch (p[1]) { + case '%': + *d++ = *p++; + destlen--; + break; + case 's': + found = 1; + strfcpy (d, src, destlen + 1); + d += destlen > slen ? slen : destlen; + destlen -= destlen > slen ? slen : destlen; + p++; + break; + default: + *d++ = *p; + destlen--; + break; } } - else - { + else { *d++ = *p; destlen--; } } - + *d = '\0'; - - if (!found && destlen > 0) - { + + if (!found && destlen > 0) { safe_strcat (dest, destlen, " "); safe_strcat (dest, destlen, src); } - + } /* return 0 on success, -1 on abort, 1 on error */ int mutt_check_overwrite (const char *attname, const char *path, - char *fname, size_t flen, int *append, char **directory) + char *fname, size_t flen, int *append, + char **directory) { int rc = 0; char tmp[_POSIX_PATH_MAX]; @@ -844,82 +809,79 @@ int mutt_check_overwrite (const char *attname, const char *path, return 0; if (stat (fname, &st) != 0) return -1; - if (S_ISDIR (st.st_mode)) - { - if (directory) - { + if (S_ISDIR (st.st_mode)) { + if (directory) { switch (mutt_multi_choice - (_("File is a directory, save under it? [(y)es, (n)o, (a)ll]"), _("yna"))) - { - case 3: /* all */ - mutt_str_replace (directory, fname); - break; - case 1: /* yes */ - FREE (directory); - break; - case -1: /* abort */ - FREE (directory); - return -1; - case 2: /* no */ - FREE (directory); - return 1; + (_("File is a directory, save under it? [(y)es, (n)o, (a)ll]"), + _("yna"))) { + case 3: /* all */ + str_replace (directory, fname); + break; + case 1: /* yes */ + FREE (directory); + break; + case -1: /* abort */ + FREE (directory); + return -1; + case 2: /* no */ + FREE (directory); + return 1; } } - else if ((rc = mutt_yesorno (_("File is a directory, save under it?"), M_YES)) != M_YES) + else + if ((rc = + mutt_yesorno (_("File is a directory, save under it?"), + M_YES)) != M_YES) return (rc == M_NO) ? 1 : -1; - if (!attname || !attname[0]) - { + if (!attname || !attname[0]) { tmp[0] = 0; if (mutt_get_field (_("File under directory: "), tmp, sizeof (tmp), - M_FILE | M_CLEAR) != 0 || !tmp[0]) - return (-1); + M_FILE | M_CLEAR) != 0 || !tmp[0]) + return (-1); mutt_concat_path (fname, path, tmp, flen); } else mutt_concat_path (fname, path, mutt_basename (attname), flen); } - - if (*append == 0 && access (fname, F_OK) == 0) - { + + if (*append == 0 && access (fname, F_OK) == 0) { switch (mutt_multi_choice - (_("File exists, (o)verwrite, (a)ppend, or (c)ancel?"), _("oac"))) + (_("File exists, (o)verwrite, (a)ppend, or (c)ancel?"), _("oac"))) { - case -1: /* abort */ - return -1; - case 3: /* cancel */ - return 1; + case -1: /* abort */ + return -1; + case 3: /* cancel */ + return 1; - case 2: /* append */ - *append = M_SAVE_APPEND; - break; - case 1: /* overwrite */ - *append = M_SAVE_OVERWRITE; - break; + case 2: /* append */ + *append = M_SAVE_APPEND; + break; + case 1: /* overwrite */ + *append = M_SAVE_OVERWRITE; + break; } } return 0; } -void mutt_save_path (char *d, size_t dsize, ADDRESS *a) +void mutt_save_path (char *d, size_t dsize, ADDRESS * a) { - if (a && a->mailbox) - { + if (a && a->mailbox) { strfcpy (d, a->mailbox, dsize); - if (!option (OPTSAVEADDRESS)) - { + if (!option (OPTSAVEADDRESS)) { char *p; if ((p = strpbrk (d, "%@"))) - *p = 0; + *p = 0; } - mutt_strlower (d); + str_tolower (d); } else *d = 0; } -void mutt_safe_path (char *s, size_t l, ADDRESS *a) +void mutt_safe_path (char *s, size_t l, ADDRESS * a) { char *p; @@ -931,11 +893,14 @@ void mutt_safe_path (char *s, size_t l, ADDRESS *a) /* counts how many characters in s can be skipped while none of the * characters of c appears */ -int mutt_skipchars (const char* s, const char* c) { +int mutt_skipchars (const char *s, const char *c) +{ int ret = 0; - const char* p = s; + const char *p = s; + while (s && *s) { - register const char* t = c; + register const char *t = c; + while (t && *t) { if (*t == *s) return (ret); @@ -944,237 +909,223 @@ int mutt_skipchars (const char* s, const char* c) { ret++; s++; } - return (mutt_strlen (p)); + return (safe_strlen (p)); } -void mutt_FormatString (char *dest, /* output buffer */ - size_t destlen, /* output buffer len */ - const char *src, /* template string */ - format_t *callback, /* callback for processing */ - unsigned long data, /* callback data */ - format_flag flags) /* callback flags */ -{ +void mutt_FormatString (char *dest, /* output buffer */ + size_t destlen, /* output buffer len */ + const char *src, /* template string */ + format_t * callback, /* callback for processing */ + unsigned long data, /* callback data */ + format_flag flags) +{ /* callback flags */ char prefix[SHORT_STRING], buf[LONG_STRING], *cp, *wptr = dest, ch; char ifstring[SHORT_STRING], elsestring[SHORT_STRING]; size_t wlen, count, len, col, wid; prefix[0] = '\0'; - destlen--; /* save room for the terminal \0 */ + destlen--; /* save room for the terminal \0 */ wlen = (flags & M_FORMAT_ARROWCURSOR && option (OPTARROWCURSOR)) ? 3 : 0; col = wlen; - - while (*src && wlen < destlen) - { - if (*src == '%') - { - if (*++src == '%') - { - *wptr++ = '%'; - wlen++; - col++; - src++; - continue; + + while (*src && wlen < destlen) { + if (*src == '%') { + if (*++src == '%') { + *wptr++ = '%'; + wlen++; + col++; + src++; + continue; } - if (*src == '?') - { - flags |= M_FORMAT_OPTIONAL; - src++; + if (*src == '?') { + flags |= M_FORMAT_OPTIONAL; + src++; } - else - { - flags &= ~M_FORMAT_OPTIONAL; - - /* eat the format string */ - cp = prefix; - count = 0; - while (count < sizeof (prefix) && - (isdigit ((unsigned char) *src) || *src == '.' || *src == '-')) - { - *cp++ = *src++; - count++; - } - *cp = 0; + else { + flags &= ~M_FORMAT_OPTIONAL; + + /* eat the format string */ + cp = prefix; + count = 0; + while (count < sizeof (prefix) && + (isdigit ((unsigned char) *src) || *src == '.' || *src == '-')) + { + *cp++ = *src++; + count++; + } + *cp = 0; } if (!*src) - break; /* bad format */ + break; /* bad format */ - ch = *src++; /* save the character to switch on */ + ch = *src++; /* save the character to switch on */ - if (flags & M_FORMAT_OPTIONAL) - { + if (flags & M_FORMAT_OPTIONAL) { if (*src != '?') - break; /* bad format */ + break; /* bad format */ src++; /* eat the `if' part of the string */ cp = ifstring; - count = 0; - while (count < sizeof (ifstring) && *src && *src != '?' && *src != '&') - { + count = 0; + while (count < sizeof (ifstring) && *src && *src != '?' + && *src != '&') { *cp++ = *src++; - count++; - } + count++; + } *cp = 0; - /* eat the `else' part of the string (optional) */ - if (*src == '&') - src++; /* skip the & */ - cp = elsestring; - count = 0; - while (count < sizeof (elsestring) && *src && *src != '?') - { - *cp++ = *src++; - count++; - } - *cp = 0; - - if (!*src) - break; /* bad format */ - - src++; /* move past the trailing `?' */ + /* eat the `else' part of the string (optional) */ + if (*src == '&') + src++; /* skip the & */ + cp = elsestring; + count = 0; + while (count < sizeof (elsestring) && *src && *src != '?') { + *cp++ = *src++; + count++; + } + *cp = 0; + + if (!*src) + break; /* bad format */ + + src++; /* move past the trailing `?' */ } /* handle generic cases first */ - if (ch == '>') - { - /* right justify to EOL */ - ch = *src++; /* pad char */ - /* calculate space left on line. if we've already written more data - than will fit on the line, ignore the rest of the line */ - if ( DrawFullLine || option(OPTSTATUSONTOP)) - count = (COLS < destlen ? COLS : destlen); - else - count = ((COLS-SidebarWidth) < destlen ? (COLS - SidebarWidth) : destlen); - if (count > col) - { - count -= col; /* how many columns left on this line */ - mutt_FormatString (buf, sizeof (buf), src, callback, data, flags); - wid = mutt_strlen (buf); - if (count > wid) - { - count -= wid; /* how many chars to pad */ - memset (wptr, ch, count); - wptr += count; - col += count; - } - if (wid + wlen > destlen) - len = destlen - wlen; - else - len = wid; - memcpy (wptr, buf, len); - wptr += len; - wlen += len; - col += mutt_strwidth (buf); - } - break; /* skip rest of input */ + if (ch == '>') { + /* right justify to EOL */ + ch = *src++; /* pad char */ + /* calculate space left on line. if we've already written more data + than will fit on the line, ignore the rest of the line */ + if (DrawFullLine || option (OPTSTATUSONTOP)) + count = (COLS < destlen ? COLS : destlen); + else + count = + ((COLS - SidebarWidth) < + destlen ? (COLS - SidebarWidth) : destlen); + if (count > col) { + count -= col; /* how many columns left on this line */ + mutt_FormatString (buf, sizeof (buf), src, callback, data, flags); + wid = safe_strlen (buf); + if (count > wid) { + count -= wid; /* how many chars to pad */ + memset (wptr, ch, count); + wptr += count; + col += count; + } + if (wid + wlen > destlen) + len = destlen - wlen; + else + len = wid; + memcpy (wptr, buf, len); + wptr += len; + wlen += len; + col += mutt_strwidth (buf); + } + break; /* skip rest of input */ } - else if (ch == '|') - { - /* pad to EOL */ - ch = *src++; - if (destlen > COLS) - destlen = COLS; - if (destlen > wlen) - { - count = destlen - wlen; - memset (wptr, ch, count); - wptr += count; - } - break; /* skip rest of input */ + else if (ch == '|') { + /* pad to EOL */ + ch = *src++; + if (destlen > COLS) + destlen = COLS; + if (destlen > wlen) { + count = destlen - wlen; + memset (wptr, ch, count); + wptr += count; + } + break; /* skip rest of input */ } - else - { - short tolower = 0; - short nodots = 0; - - while (ch == '_' || ch == ':') - { - if (ch == '_') - tolower = 1; - else if (ch == ':') - nodots = 1; - - ch = *src++; - } - - /* use callback function to handle this case */ - src = callback (buf, sizeof (buf), ch, src, prefix, ifstring, elsestring, data, flags); - - if (tolower) - mutt_strlower (buf); - if (nodots) - { - char *p = buf; - for (; *p; p++) - if (*p == '.') - *p = '_'; - } - - if ((len = mutt_strlen (buf)) + wlen > destlen) - len = (destlen - wlen > 0) ? (destlen - wlen) : 0; - - memcpy (wptr, buf, len); - wptr += len; - wlen += len; - col += mutt_strwidth (buf); + else { + short tolower = 0; + short nodots = 0; + + while (ch == '_' || ch == ':') { + if (ch == '_') + tolower = 1; + else if (ch == ':') + nodots = 1; + + ch = *src++; + } + + /* use callback function to handle this case */ + src = + callback (buf, sizeof (buf), ch, src, prefix, ifstring, elsestring, + data, flags); + + if (tolower) + str_tolower (buf); + if (nodots) { + char *p = buf; + + for (; *p; p++) + if (*p == '.') + *p = '_'; + } + + if ((len = safe_strlen (buf)) + wlen > destlen) + len = (destlen - wlen > 0) ? (destlen - wlen) : 0; + + memcpy (wptr, buf, len); + wptr += len; + wlen += len; + col += mutt_strwidth (buf); } } - else if (*src == '\\') - { + else if (*src == '\\') { if (!*++src) - break; - switch (*src) - { - case 'n': - *wptr = '\n'; - break; - case 't': - *wptr = '\t'; - break; - case 'r': - *wptr = '\r'; - break; - case 'f': - *wptr = '\f'; - break; - case 'v': - *wptr = '\v'; - break; - default: - *wptr = *src; - break; + break; + switch (*src) { + case 'n': + *wptr = '\n'; + break; + case 't': + *wptr = '\t'; + break; + case 'r': + *wptr = '\r'; + break; + case 'f': + *wptr = '\f'; + break; + case 'v': + *wptr = '\v'; + break; + default: + *wptr = *src; + break; } src++; wptr++; wlen++; col++; } - else - { + else { unsigned int bar = mutt_skipchars (src, "%\\"); - char* bar2 = safe_malloc (bar+1); - strfcpy (bar2, src, bar+1); + char *bar2 = safe_malloc (bar + 1); + + strfcpy (bar2, src, bar + 1); while (bar--) { *wptr++ = *src++; wlen++; } col += mutt_strwidth (bar2); - FREE(&bar2); + FREE (&bar2); } } *wptr = 0; #if 0 - if (flags & M_FORMAT_MAKEPRINT) - { + if (flags & M_FORMAT_MAKEPRINT) { /* Make sure that the string is printable by changing all non-printable chars to dots, or spaces for non-printable whitespace */ - for (cp = dest ; *cp ; cp++) - if (!IsPrint (*cp) && - !((flags & M_FORMAT_TREE) && (*cp <= M_TREE_MAX))) - *cp = isspace ((unsigned char) *cp) ? ' ' : '.'; + for (cp = dest; *cp; cp++) + if (!IsPrint (*cp) && !((flags & M_FORMAT_TREE) && (*cp <= M_TREE_MAX))) + *cp = isspace ((unsigned char) *cp) ? ' ' : '.'; } #endif } @@ -1182,15 +1133,14 @@ void mutt_FormatString (char *dest, /* output buffer */ /* This function allows the user to specify a command to read stdout from in place of a normal file. If the last character in the string is a pipe (|), then we assume it is a commmand to run instead of a normal file. */ -FILE *mutt_open_read (const char *path, pid_t *thepid) +FILE *mutt_open_read (const char *path, pid_t * thepid) { FILE *f; struct stat s; - int len = mutt_strlen (path); + int len = safe_strlen (path); - if (path[len - 1] == '|') - { + if (path[len - 1] == '|') { /* read from a pipe */ char *s = safe_strdup (path); @@ -1200,12 +1150,10 @@ FILE *mutt_open_read (const char *path, pid_t *thepid) *thepid = mutt_create_filter (s, NULL, &f, NULL); FREE (&s); } - else - { + else { if (stat (path, &s) < 0) return (NULL); - if (S_ISDIR (s.st_mode)) - { + if (S_ISDIR (s.st_mode)) { errno = EINVAL; return (NULL); } @@ -1226,42 +1174,39 @@ int mutt_save_confirm (const char *s, struct stat *st) magic = mx_get_magic (s); #ifdef USE_POP - if (magic == M_POP) - { + if (magic == M_POP) { mutt_error _("Can't save message to POP mailbox."); + return 1; } #endif #ifdef USE_NNTP - if (magic == M_NNTP) - { + if (magic == M_NNTP) { mutt_error _("Can't save message to newsserver."); + return 0; } #endif - if (stat (s, st) != -1) - { - if (magic == -1) - { + if (stat (s, st) != -1) { + if (magic == -1) { mutt_error (_("%s is not a mailbox!"), s); return 1; } if (option (OPTCONFIRMAPPEND) && - (!TrashPath || (mutt_strcmp (s, TrashPath) != 0))) + (!TrashPath || (safe_strcmp (s, TrashPath) != 0))) /* if we're appending to the trash, there's no point in asking */ { snprintf (tmp, sizeof (tmp), _("Append messages to %s?"), s); if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO) - ret = 1; + ret = 1; else if (rc == -1) - ret = -1; + ret = -1; } } - else - { + else { #ifdef USE_IMAP if (magic != M_IMAP) #endif /* execute the block unconditionally if we don't use imap */ @@ -1269,60 +1214,58 @@ int mutt_save_confirm (const char *s, struct stat *st) st->st_mtime = 0; st->st_atime = 0; - if (errno == ENOENT) - { - if (option (OPTCONFIRMCREATE)) - { - snprintf (tmp, sizeof (tmp), _("Create %s?"), s); - if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO) - ret = 1; - else if (rc == -1) - ret = -1; - } + if (errno == ENOENT) { + if (option (OPTCONFIRMCREATE)) { + snprintf (tmp, sizeof (tmp), _("Create %s?"), s); + if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO) + ret = 1; + else if (rc == -1) + ret = -1; + } } - else - { - mutt_perror (s); - return 1; + else { + mutt_perror (s); + return 1; } } } - CLEARLINE (LINES-1); + CLEARLINE (LINES - 1); return (ret); } -void state_prefix_putc (char c, STATE *s) +void state_prefix_putc (char c, STATE * s) { - if (s->flags & M_PENDINGPREFIX) - { + if (s->flags & M_PENDINGPREFIX) { int i; - i = strlen (Quotebuf); + i = safe_strlen (Quotebuf); Quotebuf[i++] = c; Quotebuf[i] = '\0'; - if (i == sizeof (Quotebuf) - 1 || c == '\n') - { + if (i == sizeof (Quotebuf) - 1 || c == '\n') { char buf[2 * SHORT_STRING]; int j = 0, offset = 0; regmatch_t pmatch[1]; state_reset_prefix (s); - while (regexec ((regex_t *) QuoteRegexp.rx, &Quotebuf[offset], 1, pmatch, 0) == 0) - offset += pmatch->rm_eo; - - if (!option (OPTQUOTEEMPTY) && Quotebuf[0] == '\n') - strcpy (buf, Quotebuf); - else if (option (OPTQUOTEQUOTED) && offset) - { - for (i = 0; i < offset; i++) - if (Quotebuf[i] != ' ') - j = i; - strncpy (buf, Quotebuf, j + 1); - strcpy (buf + j + 1, Quotebuf + j); + while (regexec + ((regex_t *) QuoteRegexp.rx, &Quotebuf[offset], 1, pmatch, + 0) == 0) + offset += pmatch->rm_eo; + + if (!option (OPTQUOTEEMPTY) && Quotebuf[offset] == '\n') { + buf[0] = '\n'; + buf[1] = '\0'; + } + else if (option (OPTQUOTEQUOTED) && offset) { + for (i = 0; i < offset; i++) + if (Quotebuf[i] != ' ') + j = i; + strncpy (buf, Quotebuf, j + 1); + strcpy (buf + j + 1, Quotebuf + j); } else - snprintf (buf, sizeof (buf), "%s%s", NONULL(s->prefix), Quotebuf); + snprintf (buf, sizeof (buf), "%s%s", NONULL (s->prefix), Quotebuf); state_puts (buf, s); } @@ -1330,14 +1273,13 @@ void state_prefix_putc (char c, STATE *s) else state_putc (c, s); - if (c == '\n') - { + if (c == '\n') { state_set_prefix (s); Quotebuf[0] = '\0'; } } -int state_printf (STATE *s, const char *fmt, ...) +int state_printf (STATE * s, const char *fmt, ...) { int rv; va_list ap; @@ -1345,36 +1287,36 @@ int state_printf (STATE *s, const char *fmt, ...) va_start (ap, fmt); rv = vfprintf (s->fpout, fmt, ap); va_end (ap); - + return rv; } -void state_mark_attach (STATE *s) +void state_mark_attach (STATE * s) { - if ((s->flags & M_DISPLAY) && !mutt_strcmp (Pager, "builtin")) + if ((s->flags & M_DISPLAY) && !safe_strcmp (Pager, "builtin")) state_puts (AttachmentMarker, s); } -void state_attach_puts (const char *t, STATE *s) +void state_attach_puts (const char *t, STATE * s) { - if (*t != '\n') state_mark_attach (s); - while (*t) - { + if (*t != '\n') + state_mark_attach (s); + while (*t) { state_putc (*t, s); if (*t++ == '\n' && *t) - if (*t != '\n') state_mark_attach (s); + if (*t != '\n') + state_mark_attach (s); } } void mutt_display_sanitize (char *s) { - for (; *s; s++) - { + for (; *s; s++) { if (!IsPrint (*s)) *s = '?'; } } - + void mutt_sleep (short s) { if (SleepTime > s) @@ -1390,19 +1332,17 @@ void mutt_sleep (short s) * Disregards the 'destroy' flag, which seems reserved for caller. * This is bad, but there's no apparent protocol for it. */ -BUFFER * mutt_buffer_init(BUFFER *b) +BUFFER *mutt_buffer_init (BUFFER * b) { - if (!b) - { - b = safe_malloc(sizeof(BUFFER)); + if (!b) { + b = safe_malloc (sizeof (BUFFER)); if (!b) return NULL; } - else - { - safe_free(b->data); + else { + FREE(&b->data); } - memset(b, 0, sizeof(BUFFER)); + memset (b, 0, sizeof (BUFFER)); return b; } @@ -1414,50 +1354,49 @@ BUFFER * mutt_buffer_init(BUFFER *b) * Disregards the 'destroy' flag, which seems reserved for caller. * This is bad, but there's no apparent protocol for it. */ -BUFFER * mutt_buffer_from(BUFFER *b, char *seed) +BUFFER *mutt_buffer_from (BUFFER * b, char *seed) { if (!seed) return NULL; - b = mutt_buffer_init(b); + b = mutt_buffer_init (b); b->data = safe_strdup (seed); - b->dsize = mutt_strlen (seed); + b->dsize = safe_strlen (seed); b->dptr = (char *) b->data + b->dsize; return b; } -void mutt_buffer_addstr (BUFFER* buf, const char* s) +void mutt_buffer_addstr (BUFFER * buf, const char *s) { - mutt_buffer_add (buf, s, mutt_strlen (s)); + mutt_buffer_add (buf, s, safe_strlen (s)); } -void mutt_buffer_addch (BUFFER* buf, char c) +void mutt_buffer_addch (BUFFER * buf, char c) { mutt_buffer_add (buf, &c, 1); } -void mutt_buffer_free (BUFFER **p) +void mutt_buffer_free (BUFFER ** p) { - if (!p || !*p) + if (!p || !*p) return; - FREE(&(*p)->data); - /* dptr is just an offset to data and shouldn't be freed */ - FREE(p); + FREE (&(*p)->data); + /* dptr is just an offset to data and shouldn't be freed */ + FREE (p); } /* dynamically grows a BUFFER to accomodate s, in increments of 128 bytes. * Always one byte bigger than necessary for the null terminator, and * the buffer is always null-terminated */ -void mutt_buffer_add (BUFFER* buf, const char* s, size_t len) +void mutt_buffer_add (BUFFER * buf, const char *s, size_t len) { size_t offset; - if (buf->dptr + len + 1 > buf->data + buf->dsize) - { + if (buf->dptr + len + 1 > buf->data + buf->dsize) { offset = buf->dptr - buf->data; buf->dsize += len < 128 ? 128 : len + 1; - safe_realloc ((void**) &buf->data, buf->dsize); + safe_realloc ((void **) &buf->data, buf->dsize); buf->dptr = buf->data + offset; } memcpy (buf->dptr, s, len); @@ -1472,138 +1411,89 @@ time_t mutt_decrease_mtime (const char *f, struct stat *st) struct utimbuf utim; struct stat _st; time_t mtime; - - if (!st) - { + + if (!st) { if (stat (f, &_st) == -1) return -1; st = &_st; } - if ((mtime = st->st_mtime) == time (NULL)) - { + if ((mtime = st->st_mtime) == time (NULL)) { mtime -= 1; utim.actime = mtime; utim.modtime = mtime; utime (f, &utim); } - + return mtime; } const char *mutt_make_version (void) { static char vstring[STRING]; + snprintf (vstring, sizeof (vstring), "Mutt-ng %s (%s)", - MUTT_VERSION, ReleaseDate); + MUTT_VERSION, ReleaseDate); return vstring; } -REGEXP *mutt_compile_regexp (const char *s, int flags) -{ - REGEXP *pp = safe_calloc (sizeof (REGEXP), 1); - pp->pattern = safe_strdup (s); - pp->rx = safe_calloc (sizeof (regex_t), 1); - if (REGCOMP (pp->rx, NONULL(s), flags) != 0) - mutt_free_regexp (&pp); - - return pp; -} - -void mutt_free_regexp (REGEXP **pp) -{ - FREE (&(*pp)->pattern); - regfree ((*pp)->rx); - FREE (&(*pp)->rx); - FREE (pp); -} - -void mutt_free_rx_list (RX_LIST **list) -{ - RX_LIST *p; - - if (!list) return; - while (*list) - { - p = *list; - *list = (*list)->next; - mutt_free_regexp (&p->rx); - FREE (&p); - } -} - -void mutt_free_spam_list (SPAM_LIST **list) +void mutt_free_spam_list (SPAM_LIST ** list) { SPAM_LIST *p; - - if (!list) return; - while (*list) - { + + if (!list) + return; + while (*list) { p = *list; *list = (*list)->next; - mutt_free_regexp (&p->rx); - safe_free(&p->template); - FREE (&p); + rx_free (&p->rx); + FREE(&p->template); + FREE(&p); } } -int mutt_match_rx_list (const char *s, RX_LIST *l) -{ - if (!s) return 0; - - for (; l; l = l->next) - { - if (regexec (l->rx->rx, s, (size_t) 0, (regmatch_t *) 0, (int) 0) == 0) - { - dprint (5, (debugfile, "mutt_match_rx_list: %s matches %s\n", s, l->rx->pattern)); - return 1; - } - } - - return 0; -} - -int mutt_match_spam_list (const char *s, SPAM_LIST *l, char *text, int x) +int mutt_match_spam_list (const char *s, SPAM_LIST * l, char *text, int x) { static regmatch_t *pmatch = NULL; static int nmatch = 0; int i, n, tlen; char *p; - if (!s) return 0; + if (!s) + return 0; tlen = 0; - for (; l; l = l->next) - { + for (; l; l = l->next) { /* If this pattern needs more matches, expand pmatch. */ - if (l->nmatch > nmatch) - { - safe_realloc (&pmatch, l->nmatch * sizeof(regmatch_t)); + if (l->nmatch > nmatch) { + safe_realloc (&pmatch, l->nmatch * sizeof (regmatch_t)); nmatch = l->nmatch; } /* Does this pattern match? */ - if (regexec (l->rx->rx, s, (size_t) l->nmatch, (regmatch_t *) pmatch, (int) 0) == 0) - { - dprint (5, (debugfile, "mutt_match_spam_list: %s matches %s\n", s, l->rx->pattern)); - dprint (5, (debugfile, "mutt_match_spam_list: %d subs\n", l->rx->rx->re_nsub)); + if (regexec + (l->rx->rx, s, (size_t) l->nmatch, (regmatch_t *) pmatch, + (int) 0) == 0) { + dprint (5, + (debugfile, "mutt_match_spam_list: %s matches %s\n", s, + l->rx->pattern)); + dprint (5, + (debugfile, "mutt_match_spam_list: %d subs\n", + l->rx->rx->re_nsub)); /* Copy template into text, with substitutions. */ - for (p = l->template; *p;) - { - if (*p == '%') - { - n = atoi(++p); /* find pmatch index */ - while (isdigit(*p)) - ++p; /* skip subst token */ - for (i = pmatch[n].rm_so; (i < pmatch[n].rm_eo) && (tlen < x); i++) - text[tlen++] = s[i]; - } - else - { - text[tlen++] = *p++; - } + for (p = l->template; *p;) { + if (*p == '%') { + n = atoi (++p); /* find pmatch index */ + while (isdigit (*p)) + ++p; /* skip subst token */ + for (i = pmatch[n].rm_so; (i < pmatch[n].rm_eo) && (tlen < x); i++) + text[tlen++] = s[i]; + } + else { + text[tlen++] = *p++; + } } text[tlen] = '\0'; dprint (5, (debugfile, "mutt_match_spam_list: \"%s\"\n", text));