X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=muttlib.c;h=0f6114e6e1757eb2d2ba177c869ea8318ca0b4c7;hp=2e15ea043e7ecb8332012bbcc045f559fc2cb9cc;hb=e7ca08ff86e3d01578d024a62385bafe7bceffd2;hpb=21595f98b7c8132f99abb9fee60ecdce31fc980f

diff --git a/muttlib.c b/muttlib.c
index 2e15ea0..0f6114e 100644
--- a/muttlib.c
+++ b/muttlib.c
@@ -17,24 +17,23 @@
 #include <lib-lib/str.h>
 #include <lib-lib/macros.h>
 #include <lib-lib/buffer.h>
+#include <lib-lib/file.h>
+
+#include <lib-mime/mime.h>
 
 #include "mutt.h"
 #include "enter.h"
 #include "mutt_curses.h"
-#include "mime.h"
 #include "mx.h"
 #include "url.h"
 #include "attach.h"
 
-#include "reldate.h"
 #include "version.h"
 
-#ifdef USE_IMAP
-#include "imap.h"
-#include "imap/mx_imap.h"
-#endif
+#include <imap/imap.h>
+#include <imap/mx_imap.h>
 
-#include "mutt_crypt.h"
+#include <lib-crypt/crypt.h>
 
 #include "lib/debug.h"
 
@@ -76,14 +75,14 @@ void mutt_adv_mktemp (const char* dir, char *s, size_t l)
   size_t sl;
   struct stat sb;
 
-  strfcpy (buf, dir && *dir ? dir : 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)
@@ -95,7 +94,7 @@ void mutt_adv_mktemp (const char* dir, char *s, size_t l)
     if (period != NULL) {
       *period = '.';
       sl = m_strlen(s);
-      strfcpy (s + sl, period, l - sl);
+      m_strcpy(s + sl, l - sl, period);
     }
   }
 }
@@ -113,7 +112,7 @@ int mutt_copy_body (FILE * fp, BODY ** tgt, BODY * src)
 
   if (src->filename) {
     use_disp = 1;
-    strfcpy (tmp, src->filename, sizeof (tmp));
+    m_strcpy(tmp, sizeof(tmp), src->filename);
   }
   else {
     use_disp = 0;
@@ -156,7 +155,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);
   }
@@ -177,7 +176,7 @@ void mutt_free_body (BODY ** p)
     a = a->next;
 
     if (b->parameter)
-      mutt_free_parameter (&b->parameter);
+      parameter_delete(&b->parameter);
     if (b->unlink && b->filename) {
       debug_print (1, ("unlinking %s.\n", b->filename));
       unlink (b->filename);
@@ -195,7 +194,7 @@ void mutt_free_body (BODY ** p)
     if (b->hdr) {
       /* Don't free twice (b->hdr->content = b->parts) */
       b->hdr->content = NULL;
-      mutt_free_header (&b->hdr);
+      header_delete(&b->hdr);
     }
 
     if (b->parts)
@@ -207,48 +206,15 @@ void mutt_free_body (BODY ** p)
   *p = 0;
 }
 
-void mutt_free_parameter (PARAMETER ** 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;
-}
-
 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
-#if defined USE_POP || defined USE_IMAP || defined USE_NNTP
-  p_delete(&(*h)->data);
-#endif
-  p_delete(h);
-}
-
 /* returns true if the header contained in "s" is in list "t" */
 int mutt_matches_ignore (const char *s, LIST * t)
 {
@@ -268,19 +234,19 @@ void mutt_expand_link (char *newpath, const char *path, const char *lnk)
 
   /* lnk is full path */
   if (*lnk == '/') {
-    strfcpy (newpath, lnk, _POSIX_PATH_MAX);
+    m_strcpy(newpath, _POSIX_PATH_MAX, lnk);
     return;
   }
 
   if ((lb = strrchr (path, '/')) == NULL) {
     /* no path in lnk */
-    strfcpy (newpath, lnk, _POSIX_PATH_MAX);
+    m_strcpy(newpath, _POSIX_PATH_MAX, lnk);
     return;
   }
 
   len = lb - path + 1;
   memcpy (newpath, path, len);
-  strfcpy (newpath + len, lnk, _POSIX_PATH_MAX - len);
+  m_strcpy(newpath + len, _POSIX_PATH_MAX - len, lnk);
 }
 
 char *mutt_expand_path (char *s, size_t slen)
@@ -306,7 +272,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 {
@@ -316,7 +282,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;
@@ -338,13 +304,11 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
     case '=':
     case '+':
       {
-#ifdef USE_IMAP
         /* if folder = imap[s]://host/: don't append slash */
         if (imap_is_magic (NONULL (Maildir), NULL) == M_IMAP && 
             Maildir[m_strlen(Maildir) - 1] == '/')
-          strfcpy (p, NONULL (Maildir), sizeof (p));
+          m_strcpy(p, sizeof(p), NONULL(Maildir));
         else
-#endif
           snprintf (p, sizeof (p), "%s/", NONULL (Maildir));
 
         tail = s + 1;
@@ -356,15 +320,15 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
     case '@':
       {
         HEADER *h;
-        ADDRESS *alias;
+        address_t *alias;
 
         if ((alias = mutt_lookup_alias (s + 1))) {
-          h = mutt_new_header ();
-          h->env = mutt_new_envelope ();
+          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;
@@ -376,14 +340,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;
@@ -391,11 +355,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;
         }
       }
@@ -403,14 +367,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;
@@ -429,7 +393,7 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
     else
       snprintf (tmp, sizeof (tmp), "%s%s", p, tail);
 
-    strfcpy (s, tmp, slen);
+    m_strcpy(s, slen, tmp);
   }
   while (recurse);
 
@@ -444,10 +408,10 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
  * name.
  */
 
-char *mutt_gecos_name (char *dest, size_t destlen, struct passwd *pw)
+char *mutt_gecos_name (char *dest, ssize_t destlen, struct passwd *pw)
 {
   regmatch_t pat_match[1];
-  size_t pwnl;
+  ssize_t pwnl;
   int idx;
   char *p;
 
@@ -458,13 +422,13 @@ char *mutt_gecos_name (char *dest, size_t destlen, struct passwd *pw)
 
   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));
+      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, ',')))
-    strfcpy (dest, pw->pw_gecos, MIN (destlen, p - pw->pw_gecos + 1));
+    m_strcpy(dest, MIN(destlen, p - pw->pw_gecos + 1), pw->pw_gecos);
   else
-    strfcpy (dest, pw->pw_gecos, destlen);
+    m_strcpy(dest, destlen, pw->pw_gecos);
 
   pwnl = m_strlen(pw->pw_name);
 
@@ -502,12 +466,12 @@ void mutt_set_parameter (const char *attribute, const char *value,
 
   for (q = *p; q; q = q->next) {
     if (ascii_strcasecmp (attribute, q->attribute) == 0) {
-      str_replace (&q->value, value);
+      m_strreplace(&q->value, value);
       return;
     }
   }
 
-  q = mutt_new_parameter ();
+  q = parameter_new();
   q->attribute = m_strdup(attribute);
   q->value = m_strdup(value);
   q->next = *p;
@@ -522,7 +486,7 @@ void mutt_delete_parameter (const char *attribute, PARAMETER ** p)
     if (ascii_strcasecmp (attribute, q->attribute) == 0) {
       *p = q->next;
       q->next = NULL;
-      mutt_free_parameter (&q);
+      parameter_delete(&q);
       return;
     }
   }
@@ -541,9 +505,9 @@ int mutt_needs_mailcap (BODY * m)
     break;
 
   case TYPEAPPLICATION:
-    if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp (m))
+    if (mutt_is_application_pgp (m))
       return 0;
-    if ((WithCrypto & APPLICATION_SMIME) && mutt_is_application_smime (m))
+    if (mutt_is_application_smime (m))
       return 0;
     break;
 
@@ -560,7 +524,7 @@ int mutt_is_text_part (BODY * b)
   int t = b->type;
   char *s = b->subtype;
 
-  if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp (b))
+  if (mutt_is_application_pgp (b))
     return 0;
 
   if (t == TYPETEXT)
@@ -571,7 +535,7 @@ int mutt_is_text_part (BODY * b)
       return 1;
   }
 
-  if ((WithCrypto & APPLICATION_PGP) && t == TYPEAPPLICATION) {
+  if (t == TYPEAPPLICATION) {
     if (!ascii_strcasecmp ("pgp-keys", s))
       return 1;
   }
@@ -579,46 +543,11 @@ int mutt_is_text_part (BODY * b)
   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);
-
-  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);
@@ -655,13 +584,13 @@ void mutt_merge_envelopes(ENVELOPE* base, ENVELOPE** extra)
   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));
@@ -676,7 +605,7 @@ void mutt_free_alias (ALIAS ** p)
     t = *p;
     *p = (*p)->next;
     p_delete(&t->name);
-    rfc822_free_address (&t->addr);
+    address_delete (&t->addr);
     p_delete(&t);
   }
 }
@@ -690,12 +619,10 @@ void mutt_pretty_mailbox (char *s)
 
   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) {
@@ -722,12 +649,12 @@ void mutt_pretty_mailbox (char *s)
   }
   *q = 0;
 
-  if (str_ncmp (s, Maildir, (len = m_strlen(Maildir))) == 0 &&
+  if (m_strncmp(s, Maildir, (len = m_strlen(Maildir))) == 0 &&
       s[len] == '/') {
     *s++ = '=';
     memmove (s, s + len, m_strlen(s + len) + 1);
   }
-  else if (str_ncmp (s, Homedir, (len = m_strlen(Homedir))) == 0 &&
+  else if (m_strncmp(s, Homedir, (len = m_strlen(Homedir))) == 0 &&
            s[len] == '/') {
     *s++ = '~';
     memmove (s, s + len - 1, m_strlen(s + len - 1) + 1);
@@ -737,7 +664,7 @@ void mutt_pretty_mailbox (char *s)
 void mutt_pretty_size (char *s, size_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 */
@@ -782,7 +709,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++;
@@ -802,8 +729,8 @@ void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt,
   *d = '\0';
 
   if (!found && destlen > 0) {
-    str_cat (dest, destlen, " ");
-    str_cat (dest, destlen, src);
+    m_strcat(dest, destlen, " ");
+    m_strcat(dest, destlen, src);
   }
 
 }
@@ -817,7 +744,7 @@ int mutt_check_overwrite (const char *attname, const char *path,
   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)
@@ -828,7 +755,7 @@ 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 */
         p_delete(directory);
@@ -852,10 +779,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) {
@@ -878,23 +805,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, size_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, size_t l, address_t * a)
 {
   char *p;
 
@@ -926,7 +853,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 */
@@ -934,7 +861,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 */
@@ -961,7 +888,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++;
@@ -983,7 +910,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++;
@@ -995,7 +922,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++;
         }
@@ -1069,7 +996,7 @@ void mutt_FormatString (char *dest,     /* output buffer */
                     data, flags);
 
         if (lower)
-          str_tolower (buf);
+          m_strtolower(buf);
         if (nodots) {
           char *p = buf;
 
@@ -1177,13 +1104,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) {
@@ -1195,7 +1120,7 @@ int mutt_save_confirm (const char *s, struct stat *st)
 
   if (magic > 0 && !mx_access (s, W_OK)) {
     if (option (OPTCONFIRMAPPEND) &&
-        (!TrashPath || (str_cmp (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)
@@ -1212,9 +1137,7 @@ int mutt_save_confirm (const char *s, struct stat *st)
     }
   }
   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;
@@ -1295,11 +1218,11 @@ 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/%s)", MUTT_VERSION, MUTT_REVISION,
-              ReleaseDate);
+    snprintf (vstring, sizeof (vstring),
+              "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;
 }
@@ -1391,11 +1314,11 @@ int mutt_cmp_header (const HEADER * h1, const HEADER * h2) {
 }
 
 /* return 1 if address lists are strictly identical */
-int mutt_cmp_addr (const ADDRESS * a, const ADDRESS * b)
+int mutt_cmp_addr (const address_t * a, const address_t * b)
 {
   while (a && b) {
-    if (str_cmp (a->mailbox, b->mailbox) ||
-        str_cmp (a->personal, b->personal))
+    if (m_strcmp(a->mailbox, b->mailbox) ||
+        m_strcmp(a->personal, b->personal))
       return (0);
 
     a = a->next;
@@ -1410,7 +1333,7 @@ int mutt_cmp_addr (const ADDRESS * a, const ADDRESS * b)
 int mutt_cmp_list (const LIST * a, const LIST * b)
 {
   while (a && b) {
-    if (str_cmp (a->data, b->data))
+    if (m_strcmp(a->data, b->data))
       return (0);
 
     a = a->next;
@@ -1425,8 +1348,8 @@ int mutt_cmp_list (const LIST * a, const LIST * b)
 int mutt_cmp_env (const ENVELOPE * e1, const ENVELOPE * e2)
 {
   if (e1 && e2) {
-    if (str_cmp (e1->message_id, e2->message_id) ||
-        str_cmp (e1->subject, e2->subject) ||
+    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) ||
@@ -1449,8 +1372,8 @@ int mutt_cmp_env (const ENVELOPE * e1, const ENVELOPE * e2)
 int mutt_cmp_param (const PARAMETER * p1, const PARAMETER * p2)
 {
   while (p1 && p2) {
-    if (str_cmp (p1->attribute, p2->attribute) ||
-        str_cmp (p1->value, p2->value))
+    if (m_strcmp(p1->attribute, p2->attribute) ||
+        m_strcmp(p1->value, p2->value))
       return (0);
 
     p1 = p1->next;
@@ -1466,8 +1389,8 @@ int mutt_cmp_body (const BODY * b1, const BODY * b2)
 {
   if (b1->type != b2->type ||
       b1->encoding != b2->encoding ||
-      str_cmp (b1->subtype, b2->subtype) ||
-      str_cmp (b1->description, b2->description) ||
+      m_strcmp(b1->subtype, b2->subtype) ||
+      m_strcmp(b1->description, b2->description) ||
       !mutt_cmp_param (b1->parameter, b2->parameter) ||
       b1->length != b2->length)
     return (0);