#include <h/mh.h>
#include <h/mhparse.h>
+#include <h/addrsbr.h>
#include <h/utils.h>
/*
#define qpspecial(c) (c < ' ' || c == '=' || c == '?' || c == '_')
#define base64len(n) ((((n) + 2) / 3 ) * 4) /* String len to base64 len */
-#define strbase64(n) ((n) * 3 / 4) /* Chars that fit in base64 */
+#define strbase64(n) ((n) / 4 * 3) /* Chars that fit in base64 */
#define ENCODELINELIMIT 76
static void unfold_header(char **, int);
static int field_encode_address(const char *, char **, int, const char *);
-static int field_encode_quoted(const char *, char **, const char *, int, int);
+static int field_encode_quoted(const char *, char **, const char *, int,
+ int, int);
static int field_encode_base64(const char *, char **, const char *);
+static int scanstring(const char *, int *, int *, int *);
static int utf8len(const char *);
/*
case CE_QUOTED:
return field_encode_quoted(name, value, charset, asciicount,
- eightbitcount + qpspecialcount);
+ eightbitcount + qpspecialcount, 0);
default:
advise(NULL, "Internal error: unknown RFC-2047 encoding type");
static int
field_encode_quoted(const char *name, char **value, const char *charset,
- int ascii, int encoded)
+ int ascii, int encoded, int phraserules)
{
int prefixlen = name ? strlen(name) + 2: 0, outlen = 0, column, newline = 1;
int charsetlen = strlen(charset), utf8;
/*
* Process each character, encoding if necessary
+ *
+ * Note that we have a different set of rules if we're processing
+ * RFC 5322 'phrase' (something you'd see in an address header).
*/
column++;
if (*p == ' ') {
*q++ = '_';
ascii--;
- } else if (isascii((int) *p) && !qpspecial((int) *p)) {
+ } else if (isascii((unsigned char) *p) &&
+ (phraserules ? qphrasevalid((unsigned char) *p) :
+ !qpspecial((unsigned char) *p))) {
*q++ = *p;
ascii--;
} else {
int outlen = 0, numencode, curlen;
char *output = NULL, *p = *value, *q = NULL, *linestart;
+ /*
+ * Skip over any leading white space.
+ */
+
+ while (*p == ' ' || *p == '\t')
+ p++;
+
/*
* If we had a zero-length prefix, then just encode the whole field
* as-is, without line wrapping. Note that in addition to the encoding
/*
* Our very first time, don't pad the line in the front
+ *
+ * Note ENCODELINELIMIT is + 2 because of \n \0
*/
if (! output) {
- outlen += ENCODELINELIMIT - prefixlen + 1;
+ outlen += ENCODELINELIMIT + 2;
output = q = mh_xmalloc(outlen);
linestart = q - prefixlen; /* Yes, this is intentional */
} else {
+ int curstart = linestart - output;
curlen = q - output;
- outlen += ENCODELINELIMIT + 1;
+ outlen += ENCODELINELIMIT + 2;
output = mh_xrealloc(output, outlen);
- linestart = q = output + curlen;
- q += snprintf(q, outlen - (q - output), "%*s", prefixlen, "");
+ q = output + curlen;
+ linestart = output + curstart;
}
/*
* We should have enough space now, so prepend the encoding markers
- * and character set information
+ * and character set information. The leading space is intentional.
*/
- q += snprintf(q, outlen - (q - output), "=?%s?B?", charset);
+ q += snprintf(q, outlen - (q - output), " =?%s?B?", charset);
/*
- * Find out how much room we have left on the line and see how many
- * characters we can stuff in. The start of our line is marked
- * by "linestart", so use that to figure out how many characters
- * are left out of ENCODELINELIMIT. Reserve 2 characters for the
- * end markers, and calculate how many characters we can fit into
- * that space given the base64 encoding expansion.
+ * Find out how much room we have left on the line and see how
+ * many characters we can stuff in. The start of our line
+ * is marked by "linestart", so use that to figure out how
+ * many characters are left out of ENCODELINELIMIT. Reserve
+ * 2 characters for the end markers and calculate how many
+ * characters we can fit into that space given the base64
+ * encoding expansion.
*/
numencode = strbase64(ENCODELINELIMIT - (q - linestart) - 2);
p += numencode;
q += base64len(numencode);
- *q++ = '?';
- *q++ = '=';
- *q++ = '\n';
- *q = '\0';
+
+ /*
+ * This will point us at the beginning of the new line (trust me).
+ */
+
+ linestart = q + 3;
+
+ /*
+ * What's going on here? Well, we know we're continuing to the next
+ * line, so we want to add continuation padding. We also add the
+ * trailing marker for the RFC 2047 token at this time as well.
+ * This uses a trick of snprintf(); we tell it to print a zero-length
+ * string, but pad it out to prefixlen - 1 characters; that ends
+ * up always printing out the requested number of spaces. We use
+ * prefixlen - 1 because we always add a space on the starting
+ * token marker; this makes things work out correctly for the first
+ * line, which should have a space between the ':' and the start
+ * of the token.
+ *
+ * It's okay if you don't follow all of that.
+ */
+
+ q += snprintf(q, outlen - (q - output), "?=\n%*s", prefixlen - 1, "");
}
/*
output = mh_xrealloc(output, outlen);
q = output + curlen;
- q += snprintf(q, outlen - (q - output), "=?%s?B?", charset);
+ q += snprintf(q, outlen - (q - output), "%s=?%s?B?",
+ prefixlen ? " " : "", charset);
if (writeBase64raw((unsigned char *) p, strlen(p),
(unsigned char *) q) != OK) {
*value = str;
}
+/*
+ * Decode a header containing addresses. This means we have to parse
+ * each address and only encode the display-name or comment field.
+ */
+
static int
field_encode_address(const char *name, char **value, int encoding,
const char *charset)
{
- return 0;
+ int prefixlen = strlen(name) + 2, column = prefixlen, groupflag, errflag;
+ int eightbitchars;
+ char *mp, *output = NULL;
+ struct mailname *mn;
+
+ /*
+ * Because these are addresses, we need to handle them individually.
+ *
+ * Break them down and process them one by one. This means we have to
+ * rewrite the whole header, but that's unavoidable.
+ */
+
+ /*
+ * The output headers always have to start with a space first.
+ */
+
+ output = add(" ", output);
+
+ for (groupflag = 0; mp = getname(*value); ) {
+ if ((mn = getm(mp, NULL, 0, AD_HOST, NULL)) == NULL) {
+ errflag++;
+ continue;
+ }
+
+ /*
+ * We only care if the phrase (m_pers) or any trailing comment
+ * (m_note) have 8-bit characters. If doing q-p, we also need
+ * to encode anything marked as qspecial().
+ */
+ }
+}
+
+/*
+ * Scan a string, check for characters that need to be encoded
+ */
+
+static int
+scanstring(const char *string, int *asciilen, int *eightbitchars,
+ int *specialchars)
+{
+ *asciilen = 0;
+ *eightbitchars = 0;
+ *specialchars = 0;
+
+ for (; *string != '\0'; string++) {
+ if ((isascii((unsigned char) *string))) {
+ (*asciilen++);
+ if (!qphrasevalid((unsigned char) *string))
+ (*specialchars)++;
+ } else {
+ (*eightbitchars)++;
+ }
+ }
+
+ return eightbitchars > 0;
}
projects / nmh / blobdiff