X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=muttlib.c;h=5ad138c795ff5a10b6ef445d78f4b783fb4d0bfe;hp=6892168aec2a17d418f9c2d2d274044d47125fe7;hb=2a2f2f9a5bad73c883b7f9c9b4166d932b6aaf37;hpb=b8c71f93b0296f815a6538182343ba67e88c0012

diff --git a/muttlib.c b/muttlib.c
index 6892168..5ad138c 100644
--- a/muttlib.c
+++ b/muttlib.c
@@ -12,20 +12,36 @@
 # include "config.h"
 #endif
 
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <grp.h>
+#include <pwd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <time.h>
+#include <unistd.h>
+#include <utime.h>
+
 #include <lib-lib/mem.h>
 #include <lib-lib/ascii.h>
 #include <lib-lib/str.h>
 #include <lib-lib/macros.h>
 #include <lib-lib/buffer.h>
 #include <lib-lib/file.h>
+#include <lib-lib/url.h>
 
 #include <lib-mime/mime.h>
 
+#include <lib-ui/curses.h>
+#include <lib-ui/enter.h>
+
+#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"
@@ -33,21 +49,7 @@
 #include <imap/imap.h>
 #include <imap/mx_imap.h>
 
-#include "mutt_crypt.h"
-
-#include "lib/debug.h"
-
-#include <string.h>
-#include <ctype.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <sys/wait.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <time.h>
-#include <sys/types.h>
-#include <utime.h>
+#include <lib-crypt/crypt.h>
 
 #define SW              (option(OPTMBOXPANE)?SidebarWidth:0)
 
@@ -67,12 +69,12 @@ 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)
+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;
 
   m_strcpy(buf, sizeof(buf), m_strisempty(dir) ? NONULL(Tempdir) : dir);
@@ -155,7 +157,7 @@ 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 = parameter_new();
     (*ppar)->attribute = m_strdup(par->attribute);
     (*ppar)->value = m_strdup(par->value);
   }
@@ -166,23 +168,14 @@ int mutt_copy_body (FILE * fp, BODY ** tgt, BODY * src)
 }
 
 
-
-void mutt_free_body (BODY ** p)
+static void body_wipe(BODY *b)
 {
-  BODY *a = *p, *b;
-
-  while (a) {
-    b = a;
-    a = a->next;
-
     if (b->parameter)
-      mutt_free_parameter (&b->parameter);
+        parameter_list_wipe(&b->parameter);
+
     if (b->unlink && b->filename) {
-      debug_print (1, ("unlinking %s.\n", b->filename));
-      unlink (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);
@@ -192,62 +185,38 @@ void mutt_free_body (BODY ** p)
     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);
+        /* Don't free twice (b->hdr->content = b->parts) */
+        b->hdr->content = NULL;
+        header_delete(&b->hdr);
     }
 
     if (b->parts)
-      mutt_free_body (&b->parts);
-
-    p_delete(&b);
-  }
-
-  *p = 0;
+        mutt_free_body(&b->parts);
 }
 
-void mutt_free_parameter (PARAMETER ** p)
+DO_DELETE(BODY, body);
+
+void mutt_free_body(BODY **p)
 {
-  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;
+    while (*p) {
+        BODY *b = *p;
+        *p = b->next;
+
+        body_delete(&b);
+    }
 }
 
 HEADER *mutt_dup_header (HEADER * h)
 {
   HEADER *hnew;
 
-  hnew = mutt_new_header ();
+  hnew = header_new();
   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)
+int mutt_matches_ignore (const char *s, string_list_t * t)
 {
   for (; t; t = t->next) {
     if (!ascii_strncasecmp (s, t->data, m_strlen(t->data))
@@ -261,7 +230,7 @@ int mutt_matches_ignore (const char *s, LIST * t)
 void mutt_expand_link (char *newpath, const char *path, const char *lnk)
 {
   const char *lb = NULL;
-  size_t len;
+  ssize_t len;
 
   /* lnk is full path */
   if (*lnk == '/') {
@@ -280,12 +249,12 @@ void mutt_expand_link (char *newpath, const char *path, const char *lnk)
   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] = "";
@@ -351,15 +320,16 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
     case '@':
       {
         HEADER *h;
+        /* 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;
@@ -418,7 +388,7 @@ 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
@@ -431,96 +401,40 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
   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;
+    PARAMETER *q;
 
-  if (!value) {
-    mutt_delete_parameter (attribute, p);
-    return;
-  }
+    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;
+    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;
+    q = parameter_new();
+    q->attribute = m_strdup(attribute);
+    q->value = m_strdup(value);
+    parameter_list_push(p, q);
 }
 
 void mutt_delete_parameter (const char *attribute, PARAMETER ** p)
 {
-  PARAMETER *q;
+    while (*p) {
+        if (!ascii_strcasecmp(attribute, (*p)->attribute)) {
+            PARAMETER *q = parameter_list_pop(p);
+            parameter_delete(&q);
+            return;
+        }
 
-  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;
+        p = &(*p)->next;
     }
-  }
 }
 
 /* returns 1 if Mutt can't display this type of data, 0 otherwise */
@@ -574,46 +488,11 @@ int mutt_is_text_part (BODY * b)
   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
+  * 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);
@@ -645,42 +524,28 @@ void mutt_merge_envelopes(ENVELOPE* base, ENVELOPE** extra)
   /* 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);
+  string_list_wipe(&base->userhdrs);
   MOVE_ELEM(spam);
   MOVE_ELEM(userhdrs);
 #undef MOVE_ELEM
   
-  mutt_free_envelope(extra);
+  envelope_delete(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),
+  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());
-  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);
-  }
-}
-
 /* 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);
@@ -727,7 +592,7 @@ void mutt_pretty_mailbox (char *s)
   }
 }
 
-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)
     m_strcpy(s, len, "0K");
@@ -746,7 +611,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];
@@ -755,12 +620,12 @@ 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 = m_strlen(src);
@@ -803,7 +668,7 @@ void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt,
 
 /* 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;
@@ -871,7 +736,7 @@ int mutt_check_overwrite (const char *attname, const char *path,
   return 0;
 }
 
-void mutt_save_path (char *d, size_t dsize, address_t * a)
+void mutt_save_path (char *d, ssize_t dsize, address_t * a)
 {
   if (a && a->mailbox) {
     m_strcpy(d, dsize, a->mailbox);
@@ -887,7 +752,7 @@ void mutt_save_path (char *d, size_t dsize, address_t * a)
     *d = 0;
 }
 
-void mutt_safe_path (char *s, size_t l, address_t * a)
+void mutt_safe_path (char *s, ssize_t l, address_t * a)
 {
   char *p;
 
@@ -919,7 +784,7 @@ int mutt_skipchars (const char *s, const char *c)
 }
 
 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 */
@@ -927,7 +792,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 */
@@ -954,7 +819,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++;
@@ -976,7 +841,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++;
@@ -988,7 +853,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++;
         }
@@ -1285,10 +1150,10 @@ const char *mutt_make_version (int full)
 
   if (full)
     snprintf (vstring, sizeof (vstring),
-              "Mutt-ng %s-r%s (based on Mutt 1.5.11)",
+              "Madmutt/%s-r%s (based on Mutt 1.5.11)",
               MUTT_VERSION, MUTT_REVISION);
   else
-    snprintf (vstring, sizeof (vstring), "mutt-ng/%s-r%s",
+    snprintf (vstring, sizeof (vstring), "Madmutt/%s-%s",
               MUTT_VERSION, MUTT_REVISION);
   return vstring;
 }
@@ -1302,7 +1167,7 @@ void mutt_free_spam_list (SPAM_LIST ** list)
   while (*list) {
     p = *list;
     *list = (*list)->next;
-    rx_free (&p->rx);
+    rx_delete(&p->rx);
     p_delete(&p->template);
     p_delete(&p);
   }
@@ -1328,11 +1193,8 @@ int mutt_match_spam_list (const char *s, SPAM_LIST * l, char *text, int x)
     }
 
     /* 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 == '%') {
@@ -1347,7 +1209,6 @@ 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;
     }
   }
@@ -1396,7 +1257,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)
+int mutt_cmp_list (const string_list_t * a, const string_list_t * b)
 {
   while (a && b) {
     if (m_strcmp(a->data, b->data))