X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=muttlib.c;h=1c23817e44175ba87fe40859e933355b520aab73;hp=7592681805f4038bd274dff16593dd0adaa25ce5;hb=9b87576a7ebf2e52a7ca6a0e2dba12fa24bd34dd;hpb=0ac011f8eb41bab7808881ebf9802b4eb252fe3b diff --git a/muttlib.c b/muttlib.c index 7592681..1c23817 100644 --- a/muttlib.c +++ b/muttlib.c @@ -8,60 +8,20 @@ * please see the file GPL in the top level source directory. */ -#if HAVE_CONFIG_H -# include "config.h" -#endif +#include -#include -#include -#include -#include -#include -#include +#include +#include -#include +#include +#include +#include +#include "alias.h" #include "mutt.h" -#include "enter.h" -#include "mutt_curses.h" -#include "mx.h" -#include "url.h" #include "attach.h" -#include "version.h" - -#ifdef USE_IMAP -#include "imap.h" -#include "imap/mx_imap.h" -#endif - -#include "mutt_crypt.h" - -#include "lib/debug.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define SW (option(OPTMBOXPANE)?SidebarWidth:0) - -BODY *mutt_new_body (void) -{ - BODY *p = p_new(BODY, 1); - - p->disposition = DISPATTACH; - p->use_disp = 1; - return (p); -} - +const char *madmutt_version = "Madmutt/" MUTT_VERSION; /* Modified by blong to accept a "suggestion" for file name. If * that file exists, then construct one with unique name but @@ -69,637 +29,151 @@ BODY *mutt_new_body (void) * Renamed to mutt_adv_mktemp so I only have to change where it's * called, and not all possible cases. */ -void mutt_adv_mktemp (const char* dir, char *s, size_t l) -{ - char buf[_POSIX_PATH_MAX]; - char tmp[_POSIX_PATH_MAX]; - char *period; - size_t sl; - struct stat sb; - - m_strcpy(buf, sizeof(buf), m_strisempty(dir) ? NONULL(Tempdir) : dir); - mutt_expand_path (buf, sizeof (buf)); - if (s[0] == '\0') { - snprintf (s, l, "%s/muttXXXXXX", buf); - mktemp (s); - } - else { - m_strcpy(tmp, sizeof(tmp), s); - mutt_sanitize_filename (tmp, 1); - snprintf (s, l, "%s/%s", buf, tmp); - if (lstat (s, &sb) == -1 && errno == ENOENT) - return; - if ((period = strrchr (tmp, '.')) != NULL) - *period = 0; - snprintf (s, l, "%s/%s.XXXXXX", buf, tmp); - mktemp (s); - if (period != NULL) { - *period = '.'; - sl = m_strlen(s); - m_strcpy(s + sl, l - sl, period); - } - } -} - -/* create a send-mode duplicate from a receive-mode body */ - -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) { - use_disp = 1; - m_strcpy(tmp, sizeof(tmp), src->filename); - } - else { - use_disp = 0; - tmp[0] = '\0'; - } - - mutt_adv_mktemp (NULL, 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->filename = m_strdup(tmp); - b->use_disp = use_disp; - b->unlink = 1; - - if (mutt_is_text_part (b)) - b->noconv = 1; - - b->xtype = m_strdup(b->xtype); - b->subtype = m_strdup(b->subtype); - b->form_name = m_strdup(b->form_name); - b->filename = m_strdup(b->filename); - b->d_filename = m_strdup(b->d_filename); - b->description = m_strdup(b->description); - - /* - * we don't seem to need the HEADER structure currently. - * XXX - this may change in the future - */ - - if (b->hdr) - b->hdr = NULL; - - /* copy parameters */ - for (par = b->parameter, ppar = &b->parameter; par; - ppar = &(*ppar)->next, par = par->next) { - *ppar = mutt_new_parameter (); - (*ppar)->attribute = m_strdup(par->attribute); - (*ppar)->value = m_strdup(par->value); - } - - mutt_stamp_attachment (b); - - return 0; -} - - - -void mutt_free_body (BODY ** p) +void mutt_adv_mktemp (const char* dir, char *s, ssize_t l) { - BODY *a = *p, *b; - - while (a) { - b = a; - a = a->next; + int fd; - if (b->parameter) - mutt_free_parameter (&b->parameter); - if (b->unlink && b->filename) { - debug_print (1, ("unlinking %s.\n", b->filename)); - unlink (b->filename); - } - else if (b->filename) - debug_print (1, ("not unlinking %s.\n", b->filename)); - - p_delete(&b->filename); - p_delete(&b->content); - p_delete(&b->xtype); - p_delete(&b->subtype); - p_delete(&b->description); - p_delete(&b->form_name); - - if (b->hdr) { - /* Don't free twice (b->hdr->content = b->parts) */ - b->hdr->content = NULL; - mutt_free_header (&b->hdr); + fd = m_tempfd(s, l, m_strisempty(dir) ? NONULL(mod_core.tmpdir) : dir, s); + if (fd < 0) { + *s = '\0'; + } else { + close(fd); + unlink(s); } - - if (b->parts) - mutt_free_body (&b->parts); - - p_delete(&b); - } - - *p = 0; } -void mutt_free_parameter (PARAMETER ** p) +void mutt_mktemp(char *s) { - PARAMETER *t = *p; - PARAMETER *o; - - while (t) { - p_delete(&t->attribute); - p_delete(&t->value); - o = t; - t = t->next; - p_delete(&o); - } - *p = 0; -} - -HEADER *mutt_dup_header (HEADER * h) -{ - HEADER *hnew; - - hnew = mutt_new_header (); - memcpy (hnew, h, sizeof (HEADER)); - return hnew; -} - -void mutt_free_header (HEADER ** h) -{ - if (!h || !*h) - return; - mutt_free_envelope (&(*h)->env); - mutt_free_body (&(*h)->content); - p_delete(&(*h)->maildir_flags); - p_delete(&(*h)->tree); - p_delete(&(*h)->path); -#ifdef MIXMASTER - mutt_free_list (&(*h)->chain); -#endif - p_delete(&(*h)->data); - p_delete(h); -} - -/* returns true if the header contained in "s" is in list "t" */ -int mutt_matches_ignore (const char *s, LIST * t) -{ - for (; t; t = t->next) { - if (!ascii_strncasecmp (s, t->data, m_strlen(t->data)) - || *t->data == '*') - return 1; - } - return 0; -} - -/* prepend the path part of *path to *lnk */ -void mutt_expand_link (char *newpath, const char *path, const char *lnk) -{ - const char *lb = NULL; - size_t len; - - /* lnk is full path */ - if (*lnk == '/') { - m_strcpy(newpath, _POSIX_PATH_MAX, lnk); - return; - } - - if ((lb = strrchr (path, '/')) == NULL) { - /* no path in lnk */ - m_strcpy(newpath, _POSIX_PATH_MAX, lnk); - return; - } - - len = lb - path + 1; - memcpy (newpath, path, len); - m_strcpy(newpath + len, _POSIX_PATH_MAX - len, lnk); -} - -char *mutt_expand_path (char *s, size_t slen) -{ - return _mutt_expand_path (s, slen, 0); + int fd = m_tempfd(s, _POSIX_PATH_MAX, NONULL(mod_core.tmpdir), NULL); + if (fd < 0) { + *s = '\0'; + } else { + close(fd); + unlink(s); + } } -char *_mutt_expand_path (char *s, size_t slen, int rx) +ssize_t _mutt_expand_path(char *buf, ssize_t len, const char *s, int rx) { - char p[_POSIX_PATH_MAX] = ""; - char q[_POSIX_PATH_MAX] = ""; - char tmp[_POSIX_PATH_MAX]; - char *t; - - const char *tail = ""; - - int recurse = 0; - - do { - recurse = 0; + char p[_POSIX_PATH_MAX] = ""; + char tmp[_POSIX_PATH_MAX]; + const char *tail = ""; + const address_t *alias; switch (*s) { - case '~': - { - if (*(s + 1) == '/' || *(s + 1) == 0) { - m_strcpy(p, sizeof(p), NONULL(Homedir)); - tail = s + 1; - } - else { - struct passwd *pw; - - if ((t = strchr (s + 1, '/'))) - *t = 0; - - if ((pw = getpwnam (s + 1))) { - m_strcpy(p, sizeof(p), pw->pw_dir); - if (t) { - *t = '/'; - tail = t; + case '~': + if (s[1] == '/' || s[1] == '\0') { + m_strcpy(p, sizeof(p), mod_core.homedir); + tail = s + 1; + } else { + struct passwd *pw; + tail = m_strchrnul(s + 1, '/'); + + m_strncpy(tmp, sizeof(tmp), s + 1, tail - s - 1); + + if ((pw = getpwnam(tmp))) { + m_strcpy(p, sizeof(p), pw->pw_dir); + } else { + /* user not found! */ + tail = s; } - else - tail = ""; - } - else { - /* user not found! */ - if (t) - *t = '/'; - *p = '\0'; - tail = s; - } } - } - break; + break; - case '=': - case '+': - { -#ifdef USE_IMAP + case '=': + case '+': /* if folder = imap[s]://host/: don't append slash */ - if (imap_is_magic (NONULL (Maildir), NULL) == M_IMAP && - Maildir[m_strlen(Maildir) - 1] == '/') - m_strcpy(p, sizeof(p), NONULL(Maildir)); - else -#endif - snprintf (p, sizeof (p), "%s/", NONULL (Maildir)); + if (imap_is_magic(NONULL(Maildir), NULL) == M_IMAP + && Maildir[m_strlen(Maildir) - 1] == '/') { + m_strcpy(p, sizeof(p), Maildir); + } else { + snprintf(p, sizeof(p), "%s/", NONULL(Maildir)); + } tail = s + 1; - } - break; + break; + + /* elm compatibility, @ expands alias to user name */ - /* elm compatibility, @ expands alias to user name */ - - case '@': - { - HEADER *h; - address_t *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 = ""; + case '@': + if ((alias = alias_lookup(s + 1))) { + HEADER h; + header_init(&h); + h.env = envelope_new(); + h.env->from = h.env->to = (address_t *)alias; + mutt_default_save(p, sizeof (p), &h); + h.env->from = h.env->to = NULL; + header_wipe(&h); + + if (*p != '@') + return _mutt_expand_path(buf, len, p, rx); } - } - break; + break; - case '>': - { - m_strcpy(p, sizeof(p), NONULL(Inbox)); + case '>': + m_strcpy(p, sizeof(p), Inbox); tail = s + 1; - } - break; + break; - case '<': - { - m_strcpy(p, sizeof(p), NONULL(Outbox)); + case '<': + m_strcpy(p, sizeof(p), MAlias.record); tail = s + 1; - } - break; + break; - case '!': - { - if (*(s + 1) == '!') { - m_strcpy(p, sizeof(p), NONULL(LastFolder)); - tail = s + 2; - } - else { - m_strcpy(p, sizeof(p), NONULL(Spoolfile)); - tail = s + 1; + case '!': + if (s[1] == '!') { + m_strcpy(p, sizeof(p), LastFolder); + tail = s + 2; + } else { + m_strcpy(p, sizeof(p), Spoolfile); + tail = s + 1; } - } - break; + break; - case '-': - { + case '-': m_strcpy(p, sizeof(p), NONULL(LastFolder)); tail = s + 1; - } - break; + break; - case '^': - { + case '^': m_strcpy(p, sizeof(p), NONULL(CurrentFolder)); tail = s + 1; - } - break; + break; - default: - { + default: *p = '\0'; tail = s; - } - } - - 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); - - m_strcpy(s, slen, tmp); - } - while (recurse); - - return (s); -} - -/* Extract the real name from /etc/passwd's GECOS field. - * When set, honor the regular expression in GecosMask, - * otherwise assume that the GECOS field is a - * comma-separated list. - * Replace "&" by a capitalized version of the user's login - * name. - */ - -char *mutt_gecos_name (char *dest, size_t destlen, struct passwd *pw) -{ - regmatch_t pat_match[1]; - size_t pwnl; - int idx; - char *p; - - if (!pw || !pw->pw_gecos) - return NULL; - - p_clear(dest, destlen); - - if (GecosMask.rx) { - if (regexec (GecosMask.rx, pw->pw_gecos, 1, pat_match, 0) == 0) - m_strcpy(dest, MIN(pat_match[0].rm_eo - pat_match[0].rm_so + 1, destlen), - pw->pw_gecos + pat_match[0].rm_so); - } - else if ((p = strchr (pw->pw_gecos, ','))) - m_strcpy(dest, MIN(destlen, p - pw->pw_gecos + 1), pw->pw_gecos); - else - m_strcpy(dest, destlen, pw->pw_gecos); - - pwnl = m_strlen(pw->pw_name); - - 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)); - dest[idx] = toupper ((unsigned char) dest[idx]); } - } - - return dest; -} - - -char *mutt_get_parameter (const char *s, PARAMETER * p) -{ - for (; p; p = p->next) - if (ascii_strcasecmp (s, p->attribute) == 0) - return (p->value); - - return NULL; -} - -void mutt_set_parameter (const char *attribute, const char *value, - PARAMETER ** p) -{ - PARAMETER *q; - - if (!value) { - mutt_delete_parameter (attribute, p); - return; - } - for (q = *p; q; q = q->next) { - if (ascii_strcasecmp (attribute, q->attribute) == 0) { - m_strreplace(&q->value, value); - return; - } - } - - q = mutt_new_parameter (); - q->attribute = m_strdup(attribute); - q->value = m_strdup(value); - q->next = *p; - *p = q; -} - -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) { - *p = q->next; - q->next = NULL; - mutt_free_parameter (&q); - return; + if (rx) { + char q[_POSIX_PATH_MAX]; + rx_sanitize_string(q, sizeof(q), p); + snprintf(tmp, sizeof(tmp), "%s%s", q, tail); + } else { + snprintf(tmp, sizeof(tmp), "%s%s", p, tail); } - } -} - -/* returns 1 if Mutt can't display this type of data, 0 otherwise */ -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; - - case TYPEAPPLICATION: - if (mutt_is_application_pgp (m)) - return 0; - if (mutt_is_application_smime (m)) - return 0; - break; - - case TYPEMULTIPART: - case TYPEMESSAGE: - return 0; - } - return 1; -} - -int mutt_is_text_part (BODY * b) -{ - int t = b->type; - char *s = b->subtype; - - if (mutt_is_application_pgp (b)) - return 0; - - if (t == TYPETEXT) - return 1; - - if (t == TYPEMESSAGE) { - if (!ascii_strcasecmp ("delivery-status", s)) - return 1; - } - - if (t == TYPEAPPLICATION) { - if (!ascii_strcasecmp ("pgp-keys", s)) - return 1; - } - - return 0; -} - -void mutt_free_envelope (ENVELOPE ** p) -{ - if (!*p) - return; - address_delete (&(*p)->return_path); - address_delete (&(*p)->from); - address_delete (&(*p)->to); - address_delete (&(*p)->cc); - address_delete (&(*p)->bcc); - address_delete (&(*p)->sender); - address_delete (&(*p)->reply_to); - address_delete (&(*p)->mail_followup_to); - - p_delete(&(*p)->list_post); - p_delete(&(*p)->subject); - /* real_subj is just an offset to subject and shouldn't be freed */ - p_delete(&(*p)->message_id); - p_delete(&(*p)->supersedes); - p_delete(&(*p)->date); - p_delete(&(*p)->x_label); - p_delete(&(*p)->organization); -#ifdef USE_NNTP - p_delete(&(*p)->newsgroups); - p_delete(&(*p)->xref); - p_delete(&(*p)->followup_to); - p_delete(&(*p)->x_comment_to); -#endif - - mutt_buffer_free (&(*p)->spam); - mutt_free_list (&(*p)->references); - mutt_free_list (&(*p)->in_reply_to); - mutt_free_list (&(*p)->userhdrs); - p_delete(p); -} - -/* move all the headers from extra not present in base into base */ -void mutt_merge_envelopes(ENVELOPE* base, ENVELOPE** extra) -{ - /* copies each existing element if necessary, and sets the element - * to NULL in the source so that mutt_free_envelope doesn't leave us - * with dangling pointers. */ -#define MOVE_ELEM(h) if (!base->h) { base->h = (*extra)->h; (*extra)->h = NULL; } - MOVE_ELEM(return_path); - MOVE_ELEM(from); - MOVE_ELEM(to); - MOVE_ELEM(cc); - MOVE_ELEM(bcc); - MOVE_ELEM(sender); - MOVE_ELEM(reply_to); - MOVE_ELEM(mail_followup_to); - MOVE_ELEM(list_post); - MOVE_ELEM(message_id); - MOVE_ELEM(supersedes); - MOVE_ELEM(date); - MOVE_ELEM(x_label); - if (!base->refs_changed) { - MOVE_ELEM(references); - } - if (!base->irt_changed) { - MOVE_ELEM(in_reply_to); - } - /* real_subj is subordinate to subject */ - if (!base->subject) { - base->subject = (*extra)->subject; - base->real_subj = (*extra)->real_subj; - (*extra)->subject = NULL; - (*extra)->real_subj = NULL; - } - /* spam and user headers should never be hashed, and the new envelope may - * have better values. Use new versions regardless. */ - mutt_buffer_free (&base->spam); - mutt_free_list (&base->userhdrs); - MOVE_ELEM(spam); - MOVE_ELEM(userhdrs); -#undef MOVE_ELEM - - mutt_free_envelope(extra); -} - -void _mutt_mktemp (char *s, const char *src, int line) -{ - - snprintf (s, _POSIX_PATH_MAX, "%s/muttng-%s-%d-%d-%d-%x%x", NONULL (Tempdir), - NONULL (Hostname), (int) getuid (), (int) getpid (), Counter++, - (unsigned int) rand(), (unsigned int) rand()); - debug_print (1, ("%s:%d: mutt_mktemp returns \"%s\".\n", src, line, s)); - unlink (s); -} - -void mutt_free_alias (ALIAS ** p) -{ - ALIAS *t; - - while (*p) { - t = *p; - *p = (*p)->next; - p_delete(&t->name); - address_delete (&t->addr); - p_delete(&t); - } + return m_strcpy(buf, len, tmp); } /* collapse the pathname using ~ or = when possible */ void mutt_pretty_mailbox (char *s) { char *p = s, *q = s; - size_t len; + ssize_t len; url_scheme_t scheme; scheme = url_check_scheme (s); -#ifdef USE_IMAP 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 (!strncmp (p, "//", 2)) + if (!m_strncmp (p, "//", 2)) q = strchr (p + 2, '/'); if (!q) q = strchr (p, '\0'); @@ -726,90 +200,16 @@ void mutt_pretty_mailbox (char *s) *s++ = '='; memmove (s, s + len, m_strlen(s + len) + 1); } - else if (m_strncmp(s, Homedir, (len = m_strlen(Homedir))) == 0 && - s[len] == '/') { + else if (m_strncmp(s, mod_core.homedir, (len = m_strlen(mod_core.homedir))) == 0 + && s[len] == '/') { *s++ = '~'; memmove (s, s + len - 1, m_strlen(s + len - 1) + 1); } } -void mutt_pretty_size (char *s, size_t len, long n) -{ - if (n == 0) - m_strcpy(s, len, "0K"); - 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 */ - /* 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 */ - snprintf (s, len, "%3.1fM", n / 1048576.0); - 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) -{ - 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) -{ - const char *p; - char *d; - size_t slen; - int found = 0; - - slen = m_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; - m_strcpy(d, destlen + 1, src); - d += destlen > slen ? slen : destlen; - destlen -= destlen > slen ? slen : destlen; - p++; - break; - default: - *d++ = *p; - destlen--; - break; - } - } - else { - *d++ = *p; - destlen--; - } - } - - *d = '\0'; - - if (!found && destlen > 0) { - m_strcat(dest, destlen, " "); - m_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 *fname, ssize_t flen, int *append, char **directory) { int rc = 0; @@ -841,9 +241,8 @@ int mutt_check_overwrite (const char *attname, const char *path, } } else - if ((rc = - mutt_yesorno (_("File is a directory, save under it?"), - M_YES)) != M_YES) + 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]) { @@ -877,293 +276,25 @@ int mutt_check_overwrite (const char *attname, const char *path, return 0; } -void mutt_save_path (char *d, size_t dsize, address_t * a) -{ - if (a && a->mailbox) { - m_strcpy(d, dsize, a->mailbox); - if (!option (OPTSAVEADDRESS)) { - char *p; - - if ((p = strpbrk (d, "%@"))) - *p = 0; - } - m_strtolower(d); - } - else - *d = 0; -} - -void mutt_safe_path (char *s, size_t l, address_t * a) +void mutt_save_path(char *d, ssize_t dsize, address_t *a) { - char *p; - - mutt_save_path (s, l, a); - for (p = s; *p; p++) - if (*p == '/' || ISSPACE (*p) || !IsPrint ((unsigned char) *p)) - *p = '_'; -} - -/* 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 ret = 0; - const char *p = s; - - while (s && *s) { - register const char *t = c; - - while (t && *t) { - if (*t == *s) - return (ret); - t++; - } - ret++; - s++; - } - return (m_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 */ - 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 */ - wlen = (flags & M_FORMAT_ARROWCURSOR && option (OPTARROWCURSOR)) ? 3 : 0; - col = wlen; - - while (*src && wlen < destlen) { - if (*src == '%') { - if (*++src == '%') { - *wptr++ = '%'; - wlen++; - col++; - src++; - continue; - } - - 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; - } - - if (!*src) - break; /* bad format */ - - ch = *src++; /* save the character to switch on */ - - if (flags & M_FORMAT_OPTIONAL) { - if (*src != '?') - break; /* bad format */ - src++; - - /* eat the `if' part of the string */ - cp = ifstring; - count = 0; - while (count < sizeof (ifstring) && *src && *src != '?' - && *src != '&') { - *cp++ = *src++; - 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 `?' */ - } - - /* 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 - SW) < destlen ? (COLS - SW) : destlen); - if (count > col) { - count -= col; /* how many columns left on this line */ - mutt_FormatString (buf, sizeof (buf), src, callback, data, flags); - wid = m_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 { - short lower = 0; - short nodots = 0; - - while (ch == '_' || ch == ':') { - if (ch == '_') - lower = 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 (lower) - m_strtolower(buf); - if (nodots) { - char *p = buf; - - for (; *p; p++) - if (*p == '.') - *p = '_'; - } - - if ((len = m_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 == '\\') { - 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; - } - src++; - wptr++; - wlen++; - col++; - } - else { - unsigned int bar = mutt_skipchars (src, "%\\"); - char *bar2 = p_dupstr(src, bar); - - while (bar--) { - *wptr++ = *src++; - wlen++; - } - col += mutt_strwidth (bar2); - p_delete(&bar2); + if (a && a->mailbox) { + m_strncpy(d, dsize, a->mailbox, strcspn(d, "%@")); + m_strtolower(d); + } else { + *d = '\0'; } - } - *wptr = 0; - -#if 0 - 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) ? ' ' : '.'; - } -#endif } -/* 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) +void mutt_safe_path(char *s, ssize_t l, address_t *a) { - int len = m_strlen(path); - FILE *f; + mutt_save_path(s, l, a); - if (path[len - 1] == '|') { - char *s = m_strdup(path); - - /* read from a pipe */ - - s[len - 1] = 0; - mutt_endwin (NULL); - *thepid = mutt_create_filter (s, NULL, &f, NULL); - p_delete(&s); - } else { - f = fopen (path, "r"); - if (!f) - return NULL; - *thepid = -1; + while (*s) { + if (*s == '/' || ISSPACE(*s) || !isprint((unsigned char)*s)) + *s = '_'; + s++; } - - return (f); } /* returns 0 if OK to proceed, -1 to abort, 1 to retry */ @@ -1182,14 +313,6 @@ int mutt_save_confirm (const char *s, struct stat *st) return 1; } -#ifdef USE_NNTP - if (magic == M_NNTP) { - mutt_error _("Can't save message to newsserver."); - - return 0; - } -#endif - if (magic > 0 && !mx_access (s, W_OK)) { if (option (OPTCONFIRMAPPEND) && (!TrashPath || (m_strcmp(s, TrashPath) != 0))) { @@ -1207,11 +330,8 @@ int mutt_save_confirm (const char *s, struct stat *st) mutt_error (_("%s is not a mailbox!"), s); return 1; } - } - else { -#ifdef USE_IMAP + } else { if (magic != M_IMAP) -#endif /* execute the block unconditionally if we don't use imap */ { st->st_mtime = 0; st->st_atime = 0; @@ -1224,171 +344,22 @@ int mutt_save_confirm (const char *s, struct stat *st) else if (rc == -1) ret = -1; } - } - else { + } else { mutt_perror (s); return 1; } } } - - CLEARLINE (LINES - 1); return (ret); } -void mutt_display_sanitize (char *s) -{ - for (; *s; s++) { - if (!IsPrint (*s)) - *s = '?'; - } -} - void mutt_sleep (short s) { - if (SleepTime > s) - sleep (SleepTime); - else if (s) - sleep (s); -} - -/* Decrease a file's modification time by 1 second */ -time_t mutt_decrease_mtime (const char *f, struct stat *st) -{ - struct utimbuf utim; - struct stat _st; - time_t mtime; - - if (!st) { - if (stat (f, &_st) == -1) - return -1; - st = &_st; - } - - if ((mtime = st->st_mtime) == time (NULL)) { - mtime -= 1; - utim.actime = mtime; - utim.modtime = mtime; - utime (f, &utim); - } - - return mtime; -} - -/* sets mtime of 'to' to mtime of 'from' */ -void mutt_set_mtime (const char* from, const char* to) { - struct utimbuf utim; - struct stat st; - - if (stat (from, &st) != -1) { - utim.actime = st.st_mtime; - utim.modtime = st.st_mtime; - utime (to, &utim); - } -} - -const char *mutt_make_version (int full) -{ - static char vstring[STRING]; - - if (full) - snprintf (vstring, sizeof (vstring), - "Mutt-ng %s-r%s (based on Mutt 1.5.11)", - MUTT_VERSION, MUTT_REVISION); - else - snprintf (vstring, sizeof (vstring), "mutt-ng/%s-r%s", - MUTT_VERSION, MUTT_REVISION); - return vstring; -} - -void mutt_free_spam_list (SPAM_LIST ** list) -{ - SPAM_LIST *p; - - if (!list) - return; - while (*list) { - p = *list; - *list = (*list)->next; - rx_free (&p->rx); - p_delete(&p->template); - p_delete(&p); - } -} - -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; - - tlen = 0; - - for (; l; l = l->next) { - /* If this pattern needs more matches, expand pmatch. */ - if (l->nmatch > nmatch) { - p_realloc(&pmatch, l->nmatch); - nmatch = l->nmatch; - } - - /* Does this pattern match? */ - if (regexec - (l->rx->rx, s, (size_t) l->nmatch, (regmatch_t *) pmatch, - (int) 0) == 0) { - debug_print (5, ("%s matches %s\n%d subst", s, l->rx->pattern, 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 ((unsigned char) *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'; - debug_print (5, ("\"%s\"\n", text)); - return 1; - } - } - - return 0; -} - -int mutt_cmp_header (const HEADER * h1, const HEADER * h2) { - if (h1 && h2) { - if (h1->received != h2->received || - h1->date_sent != h2->date_sent || - h1->content->length != h2->content->length || - h1->lines != h2->lines || - h1->zhours != h2->zhours || - h1->zminutes != h2->zminutes || - h1->zoccident != h2->zoccident || - h1->mime != h2->mime || - !mutt_cmp_env (h1->env, h2->env) || - !mutt_cmp_body (h1->content, h2->content)) - return (0); - else - return (1); - } - else { - if (h1 == NULL && h2 == NULL) - return (1); - else - return (0); - } + sleep(MAX(s, SleepTime)); } /* return 1 if address lists are strictly identical */ -int mutt_cmp_addr (const address_t * a, const address_t * b) +static int mutt_cmp_addr (const address_t * a, const address_t * b) { while (a && b) { if (m_strcmp(a->mailbox, b->mailbox) || @@ -1404,7 +375,7 @@ int mutt_cmp_addr (const address_t * a, const address_t * b) return (1); } -int mutt_cmp_list (const LIST * a, const LIST * b) +static int mutt_cmp_list (const string_list_t * a, const string_list_t * b) { while (a && b) { if (m_strcmp(a->data, b->data)) @@ -1419,7 +390,7 @@ int mutt_cmp_list (const LIST * a, const LIST * b) return (1); } -int mutt_cmp_env (const ENVELOPE * e1, const ENVELOPE * e2) +static int mutt_cmp_env (const ENVELOPE * e1, const ENVELOPE * e2) { if (e1 && e2) { if (m_strcmp(e1->message_id, e2->message_id) || @@ -1443,30 +414,218 @@ int mutt_cmp_env (const ENVELOPE * e1, const ENVELOPE * e2) } } -int mutt_cmp_param (const PARAMETER * p1, const PARAMETER * p2) -{ - while (p1 && p2) { - if (m_strcmp(p1->attribute, p2->attribute) || - m_strcmp(p1->value, p2->value)) - return (0); - - p1 = p1->next; - p2 = p2->next; - } - if (p1 || p2) - return (0); - - return (1); -} - -int mutt_cmp_body (const BODY * b1, const BODY * b2) +static int mutt_cmp_body (const BODY * b1, const BODY * b2) { if (b1->type != b2->type || b1->encoding != b2->encoding || m_strcmp(b1->subtype, b2->subtype) || m_strcmp(b1->description, b2->description) || - !mutt_cmp_param (b1->parameter, b2->parameter) || + !parameter_equal(b1->parameter, b2->parameter) || b1->length != b2->length) return (0); return (1); } +int mutt_cmp_header (const HEADER * h1, const HEADER * h2) { + if (h1 && h2) { + if (h1->received != h2->received || + h1->date_sent != h2->date_sent || + h1->content->length != h2->content->length || + h1->lines != h2->lines || + h1->zhours != h2->zhours || + h1->zminutes != h2->zminutes || + h1->zoccident != h2->zoccident || + h1->mime != h2->mime || + !mutt_cmp_env (h1->env, h2->env) || + !mutt_cmp_body (h1->content, h2->content)) + return (0); + else + return (1); + } + else { + if (h1 == NULL && h2 == NULL) + return (1); + else + return (0); + } +} + + +int mutt_extract_token(BUFFER *dest, BUFFER *tok, int flags) +{ + char ch; + char qc = 0; /* quote char */ + char *pc; + + /* reset the destination pointer to the beginning of the buffer */ + dest->dptr = dest->data; + + tok->dptr = vskipspaces(tok->dptr); + while ((ch = *tok->dptr)) { + if (!qc) { + if ((ISSPACE(ch) && !(flags & M_TOKEN_SPACE)) + || (ch == '#' && !(flags & M_TOKEN_COMMENT)) + || (ch == '=' && (flags & M_TOKEN_EQUAL)) + || ((flags & M_TOKEN_PATTERN) && strchr("~=!|", ch))) + { + break; + } + } + + tok->dptr++; + + if (ch == qc) { + qc = 0; /* end of quote */ + } else + if (!qc && (ch == '\'' || ch == '"') && !(flags & M_TOKEN_QUOTE)) { + qc = ch; + } else + if (ch == '\\' && qc != '\'') { + if (!*tok->dptr) + return -1; /* premature end of token */ + + switch (ch = *tok->dptr++) { + case 'c': + case 'C': + if (!*tok->dptr) + return -1; /* premature end of token */ + mutt_buffer_addch(dest, + (toupper((unsigned char)*tok->dptr) - 'A' + 1) & 0x7f); + tok->dptr++; + break; + case 'r': + mutt_buffer_addch(dest, '\r'); + break; + case 'n': + mutt_buffer_addch(dest, '\n'); + break; + case 't': + mutt_buffer_addch(dest, '\t'); + break; + case 'f': + mutt_buffer_addch(dest, '\f'); + break; + case 'e': + mutt_buffer_addch(dest, '\033'); + break; + default: + if (isdigit((unsigned char)ch) + && isdigit((unsigned char)*tok->dptr) + && isdigit((unsigned char)*(tok->dptr + 1))) + { + mutt_buffer_addch(dest, (ch << 6) + (*tok->dptr << 3) + + *(tok->dptr + 1) - 3504); + tok->dptr += 2; + } else { + mutt_buffer_addch(dest, ch); + } + } + } else + if (ch == '^' && (flags & M_TOKEN_CONDENSE)) { + if (!*tok->dptr) + return -1; /* premature end of token */ + ch = *tok->dptr++; + if (ch == '^') { + mutt_buffer_addch(dest, ch); + } else + if (ch == '[') { + mutt_buffer_addch(dest, '\033'); + } else + if (isalpha((unsigned char)ch)) { + mutt_buffer_addch(dest, toupper((unsigned char)ch) - 'A' + 1); + } else { + mutt_buffer_addch(dest, '^'); + mutt_buffer_addch(dest, ch); + } + } else + if (ch == '`' && (!qc || qc == '"')) { + FILE *fp; + pid_t pid; + char *cmd, *ptr; + ssize_t expnlen; + BUFFER expn; + int line = 0; + + pc = tok->dptr; + do { + if ((pc = strpbrk(pc, "\\`"))) { + /* skip any quoted chars */ + if (*pc == '\\') + pc += 2; + } + } while (pc && *pc != '`'); + if (!pc) { + return (-1); + } + + cmd = p_dupstr(tok->dptr, pc - tok->dptr); + if ((pid = mutt_create_filter(cmd, NULL, &fp, NULL)) < 0) { + p_delete(&cmd); + return -1; + } + p_delete(&cmd); + + tok->dptr = pc + 1; + + /* read line */ + p_clear(&expn, 1); + expn.data = mutt_read_line(NULL, &expn.dsize, fp, &line); + m_fclose(&fp); + mutt_wait_filter(pid); + + /* if we got output, make a new string consiting of the shell ouptput + plus whatever else was left on the original line */ + /* BUT: If this is inside a quoted string, directly add output to + * the token */ + if (expn.data && qc) { + mutt_buffer_addstr(dest, expn.data); + p_delete(&expn.data); + } else + if (expn.data) { + expnlen = m_strlen(expn.data); + tok->dsize = expnlen + m_strlen(tok->dptr) + 1; + ptr = xmalloc(tok->dsize); + memcpy(ptr, expn.data, expnlen); + m_strcpy(ptr + expnlen, tok->dsize - expnlen, tok->dptr); + if (tok->destroy) + p_delete(&tok->data); + tok->data = ptr; + tok->dptr = ptr; + tok->destroy = 1; /* mark that the caller should destroy this data */ + ptr = NULL; + p_delete(&expn.data); + } + } else + if (ch == '$' && (!qc || qc == '"') + && (*tok->dptr == '{' || isalpha((unsigned char)*tok->dptr))) + { + char *env = NULL, *var = NULL; + + if (*tok->dptr == '{') { + tok->dptr++; + if ((pc = strchr (tok->dptr, '}'))) { + var = p_dupstr(tok->dptr, pc - tok->dptr); + tok->dptr = pc + 1; + } + } else { + for (pc = tok->dptr; isalnum((unsigned char)*pc) || *pc == '_'; + pc++); + var = p_dupstr(tok->dptr, pc - tok->dptr); + tok->dptr = pc; + } + if (var) { + char tmp[STRING]; + if ((env = getenv (var)) + || (mutt_option_value (var, tmp, sizeof (tmp)) && (env = tmp))) + { + mutt_buffer_addstr (dest, env); + } + } + p_delete(&var); + } else { + mutt_buffer_addch(dest, ch); + } + } + mutt_buffer_addch(dest, 0); /* terminate the string */ + tok->dptr = vskipspaces(tok->dptr); + return 0; +}