diplodocus.org Git - nmh/blob - sbr/encode_rfc2047.c

   1 /*
   2  * Routines to encode message headers using RFC 2047-encoding.
   3  *
   4  * This code is Copyright (c) 2002, by the authors of nmh.  See the
   5  * COPYRIGHT file in the root directory of the nmh distribution for
   6  * complete copyright information.
   7  */
   8
   9 #include <h/mh.h>
  10 #include <h/mhparse.h>
  11 #include <h/addrsbr.h>
  12 #include <h/utils.h>
  13
  14 /*
  15  * List of headers that contain addresses and as a result require special
  16  * handling
  17  */
  18
  19 static char *address_headers[] = {
  20     "To",
  21     "From",
  22     "cc",
  23     "Bcc",
  24     "Reply-To",
  25     "Sender",
  26     "Resent-To",
  27     "Resent-From",
  28     "Resent-cc",
  29     "Resent-Bcc",
  30     "Resent-Reply-To",
  31     "Resent-Sender",
  32     NULL,
  33 };
  34
  35 /*
  36  * Macros we use for parsing headers
  37  */
  38
  39 #define is_fws(c) (c == '\t' || c == ' ' || c == '\n')
  40
  41 #define qphrasevalid(c) ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || \
  42                          (c >= 'a' && c <= 'z') || \
  43                          c == '!' || c == '*' || c == '+' || c == '-' || \
  44                          c == '/' || c == '=' || c == '_')
  45 #define qpspecial(c) (c < ' ' || c == '=' || c == '?' || c == '_')
  46
  47 #define base64len(n) ((((n) + 2) / 3 ) * 4)     /* String len to base64 len */
  48 #define strbase64(n) ((n) / 4 * 3)              /* Chars that fit in base64 */
  49
  50 #define ENCODELINELIMIT 76
  51
  52 static void unfold_header(char **, int);
  53 static int field_encode_address(const char *, char **, int, const char *);
  54 static int field_encode_quoted(const char *, char **, const char *, int,
  55                                int, int);
  56 static int field_encode_base64(const char *, char **, const char *);
  57 static int scanstring(const char *, int *, int *, int *);
  58 static int utf8len(const char *);
  59 static int pref_encoding(int, int, int);
  60
  61 /*
  62  * Encode a message header using RFC 2047 encoding.  We make the assumption
  63  * that all characters < 128 are ASCII and as a consequence don't need any
  64  * encoding.
  65  */
  66
  67 int
  68 encode_rfc2047(const char *name, char **value, int encoding,
  69                const char *charset)
  70 {
  71     int i, asciicount = 0, eightbitcount = 0, qpspecialcount = 0;
  72     char *p;
  73
  74     /*
  75      * First, check to see if we even need to encode the header
  76      */
  77
  78     for (p = *value; *p != '\0'; p++) {
  79         if (isascii((unsigned char) *p)) {
  80             asciicount++;
  81             if (qpspecial((unsigned char) *p))
  82                 qpspecialcount++;
  83         } else
  84             eightbitcount++;
  85     }
  86
  87     if (eightbitcount == 0)
  88         return 0;
  89
  90     /*
  91      * Some rules from RFC 2047:
  92      *
  93      * - Encoded words cannot be more than 75 characters long
  94      * - Multiple "long" encoded words must be on new lines.
  95      *
  96      * Also, we're not permitted to encode email addresses, so
  97      * we need to actually _parse_ email addresses and only encode
  98      * the right bits.
  99      */
 100
 101     /*
 102      * If charset was NULL, then get the value from the locale.  But
 103      * we reject it if it returns US-ASCII
 104      */
 105
 106     if (charset == NULL)
 107         charset = write_charset_8bit();
 108
 109     if (strcasecmp(charset, "US-ASCII") == 0) {
 110         advise(NULL, "Cannot use US-ASCII with 8 bit characters in header");
 111         return 1;
 112     }
 113
 114     /*
 115      * If we have an address header, then we need to parse the addresses
 116      * and only encode the names or comments.  Otherwise, handle it normally.
 117      */
 118
 119     for (i = 0; address_headers[i]; i++) {
 120         if (strcasecmp(name, address_headers[i]) == 0)
 121             return field_encode_address(name, value, encoding, charset);
 122     }
 123
 124     /*
 125      * On the encoding we choose, and the specifics of encoding:
 126      *
 127      * - If a specified encoding is passed in, we use that.
 128      * - Otherwise, pick which encoding is shorter.
 129      *
 130      * We don't quite handle continuation right here, but it should be
 131      * pretty close.
 132      */
 133
 134     if (encoding == CE_UNKNOWN)
 135         encoding = pref_encoding(asciicount, qpspecialcount, eightbitcount);
 136
 137     unfold_header(value, asciicount + eightbitcount);
 138
 139     switch (encoding) {
 140
 141     case CE_BASE64:
 142         return field_encode_base64(name, value, charset);
 143
 144     case CE_QUOTED:
 145         return field_encode_quoted(name, value, charset, asciicount,
 146                                    eightbitcount + qpspecialcount, 0);
 147
 148     default:
 149         advise(NULL, "Internal error: unknown RFC-2047 encoding type");
 150         return 1;
 151     }
 152 }
 153
 154 /*
 155  * Encode our specified header (or field) using quoted-printable
 156  */
 157
 158 static int
 159 field_encode_quoted(const char *name, char **value, const char *charset,
 160                     int ascii, int encoded, int phraserules)
 161 {
 162     int prefixlen = name ? strlen(name) + 2: 0, outlen = 0, column, newline = 1;
 163     int charsetlen = strlen(charset), utf8;
 164     char *output = NULL, *p, *q = NULL;
 165
 166     /*
 167      * Right now we just encode the whole thing.  Maybe later on we'll
 168      * only encode things on a per-atom basis.
 169      */
 170
 171     p = *value;
 172
 173     column = prefixlen + 2;     /* Header name plus ": " */
 174
 175     utf8 = strcasecmp(charset, "UTF-8") == 0;
 176
 177     while (*p != '\0') {
 178         /*
 179          * Start a new line, if it's time
 180          */
 181         if (newline) {
 182             /*
 183              * If it's the start of the header, we don't need to pad it
 184              *
 185              * The length of the output string is ...
 186              * =?charset?Q?...?=  so that's 7+strlen(charset) + 2 for \n NUL
 187              *
 188              * plus 1 for every ASCII character and 3 for every eight bit
 189              * or special character (eight bit characters are written as =XX).
 190              *
 191              */
 192
 193             int tokenlen;
 194
 195             outlen += 9 + charsetlen + ascii + 3 * encoded;
 196
 197             /*
 198              * If output is set, then we're continuing the header.  Otherwise
 199              * do the initial allocation.
 200              */
 201
 202             if (output) {
 203                 int curlen = q - output, i;
 204                 outlen += prefixlen + 1;        /* Header plus \n ": " */
 205                 output = mh_xrealloc(output, outlen);
 206                 q = output + curlen;
 207                 *q++ = '?';
 208                 *q++ = '=';
 209                 *q++ = '\n';
 210                 for (i = 0; i < prefixlen; i++)
 211                     *q++ = ' ';
 212             } else {
 213                 /*
 214                  * A bit of a hack here; the header can contain multiple
 215                  * spaces (probably at least one) until we get to the
 216                  * actual text.  Copy until we get to a non-space.
 217                  */
 218                 output = mh_xmalloc(outlen);
 219                 q = output;
 220                 while (is_fws(*p))
 221                     *q++ = *p++;
 222             }
 223
 224             tokenlen = snprintf(q, outlen - (q - output), "=?%s?Q?", charset);
 225             q += tokenlen;
 226             column = prefixlen + tokenlen;
 227             newline = 0;
 228         }
 229
 230         /*
 231          * Process each character, encoding if necessary
 232          *
 233          * Note that we have a different set of rules if we're processing
 234          * RFC 5322 'phrase' (something you'd see in an address header).
 235          */
 236
 237         column++;
 238
 239         if (*p == ' ') {
 240             *q++ = '_';
 241             ascii--;
 242         } else if (isascii((unsigned char) *p) &&
 243                    (phraserules ? qphrasevalid((unsigned char) *p) :
 244                                         !qpspecial((unsigned char) *p))) {
 245             *q++ = *p;
 246             ascii--;
 247         } else {
 248             snprintf(q, outlen - (q - output), "=%02X", (unsigned char) *p);
 249             q += 3;
 250             column += 2;        /* column already incremented by 1 above */
 251             encoded--;
 252         }
 253
 254         p++;
 255
 256         /*
 257          * We're not allowed more than ENCODELINELIMIT characters per line,
 258          * so reserve some room for the final ?=.
 259          *
 260          * If prefixlen == 0, we haven't been passed in a header name, so
 261          * don't ever wrap the field (we're likely doing an address).
 262          */
 263
 264         if (prefixlen == 0)
 265             continue;
 266
 267         if (column >= ENCODELINELIMIT - 2) {
 268             newline = 1;
 269         } else if (utf8) {
 270             /*
 271              * Okay, this is a bit weird, but to explain a bit more ...
 272              *
 273              * RFC 2047 prohibits the splitting of multibyte characters
 274              * across encoded words.  Right now we only handle the case
 275              * of UTF-8, the most common multibyte encoding.
 276              *
 277              * p is now pointing at the next input character.  If we're
 278              * using UTF-8 _and_ we'd go over ENCODELINELIMIT given the
 279              * length of the complete character, then trigger a newline
 280              * now.  Note that we check the length * 3 since we have to
 281              * allow for the encoded output.
 282              */
 283             if (column + (utf8len(p) * 3) > ENCODELINELIMIT - 2) {
 284                 newline = 1;
 285             }
 286         }
 287     }
 288
 289     *q++ = '?';
 290     *q++ = '=';
 291
 292     if (prefixlen)
 293         *q++ = '\n';
 294
 295     *q = '\0';
 296
 297     free(*value);
 298
 299     *value = output;
 300
 301     return 0;
 302 }
 303
 304 /*
 305  * Encode our specified header (or field) using base64.
 306  *
 307  * This is a little easier since every character gets encoded, we can
 308  * calculate the line wrap up front.
 309  */
 310
 311 static int
 312 field_encode_base64(const char *name, char **value, const char *charset)
 313 {
 314     int prefixlen = name ? strlen(name) + 2 : 0, charsetlen = strlen(charset);
 315     int outlen = 0, numencode, curlen;
 316     char *output = NULL, *p = *value, *q = NULL, *linestart = NULL;
 317
 318     /*
 319      * Skip over any leading white space.
 320      */
 321
 322     while (*p == ' ' || *p == '\t')
 323         p++;
 324
 325     /*
 326      * If we had a zero-length prefix, then just encode the whole field
 327      * as-is, without line wrapping.  Note that in addition to the encoding
 328      *
 329      * The added length we need is =? + charset + ?B? ... ?=
 330      *
 331      * That's 7 + strlen(charset) + 2 (for \n NUL).
 332      */
 333
 334     while (prefixlen && ((base64len(strlen(p)) + 7 + charsetlen +
 335                           prefixlen) > ENCODELINELIMIT)) {
 336
 337         /*
 338          * Our very first time, don't pad the line in the front
 339          *
 340          * Note ENCODELINELIMIT is + 2 because of \n \0
 341          */
 342
 343
 344         if (! output) {
 345             outlen += ENCODELINELIMIT + 2;
 346             output = q = mh_xmalloc(outlen);
 347             linestart = q - prefixlen;  /* Yes, this is intentional */
 348         } else {
 349             int curstart = linestart - output;
 350             curlen = q - output;
 351
 352             outlen += ENCODELINELIMIT + 2;
 353             output = mh_xrealloc(output, outlen);
 354             q = output + curlen;
 355             linestart = output + curstart;
 356         }
 357
 358         /*
 359          * We should have enough space now, so prepend the encoding markers
 360          * and character set information.  The leading space is intentional.
 361          */
 362
 363         q += snprintf(q, outlen - (q - output), " =?%s?B?", charset);
 364
 365         /*
 366          * Find out how much room we have left on the line and see how
 367          * many characters we can stuff in.  The start of our line
 368          * is marked by "linestart", so use that to figure out how
 369          * many characters are left out of ENCODELINELIMIT.  Reserve
 370          * 2 characters for the end markers and calculate how many
 371          * characters we can fit into that space given the base64
 372          * encoding expansion.
 373          */
 374
 375         numencode = strbase64(ENCODELINELIMIT - (q - linestart) - 2);
 376
 377         if (numencode <= 0) {
 378             advise(NULL, "Internal error: tried to encode %d characters "
 379                    "in base64", numencode);
 380             return 1;
 381         }
 382
 383         /*
 384          * RFC 2047 prohibits spanning multibyte characters across tokens.
 385          * Right now we only check for UTF-8.
 386          *
 387          * So note the key here ... we want to make sure the character BEYOND
 388          * our last character is not a continuation byte.  If it's the start
 389          * of a new multibyte character or a single-byte character, that's ok.
 390          */
 391
 392         if (strcasecmp(charset, "UTF-8") == 0) {
 393             /*
 394              * p points to the start of our current buffer, so p + numencode
 395              * is one past the last character to encode
 396              */
 397
 398             while (numencode > 0 && ((*(p + numencode) & 0xc0) == 0x80))
 399                 numencode--;
 400
 401             if (numencode == 0) {
 402                 advise(NULL, "Internal error: could not find start of "
 403                        "UTF-8 character when base64 encoding header");
 404                 return 1;
 405             }
 406         }
 407
 408         if (writeBase64raw((unsigned char *) p, numencode,
 409                            (unsigned char *) q) != OK) {
 410             advise(NULL, "Internal error: base64 encoding of header failed");
 411             return 1;
 412         }
 413
 414         p += numencode;
 415         q += base64len(numencode);
 416
 417         /*
 418          * This will point us at the beginning of the new line (trust me).
 419          */
 420
 421         linestart = q + 3;
 422
 423         /*
 424          * What's going on here?  Well, we know we're continuing to the next
 425          * line, so we want to add continuation padding.  We also add the
 426          * trailing marker for the RFC 2047 token at this time as well.
 427          * This uses a trick of snprintf(); we tell it to print a zero-length
 428          * string, but pad it out to prefixlen - 1 characters; that ends
 429          * up always printing out the requested number of spaces.  We use
 430          * prefixlen - 1 because we always add a space on the starting
 431          * token marker; this makes things work out correctly for the first
 432          * line, which should have a space between the ':' and the start
 433          * of the token.
 434          *
 435          * It's okay if you don't follow all of that.
 436          */
 437
 438         q += snprintf(q, outlen - (q - output), "?=\n%*s", prefixlen - 1, "");
 439     }
 440
 441     /*
 442      * We're here if there is either no prefix, or we can fit it in less
 443      * than ENCODELINELIMIT characters.  Encode the whole thing.
 444      */
 445
 446     outlen += prefixlen + 9 + charsetlen + base64len(strlen(p));
 447     curlen = q - output;
 448
 449     output = mh_xrealloc(output, outlen);
 450     q = output + curlen;
 451
 452     q += snprintf(q, outlen - (q - output), "%s=?%s?B?",
 453                   prefixlen ? " " : "", charset);
 454
 455     if (writeBase64raw((unsigned char *) p, strlen(p),
 456                        (unsigned char *) q) != OK) {
 457         advise(NULL, "Internal error: base64 encoding of header failed");
 458         return 1;
 459     }
 460
 461     strcat(q, "?=");
 462
 463     if (prefixlen)
 464         strcat(q, "\n");
 465
 466     free(*value);
 467
 468     *value = output;
 469
 470     return 0;
 471 }
 472
 473 /*
 474  * Calculate the length of a UTF-8 character.
 475  *
 476  * If it's not a UTF-8 character (or we're in the middle of a multibyte
 477  * character) then simply return 0.
 478  */
 479
 480 static int
 481 utf8len(const char *p)
 482 {
 483     int len = 1;
 484
 485     if (*p == '\0')
 486         return 0;
 487
 488     if (isascii((unsigned char) *p) || (((unsigned char) *p) & 0xc0) == 0x80)
 489         return 0;
 490
 491     p++;
 492     while ((((unsigned char) *p++) & 0xc0) == 0x80)
 493         len++;
 494
 495     return len;
 496 }
 497
 498 /*
 499  * "Unfold" a header, making it a single line (without continuation)
 500  *
 501  * We cheat a bit here; we never make the string longer, so using the
 502  * original length here is fine.
 503  */
 504
 505 static void
 506 unfold_header(char **value, int len)
 507 {
 508     char *str = mh_xmalloc(len + 1);
 509     char *p = str, *q = *value;
 510
 511     while (*q != '\0') {
 512         if (*q == '\n') {
 513             /*
 514              * When we get a newline, skip to the next non-whitespace
 515              * character and add a space to replace all of the whitespace
 516              *
 517              * This has the side effect of stripping off the final newline
 518              * for the header; we put it back in the encoding routine.
 519              */
 520             while (is_fws(*q))
 521                 q++;
 522             if (*q == '\0')
 523                 break;
 524
 525             *p++ = ' ';
 526         } else {
 527             *p++ = *q++;
 528         }
 529     }
 530
 531     *p = '\0';
 532
 533     free(*value);
 534     *value = str;
 535 }
 536
 537 /*
 538  * Decode a header containing addresses.  This means we have to parse
 539  * each address and only encode the display-name or comment field.
 540  */
 541
 542 static int
 543 field_encode_address(const char *name, char **value, int encoding,
 544                      const char *charset)
 545 {
 546     int prefixlen = strlen(name) + 2, column = prefixlen, groupflag;
 547     int asciichars, specialchars, eightbitchars, reformat = 0, errflag = 0;
 548     size_t len;
 549     char *mp, *cp = NULL, *output = NULL;
 550     char *tmpbuf = NULL;
 551     size_t tmpbufsize = 0;
 552     struct mailname *mn;
 553     char errbuf[BUFSIZ];
 554
 555     /*
 556      * Because these are addresses, we need to handle them individually.
 557      *
 558      * Break them down and process them one by one.  This means we have to
 559      * rewrite the whole header, but that's unavoidable.
 560      */
 561
 562     /*
 563      * The output headers always have to start with a space first; this
 564      * is just the way the API works right now.
 565      */
 566
 567     output = add(" ", output);
 568
 569     for (groupflag = 0; (mp = getname(*value)); ) {
 570         if ((mn = getm(mp, NULL, 0, errbuf, sizeof(errbuf))) == NULL) {
 571             advise(NULL, "%s: %s", errbuf, mp);
 572             errflag++;
 573             continue;
 574         }
 575
 576         reformat = 0;
 577
 578         /*
 579          * We only care if the phrase (m_pers) or any trailing comment
 580          * (m_note) have 8-bit characters.  If doing q-p, we also need
 581          * to encode anything marked as qspecial().  Unquote it first
 582          * so the specialchars count is right.
 583          */
 584
 585         if (! mn->m_pers)
 586             goto check_note;
 587
 588         if ((len = strlen(mn->m_pers)) + 1 > tmpbufsize) {
 589             tmpbuf = mh_xrealloc(tmpbuf, tmpbufsize = len + 1);
 590         }
 591
 592         unquote_string(mn->m_pers, tmpbuf);
 593
 594         if (scanstring(tmpbuf, &asciichars, &eightbitchars,
 595                        &specialchars)) {
 596             /*
 597              * If we have 8-bit characters, encode it.
 598              */
 599
 600             if (encoding == CE_UNKNOWN)
 601                 encoding = pref_encoding(asciichars, specialchars,
 602                                          eightbitchars);
 603
 604             /*
 605              * This is okay, because the output of unquote_string will be either
 606              * equal or shorter than the original.
 607              */
 608
 609             strcpy(mn->m_pers, tmpbuf);
 610
 611             switch (encoding) {
 612
 613             case CE_BASE64:
 614                 if (field_encode_base64(NULL, &mn->m_pers, charset)) {
 615                     errflag++;
 616                     goto out;
 617                 }
 618                 break;
 619
 620             case CE_QUOTED:
 621                 if (field_encode_quoted(NULL, &mn->m_pers, charset, asciichars,
 622                                         eightbitchars + specialchars, 1)) {
 623                     errflag++;
 624                     goto out;
 625                 }
 626                 break;
 627
 628             default:
 629                 advise(NULL, "Internal error: unknown RFC-2047 encoding type");
 630                 errflag++;
 631                 goto out;
 632             }
 633
 634             reformat++;
 635         }
 636
 637         check_note:
 638
 639         /*
 640          * The "note" field is generally a comment at the end of the address,
 641          * at least as how it's implemented here.  Notes are always surrounded
 642          * by parenthesis (since they're comments).  Strip them out and
 643          * then put them back when we format the final field, but they do
 644          * not get encoded.
 645          */
 646
 647         if (! mn->m_note)
 648             goto do_reformat;
 649
 650         if ((len = strlen(mn->m_note)) + 1 > tmpbufsize) {
 651             tmpbuf = mh_xrealloc(tmpbuf, tmpbufsize = len + 1);
 652         }
 653
 654         if (mn->m_note[0] != '(' || mn->m_note[len - 1] != ')') {
 655             advise(NULL, "Internal error: Invalid note field \"%s\"",
 656                    mn->m_note);
 657             errflag++;
 658             goto out;
 659         }
 660
 661         strncpy(tmpbuf, mn->m_note + 1, len - 1);
 662         tmpbuf[len - 2] = '\0';
 663
 664         if (scanstring(tmpbuf, &asciichars, &eightbitchars,
 665                        &specialchars)) {
 666             /*
 667              * If we have 8-bit characters, encode it.
 668              */
 669
 670             if (encoding == CE_UNKNOWN)
 671                 encoding = pref_encoding(asciichars, specialchars,
 672                                          eightbitchars);
 673
 674             switch (encoding) {
 675
 676             case CE_BASE64:
 677                 if (field_encode_base64(NULL, &tmpbuf, charset)) {
 678                     errflag++;
 679                     goto out;
 680                 }
 681                 break;
 682
 683             case CE_QUOTED:
 684                 if (field_encode_quoted(NULL, &tmpbuf, charset, asciichars,
 685                                         eightbitchars + specialchars, 1)) {
 686                     errflag++;
 687                     goto out;
 688                 }
 689                 break;
 690
 691             default:
 692                 advise(NULL, "Internal error: unknown RFC-2047 encoding type");
 693                 errflag++;
 694                 goto out;
 695             }
 696
 697             reformat++;
 698
 699             /*
 700              * Make sure the size of tmpbuf is correct (it always gets
 701              * reallocated in the above functions).
 702              */
 703
 704             tmpbufsize = strlen(tmpbuf) + 1;
 705
 706             /*
 707              * Put the note field back surrounded by parenthesis.
 708              */
 709
 710             mn->m_note = mh_xrealloc(mn->m_note, tmpbufsize + 2);
 711
 712             snprintf(mn->m_note, tmpbufsize + 2, "(%s)", tmpbuf);
 713         }
 714
 715 do_reformat:
 716
 717         /*
 718          * So, some explanation is in order.
 719          *
 720          * We know we need to rewrite at least one address in the header,
 721          * otherwise we wouldn't be here.  If we had to reformat this
 722          * particular address, then run it through adrformat().  Otherwise
 723          * we can use m_text directly.
 724          */
 725
 726         /*
 727          * If we were in a group but are no longer, make sure we add a
 728          * semicolon (which needs to be FIRST, as it needs to be at the end
 729          * of the last address).
 730          */
 731
 732         if (groupflag && ! mn->m_ingrp) {
 733             output = add(";", output);
 734             column += 1;
 735         }
 736
 737         groupflag = mn->m_ingrp;
 738
 739         if (mn->m_gname) {
 740             cp = add(mn->m_gname, NULL);
 741         }
 742
 743         if (reformat) {
 744             cp = add(adrformat(mn), cp);
 745         } else {
 746             cp = add(mn->m_text, cp);
 747         }
 748
 749         len = strlen(cp);
 750
 751         /*
 752          * If we're not at the beginning of the line, add a command and
 753          * either a space or a newline.
 754          */
 755
 756         if (column != prefixlen) {
 757             if (len + column + 2 > OUTPUTLINELEN) {
 758
 759                 if ((size_t) (prefixlen + 3) < tmpbufsize)
 760                     tmpbuf = mh_xrealloc(tmpbuf, tmpbufsize = prefixlen + 3);
 761
 762                 snprintf(tmpbuf, tmpbufsize, ",\n%*s", column = prefixlen, "");
 763                 output = add(tmpbuf, output);
 764             } else {
 765                 output = add(", ", output);
 766                 column += 2;
 767             }
 768         }
 769
 770         /*
 771          * Finally add the address
 772          */
 773
 774         output = add(cp, output);
 775         column += len;
 776         free(cp);
 777         cp = NULL;
 778     }
 779
 780     /*
 781      * Just in case we're at the end of a list
 782      */
 783
 784     if (groupflag) {
 785         output = add(";", output);
 786     }
 787
 788     output = add("\n", output);
 789
 790     free(*value);
 791     *value = output;
 792     output = NULL;
 793
 794 out:
 795
 796     if (tmpbuf)
 797         free(tmpbuf);
 798     if (output)
 799         free(output);
 800
 801     return errflag > 0;
 802 }
 803
 804 /*
 805  * Scan a string, check for characters that need to be encoded
 806  */
 807
 808 static int
 809 scanstring(const char *string, int *asciilen, int *eightbitchars,
 810            int *specialchars)
 811 {
 812     *asciilen = 0;
 813     *eightbitchars = 0;
 814     *specialchars = 0;
 815
 816     for (; *string != '\0'; string++) {
 817         if ((isascii((unsigned char) *string))) {
 818             (*asciilen)++;
 819             /*
 820              * So, a space is not a valid phrase character, but we're counting
 821              * an exception here, because in q-p a space can be directly
 822              * encoded as an underscore.
 823              */
 824             if (!qphrasevalid((unsigned char) *string) && *string != ' ')
 825                 (*specialchars)++;
 826         } else {
 827             (*eightbitchars)++;
 828         }
 829     }
 830
 831     return *eightbitchars > 0;
 832 }
 833
 834 /*
 835  * This function is to be used to decide which encoding algorithm we should
 836  * use if one is not given.  Basically, we pick whichever one is the shorter
 837  * of the two.
 838  *
 839  * Arguments are:
 840  *
 841  * ascii        - Number of ASCII characters in to-be-encoded string.
 842  * specials     - Number of ASCII characters in to-be-encoded string that
 843  *                still require encoding under quoted-printable.  Note that
 844  *                these are included in the "ascii" total.
 845  * eightbit     - Eight-bit characters in the to-be-encoded string.
 846  *
 847  * Returns one of CE_BASE64 or CE_QUOTED.
 848  */
 849
 850 static int
 851 pref_encoding(int ascii, int specials, int eightbits)
 852 {
 853     /*
 854      * The length of the q-p encoding is:
 855      *
 856      * ascii - specials + (specials + eightbits) * 3.
 857      *
 858      * The length of the base64 encoding is:
 859      *
 860      * base64len(ascii + eightbits)     (See macro for details)
 861      */
 862
 863     return base64len(ascii + eightbits) < (ascii - specials +
 864                         (specials + eightbits) * 3) ? CE_BASE64 : CE_QUOTED;
 865 }