X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=muttlib.c;h=f7449df8df9a792bfc4dc46033b279d29b00e45e;hp=d7e88ed4da1165bf8acdac7b6b4fd64d0009113b;hb=774b53097f8c8b62c5101bce8f313d339387a438;hpb=814a01519c9605d479201b99eb16c97b0ad8635d diff --git a/muttlib.c b/muttlib.c index d7e88ed..f7449df 100644 --- a/muttlib.c +++ b/muttlib.c @@ -12,47 +12,46 @@ # include "config.h" #endif -#include "mutt.h" -#include "mutt_curses.h" -#include "mime.h" -#include "mx.h" -#include "url.h" - -#include "reldate.h" - -#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 "lib/debug.h" - -#include #include -#include -#include -#include #include -#include #include -#include +#include +#include +#include +#include +#include #include +#include +#include +#include #include -BODY *mutt_new_body (void) -{ - BODY *p = (BODY *) safe_calloc (1, sizeof (BODY)); +#include +#include +#include +#include +#include +#include +#include - p->disposition = DISPATTACH; - p->use_disp = 1; - return (p); -} +#include + +#include +#include + +#include "alias.h" +#include "mutt.h" +#include "mx.h" +#include "attach.h" +#include "version.h" + +#include +#include + +#include + +#define SW (option(OPTMBOXPANE)?SidebarWidth:0) /* Modified by blong to accept a "suggestion" for file name. If * that file exists, then construct one with unique name but @@ -60,22 +59,22 @@ 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 (char *s, size_t l) +void mutt_adv_mktemp (const char* dir, char *s, ssize_t l) { char buf[_POSIX_PATH_MAX]; char tmp[_POSIX_PATH_MAX]; char *period; - size_t sl; + ssize_t sl; struct stat sb; - strfcpy (buf, NONULL (Tempdir), sizeof (buf)); + 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 { - strfcpy (tmp, s, sizeof (tmp)); + 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) @@ -86,8 +85,8 @@ void mutt_adv_mktemp (char *s, size_t l) mktemp (s); if (period != NULL) { *period = '.'; - sl = safe_strlen (s); - strfcpy (s + sl, period, l - sl); + sl = m_strlen(s); + m_strcpy(s + sl, l - sl, period); } } } @@ -99,43 +98,43 @@ int mutt_copy_body (FILE * fp, BODY ** tgt, BODY * src) char tmp[_POSIX_PATH_MAX]; BODY *b; - PARAMETER *par, **ppar; + parameter_t *par, **ppar; short use_disp; if (src->filename) { use_disp = 1; - strfcpy (tmp, src->filename, sizeof (tmp)); + m_strcpy(tmp, sizeof(tmp), src->filename); } else { use_disp = 0; tmp[0] = '\0'; } - mutt_adv_mktemp (tmp, sizeof (tmp)); + mutt_adv_mktemp (NULL, tmp, sizeof (tmp)); if (mutt_save_attachment (fp, src, tmp, 0, NULL) == -1) return -1; - *tgt = mutt_new_body (); + *tgt = body_new(); b = *tgt; memcpy (b, src, sizeof (BODY)); b->parts = NULL; b->next = NULL; - b->filename = safe_strdup (tmp); + b->filename = m_strdup(tmp); b->use_disp = use_disp; b->unlink = 1; if (mutt_is_text_part (b)) b->noconv = 1; - b->xtype = safe_strdup (b->xtype); - b->subtype = safe_strdup (b->subtype); - b->form_name = safe_strdup (b->form_name); - b->filename = safe_strdup (b->filename); - b->d_filename = safe_strdup (b->d_filename); - b->description = safe_strdup (b->description); + 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. @@ -148,9 +147,9 @@ int mutt_copy_body (FILE * fp, BODY ** tgt, BODY * src) /* copy parameters */ 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); + *ppar = parameter_new(); + (*ppar)->attribute = m_strdup(par->attribute); + (*ppar)->value = m_strdup(par->value); } mutt_stamp_attachment (b); @@ -158,167 +157,53 @@ int mutt_copy_body (FILE * fp, BODY ** tgt, BODY * src) return 0; } - - -void mutt_free_body (BODY ** p) -{ - BODY *a = *p, *b; - - while (a) { - b = a; - a = a->next; - - 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)); - - FREE (&b->filename); - FREE (&b->content); - FREE (&b->xtype); - FREE (&b->subtype); - FREE (&b->description); - FREE (&b->form_name); - - if (b->hdr) { - /* Don't free twice (b->hdr->content = b->parts) */ - b->hdr->content = NULL; - mutt_free_header (&b->hdr); - } - - if (b->parts) - mutt_free_body (&b->parts); - - FREE (&b); - } - - *p = 0; -} - -void mutt_free_parameter (PARAMETER ** p) -{ - PARAMETER *t = *p; - PARAMETER *o; - - while (t) { - FREE (&t->attribute); - FREE (&t->value); - o = t; - t = t->next; - FREE (&o); - } - *p = 0; -} - -LIST *mutt_add_list (LIST * head, const char *data) -{ - LIST *tmp; - - for (tmp = head; tmp && tmp->next; tmp = tmp->next); - if (tmp) { - tmp->next = safe_malloc (sizeof (LIST)); - tmp = tmp->next; - } - else - head = tmp = safe_malloc (sizeof (LIST)); - - tmp->data = safe_strdup (data); - tmp->next = NULL; - return head; -} - -void mutt_free_list (LIST ** list) -{ - LIST *p; - - if (!list) - return; - while (*list) { - p = *list; - *list = (*list)->next; - FREE (&p->data); - FREE (&p); - } -} - -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); - FREE (&(*h)->maildir_flags); - FREE (&(*h)->tree); - FREE (&(*h)->path); -#ifdef MIXMASTER - mutt_free_list (&(*h)->chain); -#endif -#if defined USE_POP || defined USE_IMAP || defined USE_NNTP - FREE (&(*h)->data); -#endif - FREE (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, string_list_t * t) { for (; t; t = t->next) { - if (!ascii_strncasecmp (s, t->data, safe_strlen (t->data)) + if (!ascii_strncasecmp (s, t->data, m_strlen(t->data)) || *t->data == '*') return 1; } return 0; } -/* prepend the path part of *path to *link */ -void mutt_expand_link (char *newpath, const char *path, const char *link) +/* 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; + ssize_t len; - /* link is full path */ - if (*link == '/') { - strfcpy (newpath, link, _POSIX_PATH_MAX); + /* lnk is full path */ + if (*lnk == '/') { + m_strcpy(newpath, _POSIX_PATH_MAX, lnk); return; } if ((lb = strrchr (path, '/')) == NULL) { - /* no path in link */ - strfcpy (newpath, link, _POSIX_PATH_MAX); + /* no path in lnk */ + m_strcpy(newpath, _POSIX_PATH_MAX, lnk); return; } len = lb - path + 1; memcpy (newpath, path, len); - strfcpy (newpath + len, link, _POSIX_PATH_MAX - len); + m_strcpy(newpath + len, _POSIX_PATH_MAX - len, lnk); } -char *mutt_expand_path (char *s, size_t slen) +char *mutt_expand_path (char *s, ssize_t slen) { return _mutt_expand_path (s, slen, 0); } -char *_mutt_expand_path (char *s, size_t slen, int rx) +char *_mutt_expand_path (char *s, ssize_t slen, int rx) { char p[_POSIX_PATH_MAX] = ""; char q[_POSIX_PATH_MAX] = ""; char tmp[_POSIX_PATH_MAX]; char *t; - char *tail = ""; + const char *tail = ""; int recurse = 0; @@ -329,7 +214,7 @@ char *_mutt_expand_path (char *s, size_t slen, int rx) case '~': { if (*(s + 1) == '/' || *(s + 1) == 0) { - strfcpy (p, NONULL (Homedir), sizeof (p)); + m_strcpy(p, sizeof(p), NONULL(Homedir)); tail = s + 1; } else { @@ -339,7 +224,7 @@ char *_mutt_expand_path (char *s, size_t slen, int rx) *t = 0; if ((pw = getpwnam (s + 1))) { - strfcpy (p, pw->pw_dir, sizeof (p)); + m_strcpy(p, sizeof(p), pw->pw_dir); if (t) { *t = '/'; tail = t; @@ -361,14 +246,11 @@ char *_mutt_expand_path (char *s, size_t slen, int rx) case '=': case '+': { -#ifdef USE_IMAP - /* 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)); + /* 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)); tail = s + 1; @@ -380,15 +262,16 @@ char *_mutt_expand_path (char *s, size_t slen, int rx) case '@': { HEADER *h; - ADDRESS *alias; + /* FIXME: BUG ? */ + address_t *alias; - if ((alias = mutt_lookup_alias (s + 1))) { - h = mutt_new_header (); - h->env = mutt_new_envelope (); + if ((alias = alias_lookup(s + 1))) { + h = header_new(); + h->env = envelope_new(); 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); + header_delete(&h); /* Avoid infinite recursion if the resulting folder starts with '@' */ if (*p != '@') recurse = 1; @@ -400,14 +283,14 @@ char *_mutt_expand_path (char *s, size_t slen, int rx) case '>': { - strfcpy (p, NONULL (Inbox), sizeof (p)); + m_strcpy(p, sizeof(p), NONULL(Inbox)); tail = s + 1; } break; case '<': { - strfcpy (p, NONULL (Outbox), sizeof (p)); + m_strcpy(p, sizeof(p), NONULL(Outbox)); tail = s + 1; } break; @@ -415,11 +298,11 @@ char *_mutt_expand_path (char *s, size_t slen, int rx) case '!': { if (*(s + 1) == '!') { - strfcpy (p, NONULL (LastFolder), sizeof (p)); + m_strcpy(p, sizeof(p), NONULL(LastFolder)); tail = s + 2; } else { - strfcpy (p, NONULL (Spoolfile), sizeof (p)); + m_strcpy(p, sizeof(p), NONULL(Spoolfile)); tail = s + 1; } } @@ -427,14 +310,14 @@ char *_mutt_expand_path (char *s, size_t slen, int rx) case '-': { - strfcpy (p, NONULL (LastFolder), sizeof (p)); + m_strcpy(p, sizeof(p), NONULL(LastFolder)); tail = s + 1; } break; case '^': { - strfcpy (p, NONULL (CurrentFolder), sizeof (p)); + m_strcpy(p, sizeof(p), NONULL(CurrentFolder)); tail = s + 1; } break; @@ -447,240 +330,85 @@ char *_mutt_expand_path (char *s, size_t slen, int rx) } if (rx && *p && !recurse) { - mutt_rx_sanitize_string (q, sizeof (q), p); + 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); + m_strcpy(s, slen, tmp); } while (recurse); -#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 (imap_is_magic (s, NULL) == M_IMAP) - imap_expand_path (s, slen); -#endif - 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; - - memset (dest, 0, destlen); - - 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)); - } - 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 = safe_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) { - str_replace (&q->value, value); - return; - } - } - - 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) +/* move all the headers from extra not present in base into base */ +void mutt_merge_envelopes(ENVELOPE* base, ENVELOPE** extra) { - 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; - } + /* copies each existing element if necessary, and sets the element + * to NULL in the source so that envelope_delete 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); } -} - -/* 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 ((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; + if (!base->irt_changed) { + MOVE_ELEM(in_reply_to); } - - return 1; -} - -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 (!ascii_strcasecmp ("delivery-status", s)) - return 1; - } - - if ((WithCrypto & APPLICATION_PGP) && t == TYPEAPPLICATION) { - if (!ascii_strcasecmp ("pgp-keys", s)) - return 1; + /* 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; } - - return 0; -} - -void mutt_free_envelope (ENVELOPE ** p) -{ - if (!*p) - return; - rfc822_free_address (&(*p)->return_path); - rfc822_free_address (&(*p)->from); - rfc822_free_address (&(*p)->to); - rfc822_free_address (&(*p)->cc); - rfc822_free_address (&(*p)->bcc); - rfc822_free_address (&(*p)->sender); - rfc822_free_address (&(*p)->reply_to); - rfc822_free_address (&(*p)->mail_followup_to); - - FREE (&(*p)->list_post); - FREE (&(*p)->subject); - /* real_subj is just an offset to subject and shouldn't be freed */ - FREE (&(*p)->message_id); - FREE (&(*p)->supersedes); - FREE (&(*p)->date); - FREE (&(*p)->x_label); - FREE (&(*p)->organization); -#ifdef USE_NNTP - FREE (&(*p)->newsgroups); - FREE (&(*p)->xref); - FREE (&(*p)->followup_to); - FREE (&(*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); - FREE (p); + /* 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); + string_list_wipe(&base->userhdrs); + MOVE_ELEM(spam); + MOVE_ELEM(userhdrs); +#undef MOVE_ELEM + + envelope_delete(extra); } void _mutt_mktemp (char *s, const char *src, int line) { - snprintf (s, _POSIX_PATH_MAX, "%s/muttng-%s-%d-%d-%d", NONULL (Tempdir), - NONULL (Hostname), (int) getuid (), (int) getpid (), Counter++); - 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; - FREE (&t->name); - rfc822_free_address (&t->addr); - FREE (&t); - } + snprintf (s, _POSIX_PATH_MAX, "%s/madmutt-%s-%d-%d-%d-%x%x", NONULL (Tempdir), + NONULL (Hostname), (int) getuid (), (int) getpid (), Counter++, + (unsigned int) rand(), (unsigned int) rand()); + unlink (s); } /* 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) { @@ -707,22 +435,22 @@ void mutt_pretty_mailbox (char *s) } *q = 0; - if (safe_strncmp (s, Maildir, (len = safe_strlen (Maildir))) == 0 && + if (m_strncmp(s, Maildir, (len = m_strlen(Maildir))) == 0 && s[len] == '/') { *s++ = '='; - memmove (s, s + len, safe_strlen (s + len) + 1); + memmove (s, s + len, m_strlen(s + len) + 1); } - else if (safe_strncmp (s, Homedir, (len = safe_strlen (Homedir))) == 0 && + else if (m_strncmp(s, Homedir, (len = m_strlen(Homedir))) == 0 && s[len] == '/') { *s++ = '~'; - memmove (s, s + len - 1, safe_strlen (s + len - 1) + 1); + memmove (s, s + len - 1, m_strlen(s + len - 1) + 1); } } -void mutt_pretty_size (char *s, size_t len, long n) +void mutt_pretty_size (char *s, ssize_t len, long n) { if (n == 0) - strfcpy (s, "0K", len); + 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 */ @@ -738,7 +466,7 @@ void mutt_pretty_size (char *s, size_t len, long n) } } -void mutt_expand_file_fmt (char *dest, size_t destlen, const char *fmt, +void mutt_expand_file_fmt (char *dest, ssize_t destlen, const char *fmt, const char *src) { char tmp[LONG_STRING]; @@ -747,15 +475,15 @@ void mutt_expand_file_fmt (char *dest, size_t destlen, const char *fmt, mutt_expand_fmt (dest, destlen, fmt, tmp); } -void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt, +void mutt_expand_fmt (char *dest, ssize_t destlen, const char *fmt, const char *src) { const char *p; char *d; - size_t slen; + ssize_t slen; int found = 0; - slen = safe_strlen (src); + slen = m_strlen(src); destlen--; for (p = fmt, d = dest; destlen && *p; p++) { @@ -767,7 +495,7 @@ void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt, break; case 's': found = 1; - strfcpy (d, src, destlen + 1); + m_strcpy(d, destlen + 1, src); d += destlen > slen ? slen : destlen; destlen -= destlen > slen ? slen : destlen; p++; @@ -787,22 +515,22 @@ void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt, *d = '\0'; if (!found && destlen > 0) { - safe_strcat (dest, destlen, " "); - safe_strcat (dest, destlen, src); + 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; char tmp[_POSIX_PATH_MAX]; struct stat st; - strfcpy (fname, path, flen); + m_strcpy(fname, flen, path); if (access (fname, F_OK) != 0) return 0; if (stat (fname, &st) != 0) @@ -813,16 +541,16 @@ int mutt_check_overwrite (const char *attname, const char *path, (_("File is a directory, save under it? [(y)es, (n)o, (a)ll]"), _("yna"))) { case 3: /* all */ - str_replace (directory, fname); + m_strreplace(directory, fname); break; case 1: /* yes */ - FREE (directory); + p_delete(directory); break; case -1: /* abort */ - FREE (directory); + p_delete(directory); return -1; case 2: /* no */ - FREE (directory); + p_delete(directory); return 1; } } @@ -837,10 +565,10 @@ int mutt_check_overwrite (const char *attname, const char *path, if (mutt_get_field (_("File under directory: "), tmp, sizeof (tmp), M_FILE | M_CLEAR) != 0 || !tmp[0]) return (-1); - mutt_concat_path (fname, path, tmp, flen); + mutt_concat_path(fname, flen, path, tmp); } else - mutt_concat_path (fname, path, mutt_basename (attname), flen); + mutt_concat_path(fname, flen, path, mutt_basename(attname)); } if (*append == 0 && access (fname, F_OK) == 0) { @@ -863,23 +591,23 @@ int mutt_check_overwrite (const char *attname, const char *path, return 0; } -void mutt_save_path (char *d, size_t dsize, ADDRESS * a) +void mutt_save_path (char *d, ssize_t dsize, address_t * a) { if (a && a->mailbox) { - strfcpy (d, a->mailbox, dsize); + m_strcpy(d, dsize, a->mailbox); if (!option (OPTSAVEADDRESS)) { char *p; if ((p = strpbrk (d, "%@"))) *p = 0; } - str_tolower (d); + m_strtolower(d); } else *d = 0; } -void mutt_safe_path (char *s, size_t l, ADDRESS * a) +void mutt_safe_path (char *s, ssize_t l, address_t * a) { char *p; @@ -907,11 +635,11 @@ int mutt_skipchars (const char *s, const char *c) ret++; s++; } - return (safe_strlen (p)); + return (m_strlen(p)); } void mutt_FormatString (char *dest, /* output buffer */ - size_t destlen, /* output buffer len */ + ssize_t destlen, /* output buffer len */ const char *src, /* template string */ format_t * callback, /* callback for processing */ unsigned long data, /* callback data */ @@ -919,7 +647,7 @@ void mutt_FormatString (char *dest, /* output buffer */ { /* 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; + ssize_t wlen, wid, count, col, len; prefix[0] = '\0'; destlen--; /* save room for the terminal \0 */ @@ -946,7 +674,7 @@ void mutt_FormatString (char *dest, /* output buffer */ /* eat the format string */ cp = prefix; count = 0; - while (count < sizeof (prefix) && + while (count < ssizeof (prefix) && (isdigit ((unsigned char) *src) || *src == '.' || *src == '-')) { *cp++ = *src++; @@ -968,7 +696,7 @@ void mutt_FormatString (char *dest, /* output buffer */ /* eat the `if' part of the string */ cp = ifstring; count = 0; - while (count < sizeof (ifstring) && *src && *src != '?' + while (count < ssizeof (ifstring) && *src && *src != '?' && *src != '&') { *cp++ = *src++; count++; @@ -980,7 +708,7 @@ void mutt_FormatString (char *dest, /* output buffer */ src++; /* skip the & */ cp = elsestring; count = 0; - while (count < sizeof (elsestring) && *src && *src != '?') { + while (count < ssizeof (elsestring) && *src && *src != '?') { *cp++ = *src++; count++; } @@ -1001,13 +729,11 @@ void mutt_FormatString (char *dest, /* output buffer */ if (DrawFullLine || option (OPTSTATUSONTOP)) count = (COLS < destlen ? COLS : destlen); else - count = - ((COLS - SidebarWidth) < - destlen ? (COLS - SidebarWidth) : destlen); + 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 = safe_strlen (buf); + wid = m_strlen(buf); if (count > wid) { count -= wid; /* how many chars to pad */ memset (wptr, ch, count); @@ -1038,12 +764,12 @@ void mutt_FormatString (char *dest, /* output buffer */ break; /* skip rest of input */ } else { - short tolower = 0; + short lower = 0; short nodots = 0; while (ch == '_' || ch == ':') { if (ch == '_') - tolower = 1; + lower = 1; else if (ch == ':') nodots = 1; @@ -1055,8 +781,8 @@ void mutt_FormatString (char *dest, /* output buffer */ callback (buf, sizeof (buf), ch, src, prefix, ifstring, elsestring, data, flags); - if (tolower) - str_tolower (buf); + if (lower) + m_strtolower(buf); if (nodots) { char *p = buf; @@ -1065,7 +791,7 @@ void mutt_FormatString (char *dest, /* output buffer */ *p = '_'; } - if ((len = safe_strlen (buf)) + wlen > destlen) + if ((len = m_strlen(buf)) + wlen > destlen) len = (destlen - wlen > 0) ? (destlen - wlen) : 0; memcpy (wptr, buf, len); @@ -1104,15 +830,14 @@ void mutt_FormatString (char *dest, /* output buffer */ } else { unsigned int bar = mutt_skipchars (src, "%\\"); - char *bar2 = safe_malloc (bar + 1); + char *bar2 = p_dupstr(src, bar); - strfcpy (bar2, src, bar + 1); while (bar--) { *wptr++ = *src++; wlen++; } col += mutt_strwidth (bar2); - FREE (&bar2); + p_delete(&bar2); } } *wptr = 0; @@ -1133,32 +858,26 @@ void mutt_FormatString (char *dest, /* output buffer */ 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 *f; - struct stat s; - - int len = safe_strlen (path); - - if (path[len - 1] == '|') { - /* read from a pipe */ - - char *s = safe_strdup (path); - - s[len - 1] = 0; - mutt_endwin (NULL); - *thepid = mutt_create_filter (s, NULL, &f, NULL); - FREE (&s); - } - else { - if (stat (path, &s) < 0) - return (NULL); - if (S_ISDIR (s.st_mode)) { - errno = EINVAL; - return (NULL); + int len = m_strlen(path); + FILE *f; + + 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; } - f = fopen (path, "r"); - *thepid = -1; - } - return (f); + + return (f); } /* returns 0 if OK to proceed, -1 to abort, 1 to retry */ @@ -1171,13 +890,11 @@ int mutt_save_confirm (const char *s, struct stat *st) magic = mx_get_magic (s); -#ifdef USE_POP if (magic == M_POP) { mutt_error _("Can't save message to POP mailbox."); return 1; } -#endif #ifdef USE_NNTP if (magic == M_NNTP) { @@ -1187,16 +904,10 @@ int mutt_save_confirm (const char *s, struct stat *st) } #endif - if (stat (s, st) != -1) { - if (magic == -1) { - mutt_error (_("%s is not a mailbox!"), s); - return 1; - } - + if (magic > 0 && !mx_access (s, W_OK)) { if (option (OPTCONFIRMAPPEND) && - (!TrashPath || (safe_strcmp (s, TrashPath) != 0))) + (!TrashPath || (m_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; @@ -1204,10 +915,15 @@ int mutt_save_confirm (const char *s, struct stat *st) ret = -1; } } + + if (stat (s, st) != -1) { + if (magic == -1) { + mutt_error (_("%s is not a mailbox!"), s); + return 1; + } + } else { -#ifdef USE_IMAP if (magic != M_IMAP) -#endif /* execute the block unconditionally if we don't use imap */ { st->st_mtime = 0; st->st_atime = 0; @@ -1232,81 +948,6 @@ int mutt_save_confirm (const char *s, struct stat *st) return (ret); } -void state_prefix_putc (char c, STATE * s) -{ - if (s->flags & M_PENDINGPREFIX) { - int i; - - i = safe_strlen (Quotebuf); - Quotebuf[i++] = c; - Quotebuf[i] = '\0'; - 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[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); - - state_puts (buf, s); - } - } - else - state_putc (c, s); - - if (c == '\n') { - state_set_prefix (s); - Quotebuf[0] = '\0'; - } -} - -int state_printf (STATE * s, const char *fmt, ...) -{ - int rv; - va_list ap; - - va_start (ap, fmt); - rv = vfprintf (s->fpout, fmt, ap); - va_end (ap); - - return rv; -} - -void state_mark_attach (STATE * s) -{ - if ((s->flags & M_DISPLAY) && !safe_strcmp (Pager, "builtin")) - state_puts (AttachmentMarker, s); -} - -void state_attach_puts (const char *t, STATE * s) -{ - if (*t != '\n') - state_mark_attach (s); - while (*t) { - state_putc (*t, s); - if (*t++ == '\n' && *t) - if (*t != '\n') - state_mark_attach (s); - } -} - void mutt_display_sanitize (char *s) { for (; *s; s++) { @@ -1323,87 +964,7 @@ void mutt_sleep (short s) sleep (s); } -/* - * Creates and initializes a BUFFER*. If passed an existing BUFFER*, - * just initializes. Frees anything already in the buffer. - * - * 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) -{ - if (!b) { - b = safe_malloc (sizeof (BUFFER)); - if (!b) - return NULL; - } - else { - FREE(&b->data); - } - memset (b, 0, sizeof (BUFFER)); - return b; -} - -/* - * Creates and initializes a BUFFER*. If passed an existing BUFFER*, - * just initializes. Frees anything already in the buffer. Copies in - * the seed string. - * - * 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) -{ - if (!seed) - return NULL; - - b = mutt_buffer_init (b); - b->data = safe_strdup (seed); - b->dsize = safe_strlen (seed); - b->dptr = (char *) b->data + b->dsize; - return b; -} - -void mutt_buffer_addstr (BUFFER * buf, const char *s) -{ - mutt_buffer_add (buf, s, safe_strlen (s)); -} - -void mutt_buffer_addch (BUFFER * buf, char c) -{ - mutt_buffer_add (buf, &c, 1); -} - -void mutt_buffer_free (BUFFER ** p) -{ - if (!p || !*p) - return; - - 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) -{ - size_t offset; - - 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); - buf->dptr = buf->data + offset; - } - memcpy (buf->dptr, s, len); - buf->dptr += len; - *(buf->dptr) = '\0'; -} - /* Decrease a file's modification time by 1 second */ - time_t mutt_decrease_mtime (const char *f, struct stat *st) { struct utimbuf utim; @@ -1426,12 +987,29 @@ time_t mutt_decrease_mtime (const char *f, struct stat *st) return mtime; } -const char *mutt_make_version (void) +/* 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]; - snprintf (vstring, sizeof (vstring), "Mutt-ng %s (%s)", - MUTT_VERSION, ReleaseDate); + if (full) + snprintf (vstring, sizeof (vstring), + "Madmutt/%s-r%s (based on Mutt 1.5.11)", + MUTT_VERSION, MUTT_REVISION); + else + snprintf (vstring, sizeof (vstring), "Madmutt/%s-%s", + MUTT_VERSION, MUTT_REVISION); return vstring; } @@ -1444,9 +1022,9 @@ void mutt_free_spam_list (SPAM_LIST ** list) while (*list) { p = *list; *list = (*list)->next; - rx_free (&p->rx); - FREE(&p->template); - FREE(&p); + rx_delete(&p->rx); + p_delete(&p->template); + p_delete(&p); } } @@ -1465,21 +1043,18 @@ int mutt_match_spam_list (const char *s, SPAM_LIST * l, char *text, int x) 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)); + 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)); - + if (regexec(l->rx->rx, s, l->nmatch, (regmatch_t *)pmatch, (int) 0) == 0) + { /* Copy template into text, with substitutions. */ for (p = l->template; *p;) { if (*p == '%') { n = atoi (++p); /* find pmatch index */ - while (isdigit (*p)) + 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]; @@ -1489,10 +1064,101 @@ int mutt_match_spam_list (const char *s, SPAM_LIST * l, char *text, int x) } } 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); + } +} + +/* return 1 if address lists are strictly identical */ +int mutt_cmp_addr (const address_t * a, const address_t * b) +{ + while (a && b) { + if (m_strcmp(a->mailbox, b->mailbox) || + m_strcmp(a->personal, b->personal)) + return (0); + + a = a->next; + b = b->next; + } + if (a || b) + return (0); + + return (1); +} + +int mutt_cmp_list (const string_list_t * a, const string_list_t * b) +{ + while (a && b) { + if (m_strcmp(a->data, b->data)) + return (0); + + a = a->next; + b = b->next; + } + if (a || b) + return (0); + + return (1); +} + +int mutt_cmp_env (const ENVELOPE * e1, const ENVELOPE * e2) +{ + if (e1 && e2) { + if (m_strcmp(e1->message_id, e2->message_id) || + m_strcmp(e1->subject, e2->subject) || + !mutt_cmp_list (e1->references, e2->references) || + !mutt_cmp_addr (e1->from, e2->from) || + !mutt_cmp_addr (e1->sender, e2->sender) || + !mutt_cmp_addr (e1->reply_to, e2->reply_to) || + !mutt_cmp_addr (e1->to, e2->to) || + !mutt_cmp_addr (e1->cc, e2->cc) || + !mutt_cmp_addr (e1->return_path, e2->return_path)) + return (0); + else + return (1); + } + else { + if (e1 == NULL && e2 == NULL) + return (1); + else + return (0); + } +} + +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) || + !parameter_equal(b1->parameter, b2->parameter) || + b1->length != b2->length) + return (0); + return (1); +}