rationalize list handling in mutt a bit.

[apps/madmutt.git] / lib-mime / rfc2047.c

diff --git a/lib-mime/rfc2047.c b/lib-mime/rfc2047.c
index c28b2b9..264caff 100644 (file)
--- a/lib-mime/rfc2047.c
+++ b/lib-mime/rfc2047.c
@@ -33,7 +33,6 @@
 
 #include <lib-mime/mime.h>
 
 
 #include <lib-mime/mime.h>
 

-#include "mutt.h"

 #include "charset.h"
 #include "thread.h"
 
 #include "charset.h"
 #include "thread.h"
 


@@ -305,7 +304,7 @@ static size_t try_block(const char *d, ssize_t dlen,
         len_q = len + (ob - buf1) + 2 * count;
 
         /* Apparently RFC 1468 says to use B encoding for iso-2022-jp. */
         len_q = len + (ob - buf1) + 2 * count;
 
         /* Apparently RFC 1468 says to use B encoding for iso-2022-jp. */

-        if (!ascii_strcasecmp(tocode, "ISO-2022-JP"))
+        if (mime_which_token(tocode, -1) == MIME_ISO_2022_JP)

             len_q = ENCWORD_LEN_MAX + 1;
 
         if (len_b < len_q && len_b <= ENCWORD_LEN_MAX) {
             len_q = ENCWORD_LEN_MAX + 1;
 
         if (len_b < len_q && len_b <= ENCWORD_LEN_MAX) {


@@ -362,7 +361,7 @@ static size_t choose_block(char *d, size_t dlen, int col,
                            encoder_t **encoder, ssize_t *wlen)
 {
     size_t n, nn;
                            encoder_t **encoder, ssize_t *wlen)
 {
     size_t n, nn;

-    int utf8 = fromcode && !ascii_strcasecmp(fromcode, "UTF-8");
+    int utf8 = mime_which_token(fromcode, -1) == MIME_UTF_8;

 
     n = dlen;
     for (;;) {
 
     n = dlen;
     for (;;) {


@@ -776,14 +775,14 @@ static ssize_t lwsrlen(const char *s, ssize_t n)
 /* try to decode anything that looks like a valid RFC2047 encoded
  * header field, ignoring RFC822 parsing rules
  */
 /* try to decode anything that looks like a valid RFC2047 encoded
  * header field, ignoring RFC822 parsing rules
  */

-void rfc2047_decode (char **pd)
+void rfc2047_decode(char **pd)

 {
 {

-    const char *p, *q;
-    size_t m, n;
-    int found_encoded = 0;
-    char *d0, *d;
+    const int strict_mime = option(OPTSTRICTMIME);
+

     const char *s = *pd;
     const char *s = *pd;

-    size_t dlen;
+    char *d0, *d;
+    ssize_t dlen;
+    int found_encoded = 0;

 
     if (!s || !*s)
         return;
 
     if (!s || !*s)
         return;


@@ -792,63 +791,62 @@ void rfc2047_decode (char **pd)
     d = d0 = p_new(char, dlen + 1);
 
     while (*s && dlen > 0) {
     d = d0 = p_new(char, dlen + 1);
 
     while (*s && dlen > 0) {

-        if (!(p = find_encoded_word (s, &q))) {
+        const char *p, *q;
+
+        p = find_encoded_word(s, &q);
+
+        if (!p) {

             /* no encoded words */
             /* no encoded words */

-            if (!option (OPTSTRICTMIME)) {
+            if (!strict_mime) {
+                ssize_t m, n;
+

                 n = m_strlen(s);
                 n = m_strlen(s);

-                if (found_encoded && (m = lwslen (s, n)) != 0) {
+                if (found_encoded && (m = lwslen(s, n)) != 0) {

                     if (m != n)
                     if (m != n)

-                        *d = ' ', d++, dlen--;
+                        *d++ = ' ', dlen--;

                     n -= m, s += m;
                 }
                     n -= m, s += m;
                 }

-                if (ascii_strcasecmp (AssumedCharset, "us-ascii")) {
+
+                if (mime_which_token(AssumedCharset, -1) == MIME_US_ASCII) {

                     char *t;
                     char *t;

-                    ssize_t tlen;

 
                     t = p_dupstr(s, n);
 
                     t = p_dupstr(s, n);

-                    if (mutt_convert_nonmime_string (&t) == 0) {
-                        tlen = m_strlen(t);
-                        strncpy (d, t, tlen);
-                        d += tlen;
-                    }
-                    else {
-                        strncpy (d, s, n);
-                        d += n;
+                    if (mutt_convert_nonmime_string(&t) == 0) {
+                        d += m_strcpy(d, dlen, t);
+                    } else {
+                        d += m_strcpy(d, dlen, s);

                     }
                     p_delete(&t);
                     break;
                 }
             }
                     }
                     p_delete(&t);
                     break;
                 }
             }

-            strncpy (d, s, dlen);
-            d += dlen;
+            d += m_strcpy(d, dlen, s);

             break;
         }
 
         if (p != s) {
             break;
         }
 
         if (p != s) {

+            ssize_t m, n;
+

             n = (p - s);
             /* ignore spaces between encoded words
              * and linear white spaces between encoded word and *text */
             n = (p - s);
             /* ignore spaces between encoded words
              * and linear white spaces between encoded word and *text */

-            if (!option (OPTSTRICTMIME)) {
-                if (found_encoded && (m = lwslen (s, n)) != 0) {
+            if (!strict_mime) {
+                if (found_encoded && (m = lwslen(s, n)) != 0) {

                     if (m != n)
                     if (m != n)

-                        *d = ' ', d++, dlen--;
+                        *d++ = ' ', dlen--;

                     n -= m, s += m;
                 }
 
                     n -= m, s += m;
                 }
 

-                if ((m = n - lwsrlen (s, n)) != 0) {
-                    if (m > dlen)
-                        m = dlen;
-                    memcpy (d, s, m);
+                if ((m = n - lwsrlen(s, n)) != 0) {
+                    m  = m_strncpy(d, dlen, s, m);

                     d += m;
                     dlen -= m;
                     if (m != n)
                     d += m;
                     dlen -= m;
                     if (m != n)

-                        *d = ' ', d++, dlen--;
+                        *d++ = ' ', dlen--;

                 }
                 }

-            }
-            else if (!found_encoded || strspn (s, " \t\r\n") != n) {
-                if (n > dlen)
-                    n = dlen;
-                memcpy (d, s, n);
+            } else
+            if (!found_encoded || (ssize_t)strspn(s, " \t\r\n") != n) {
+                n  = m_strncpy(d, dlen, s, n);

                 d += n;
                 dlen -= n;
             }
                 d += n;
                 dlen -= n;
             }


@@ -857,15 +855,12 @@ void rfc2047_decode (char **pd)
         rfc2047_decode_word(d, dlen, p);
         found_encoded = 1;
         s = q;
         rfc2047_decode_word(d, dlen, p);
         found_encoded = 1;
         s = q;

-        n = m_strlen(d);
-        dlen -= n;
-        d += n;
+        while (*d && dlen)
+            d++, dlen--;

     }
     }

-    *d = 0;

 
     p_delete(pd);
     *pd = d0;
 
     p_delete(pd);
     *pd = d0;

-    str_adjust (pd);

 }
 
 void rfc2047_decode_adrlist(address_t *a)
 }
 
 void rfc2047_decode_adrlist(address_t *a)