contrib/sendmail-8.14/sendmail/mime.c

   1 /*
   2  * Copyright (c) 1998-2003, 2006 Sendmail, Inc. and its suppliers.
   3  *      All rights reserved.
   4  * Copyright (c) 1994, 1996-1997 Eric P. Allman.  All rights reserved.
   5  * Copyright (c) 1994
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * By using this file, you agree to the terms and conditions set
   9  * forth in the LICENSE file which can be found at the top level of
  10  * the sendmail distribution.
  11  *
  12  */
  13
  14 #include <sendmail.h>
  15 #include <string.h>
  16
  17 SM_RCSID("@(#)$Id: mime.c,v 8.147 2007/09/26 23:29:11 ca Exp $")
  18
  19 /*
  20 **  MIME support.
  21 **
  22 **      I am indebted to John Beck of Hewlett-Packard, who contributed
  23 **      his code to me for inclusion.  As it turns out, I did not use
  24 **      his code since he used a "minimum change" approach that used
  25 **      several temp files, and I wanted a "minimum impact" approach
  26 **      that would avoid copying.  However, looking over his code
  27 **      helped me cement my understanding of the problem.
  28 **
  29 **      I also looked at, but did not directly use, Nathaniel
  30 **      Borenstein's "code.c" module.  Again, it functioned as
  31 **      a file-to-file translator, which did not fit within my
  32 **      design bounds, but it was a useful base for understanding
  33 **      the problem.
  34 */
  35
  36 /* use "old" mime 7 to 8 algorithm by default */
  37 #ifndef MIME7TO8_OLD
  38 # define MIME7TO8_OLD   1
  39 #endif /* ! MIME7TO8_OLD */
  40
  41 #if MIME8TO7
  42 static int      isboundary __P((char *, char **));
  43 static int      mimeboundary __P((char *, char **));
  44 static int      mime_getchar __P((SM_FILE_T *, char **, int *));
  45 static int      mime_getchar_crlf __P((SM_FILE_T *, char **, int *));
  46
  47 /* character set for hex and base64 encoding */
  48 static char     Base16Code[] =  "0123456789ABCDEF";
  49 static char     Base64Code[] =  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  50
  51 /* types of MIME boundaries */
  52 # define MBT_SYNTAX     0       /* syntax error */
  53 # define MBT_NOTSEP     1       /* not a boundary */
  54 # define MBT_INTERMED   2       /* intermediate boundary (no trailing --) */
  55 # define MBT_FINAL      3       /* final boundary (trailing -- included) */
  56
  57 static char     *MimeBoundaryNames[] =
  58 {
  59         "SYNTAX",       "NOTSEP",       "INTERMED",     "FINAL"
  60 };
  61
  62 static bool     MapNLtoCRLF;
  63
  64 /*
  65 **  MIME8TO7 -- output 8 bit body in 7 bit format
  66 **
  67 **      The header has already been output -- this has to do the
  68 **      8 to 7 bit conversion.  It would be easy if we didn't have
  69 **      to deal with nested formats (multipart/xxx and message/rfc822).
  70 **
  71 **      We won't be called if we don't have to do a conversion, and
  72 **      appropriate MIME-Version: and Content-Type: fields have been
  73 **      output.  Any Content-Transfer-Encoding: field has not been
  74 **      output, and we can add it here.
  75 **
  76 **      Parameters:
  77 **              mci -- mailer connection information.
  78 **              header -- the header for this body part.
  79 **              e -- envelope.
  80 **              boundaries -- the currently pending message boundaries.
  81 **                      NULL if we are processing the outer portion.
  82 **              flags -- to tweak processing.
  83 **              level -- recursion level.
  84 **
  85 **      Returns:
  86 **              An indicator of what terminated the message part:
  87 **                MBT_FINAL -- the final boundary
  88 **                MBT_INTERMED -- an intermediate boundary
  89 **                MBT_NOTSEP -- an end of file
  90 **                SM_IO_EOF -- I/O error occurred
  91 */
  92
  93 struct args
  94 {
  95         char    *a_field;       /* name of field */
  96         char    *a_value;       /* value of that field */
  97 };
  98
  99 int
 100 mime8to7(mci, header, e, boundaries, flags, level)
 101         register MCI *mci;
 102         HDR *header;
 103         register ENVELOPE *e;
 104         char **boundaries;
 105         int flags;
 106         int level;
 107 {
 108         register char *p;
 109         int linelen;
 110         int bt;
 111         off_t offset;
 112         size_t sectionsize, sectionhighbits;
 113         int i;
 114         char *type;
 115         char *subtype;
 116         char *cte;
 117         char **pvp;
 118         int argc = 0;
 119         char *bp;
 120         bool use_qp = false;
 121         struct args argv[MAXMIMEARGS];
 122         char bbuf[128];
 123         char buf[MAXLINE];
 124         char pvpbuf[MAXLINE];
 125         extern unsigned char MimeTokenTab[256];
 126
 127         if (level > MAXMIMENESTING)
 128         {
 129                 if (!bitset(EF_TOODEEP, e->e_flags))
 130                 {
 131                         if (tTd(43, 4))
 132                                 sm_dprintf("mime8to7: too deep, level=%d\n",
 133                                            level);
 134                         usrerr("mime8to7: recursion level %d exceeded",
 135                                 level);
 136                         e->e_flags |= EF_DONT_MIME|EF_TOODEEP;
 137                 }
 138         }
 139         if (tTd(43, 1))
 140         {
 141                 sm_dprintf("mime8to7: flags = %x, boundaries =", flags);
 142                 if (boundaries[0] == NULL)
 143                         sm_dprintf(" <none>");
 144                 else
 145                 {
 146                         for (i = 0; boundaries[i] != NULL; i++)
 147                                 sm_dprintf(" %s", boundaries[i]);
 148                 }
 149                 sm_dprintf("\n");
 150         }
 151         MapNLtoCRLF = true;
 152         p = hvalue("Content-Transfer-Encoding", header);
 153         if (p == NULL ||
 154             (pvp = prescan(p, '\0', pvpbuf, sizeof(pvpbuf), NULL,
 155                            MimeTokenTab, false)) == NULL ||
 156             pvp[0] == NULL)
 157         {
 158                 cte = NULL;
 159         }
 160         else
 161         {
 162                 cataddr(pvp, NULL, buf, sizeof(buf), '\0', false);
 163                 cte = sm_rpool_strdup_x(e->e_rpool, buf);
 164         }
 165
 166         type = subtype = NULL;
 167         p = hvalue("Content-Type", header);
 168         if (p == NULL)
 169         {
 170                 if (bitset(M87F_DIGEST, flags))
 171                         p = "message/rfc822";
 172                 else
 173                         p = "text/plain";
 174         }
 175         if (p != NULL &&
 176             (pvp = prescan(p, '\0', pvpbuf, sizeof(pvpbuf), NULL,
 177                            MimeTokenTab, false)) != NULL &&
 178             pvp[0] != NULL)
 179         {
 180                 if (tTd(43, 40))
 181                 {
 182                         for (i = 0; pvp[i] != NULL; i++)
 183                                 sm_dprintf("pvp[%d] = \"%s\"\n", i, pvp[i]);
 184                 }
 185                 type = *pvp++;
 186                 if (*pvp != NULL && strcmp(*pvp, "/") == 0 &&
 187                     *++pvp != NULL)
 188                 {
 189                         subtype = *pvp++;
 190                 }
 191
 192                 /* break out parameters */
 193                 while (*pvp != NULL && argc < MAXMIMEARGS)
 194                 {
 195                         /* skip to semicolon separator */
 196                         while (*pvp != NULL && strcmp(*pvp, ";") != 0)
 197                                 pvp++;
 198                         if (*pvp++ == NULL || *pvp == NULL)
 199                                 break;
 200
 201                         /* complain about empty values */
 202                         if (strcmp(*pvp, ";") == 0)
 203                         {
 204                                 usrerr("mime8to7: Empty parameter in Content-Type header");
 205
 206                                 /* avoid bounce loops */
 207                                 e->e_flags |= EF_DONT_MIME;
 208                                 continue;
 209                         }
 210
 211                         /* extract field name */
 212                         argv[argc].a_field = *pvp++;
 213
 214                         /* see if there is a value */
 215                         if (*pvp != NULL && strcmp(*pvp, "=") == 0 &&
 216                             (*++pvp == NULL || strcmp(*pvp, ";") != 0))
 217                         {
 218                                 argv[argc].a_value = *pvp;
 219                                 argc++;
 220                         }
 221                 }
 222         }
 223
 224         /* check for disaster cases */
 225         if (type == NULL)
 226                 type = "-none-";
 227         if (subtype == NULL)
 228                 subtype = "-none-";
 229
 230         /* don't propagate some flags more than one level into the message */
 231         flags &= ~M87F_DIGEST;
 232
 233         /*
 234         **  Check for cases that can not be encoded.
 235         **
 236         **      For example, you can't encode certain kinds of types
 237         **      or already-encoded messages.  If we find this case,
 238         **      just copy it through.
 239         */
 240
 241         (void) sm_snprintf(buf, sizeof(buf), "%.100s/%.100s", type, subtype);
 242         if (wordinclass(buf, 'n') || (cte != NULL && !wordinclass(cte, 'e')))
 243                 flags |= M87F_NO8BIT;
 244
 245 # ifdef USE_B_CLASS
 246         if (wordinclass(buf, 'b') || wordinclass(type, 'b'))
 247                 MapNLtoCRLF = false;
 248 # endif /* USE_B_CLASS */
 249         if (wordinclass(buf, 'q') || wordinclass(type, 'q'))
 250                 use_qp = true;
 251
 252         /*
 253         **  Multipart requires special processing.
 254         **
 255         **      Do a recursive descent into the message.
 256         */
 257
 258         if (sm_strcasecmp(type, "multipart") == 0 &&
 259             (!bitset(M87F_NO8BIT, flags) || bitset(M87F_NO8TO7, flags)) &&
 260             !bitset(EF_TOODEEP, e->e_flags)
 261            )
 262         {
 263
 264                 if (sm_strcasecmp(subtype, "digest") == 0)
 265                         flags |= M87F_DIGEST;
 266
 267                 for (i = 0; i < argc; i++)
 268                 {
 269                         if (sm_strcasecmp(argv[i].a_field, "boundary") == 0)
 270                                 break;
 271                 }
 272                 if (i >= argc || argv[i].a_value == NULL)
 273                 {
 274                         usrerr("mime8to7: Content-Type: \"%s\": %s boundary",
 275                                 i >= argc ? "missing" : "bogus", p);
 276                         p = "---";
 277
 278                         /* avoid bounce loops */
 279                         e->e_flags |= EF_DONT_MIME;
 280                 }
 281                 else
 282                 {
 283                         p = argv[i].a_value;
 284                         stripquotes(p);
 285                 }
 286                 if (sm_strlcpy(bbuf, p, sizeof(bbuf)) >= sizeof(bbuf))
 287                 {
 288                         usrerr("mime8to7: multipart boundary \"%s\" too long",
 289                                 p);
 290
 291                         /* avoid bounce loops */
 292                         e->e_flags |= EF_DONT_MIME;
 293                 }
 294
 295                 if (tTd(43, 1))
 296                         sm_dprintf("mime8to7: multipart boundary \"%s\"\n",
 297                                 bbuf);
 298                 for (i = 0; i < MAXMIMENESTING; i++)
 299                 {
 300                         if (boundaries[i] == NULL)
 301                                 break;
 302                 }
 303                 if (i >= MAXMIMENESTING)
 304                 {
 305                         if (tTd(43, 4))
 306                                 sm_dprintf("mime8to7: too deep, i=%d\n", i);
 307                         if (!bitset(EF_TOODEEP, e->e_flags))
 308                                 usrerr("mime8to7: multipart nesting boundary too deep");
 309
 310                         /* avoid bounce loops */
 311                         e->e_flags |= EF_DONT_MIME|EF_TOODEEP;
 312                 }
 313                 else
 314                 {
 315                         boundaries[i] = bbuf;
 316                         boundaries[i + 1] = NULL;
 317                 }
 318                 mci->mci_flags |= MCIF_INMIME;
 319
 320                 /* skip the early "comment" prologue */
 321                 if (!putline("", mci))
 322                         goto writeerr;
 323                 mci->mci_flags &= ~MCIF_INHEADER;
 324                 bt = MBT_FINAL;
 325                 while (sm_io_fgets(e->e_dfp, SM_TIME_DEFAULT, buf, sizeof(buf))
 326                         != NULL)
 327                 {
 328                         bt = mimeboundary(buf, boundaries);
 329                         if (bt != MBT_NOTSEP)
 330                                 break;
 331                         if (!putxline(buf, strlen(buf), mci,
 332                                         PXLF_MAPFROM|PXLF_STRIP8BIT))
 333                                 goto writeerr;
 334                         if (tTd(43, 99))
 335                                 sm_dprintf("  ...%s", buf);
 336                 }
 337                 if (sm_io_eof(e->e_dfp))
 338                         bt = MBT_FINAL;
 339                 while (bt != MBT_FINAL)
 340                 {
 341                         auto HDR *hdr = NULL;
 342
 343                         (void) sm_strlcpyn(buf, sizeof(buf), 2, "--", bbuf);
 344                         if (!putline(buf, mci))
 345                                 goto writeerr;
 346                         if (tTd(43, 35))
 347                                 sm_dprintf("  ...%s\n", buf);
 348                         collect(e->e_dfp, false, &hdr, e, false);
 349                         if (tTd(43, 101))
 350                                 putline("+++after collect", mci);
 351                         if (!putheader(mci, hdr, e, flags))
 352                                 goto writeerr;
 353                         if (tTd(43, 101))
 354                                 putline("+++after putheader", mci);
 355                         bt = mime8to7(mci, hdr, e, boundaries, flags,
 356                                       level + 1);
 357                         if (bt == SM_IO_EOF)
 358                                 goto writeerr;
 359                 }
 360                 (void) sm_strlcpyn(buf, sizeof(buf), 3, "--", bbuf, "--");
 361                 if (!putline(buf, mci))
 362                         goto writeerr;
 363                 if (tTd(43, 35))
 364                         sm_dprintf("  ...%s\n", buf);
 365                 boundaries[i] = NULL;
 366                 mci->mci_flags &= ~MCIF_INMIME;
 367
 368                 /* skip the late "comment" epilogue */
 369                 while (sm_io_fgets(e->e_dfp, SM_TIME_DEFAULT, buf, sizeof(buf))
 370                         != NULL)
 371                 {
 372                         bt = mimeboundary(buf, boundaries);
 373                         if (bt != MBT_NOTSEP)
 374                                 break;
 375                         if (!putxline(buf, strlen(buf), mci,
 376                                         PXLF_MAPFROM|PXLF_STRIP8BIT))
 377                                 goto writeerr;
 378                         if (tTd(43, 99))
 379                                 sm_dprintf("  ...%s", buf);
 380                 }
 381                 if (sm_io_eof(e->e_dfp))
 382                         bt = MBT_FINAL;
 383                 if (tTd(43, 3))
 384                         sm_dprintf("\t\t\tmime8to7=>%s (multipart)\n",
 385                                 MimeBoundaryNames[bt]);
 386                 return bt;
 387         }
 388
 389         /*
 390         **  Message/xxx types -- recurse exactly once.
 391         **
 392         **      Class 's' is predefined to have "rfc822" only.
 393         */
 394
 395         if (sm_strcasecmp(type, "message") == 0)
 396         {
 397                 if (!wordinclass(subtype, 's') ||
 398                     bitset(EF_TOODEEP, e->e_flags))
 399                 {
 400                         flags |= M87F_NO8BIT;
 401                 }
 402                 else
 403                 {
 404                         auto HDR *hdr = NULL;
 405
 406                         if (!putline("", mci))
 407                                 goto writeerr;
 408
 409                         mci->mci_flags |= MCIF_INMIME;
 410                         collect(e->e_dfp, false, &hdr, e, false);
 411                         if (tTd(43, 101))
 412                                 putline("+++after collect", mci);
 413                         if (!putheader(mci, hdr, e, flags))
 414                                 goto writeerr;
 415                         if (tTd(43, 101))
 416                                 putline("+++after putheader", mci);
 417                         if (hvalue("MIME-Version", hdr) == NULL &&
 418                             !bitset(M87F_NO8TO7, flags) &&
 419                             !putline("MIME-Version: 1.0", mci))
 420                                 goto writeerr;
 421                         bt = mime8to7(mci, hdr, e, boundaries, flags,
 422                                       level + 1);
 423                         mci->mci_flags &= ~MCIF_INMIME;
 424                         return bt;
 425                 }
 426         }
 427
 428         /*
 429         **  Non-compound body type
 430         **
 431         **      Compute the ratio of seven to eight bit characters;
 432         **      use that as a heuristic to decide how to do the
 433         **      encoding.
 434         */
 435
 436         sectionsize = sectionhighbits = 0;
 437         if (!bitset(M87F_NO8BIT|M87F_NO8TO7, flags))
 438         {
 439                 /* remember where we were */
 440                 offset = sm_io_tell(e->e_dfp, SM_TIME_DEFAULT);
 441                 if (offset == -1)
 442                         syserr("mime8to7: cannot sm_io_tell on %cf%s",
 443                                DATAFL_LETTER, e->e_id);
 444
 445                 /* do a scan of this body type to count character types */
 446                 while (sm_io_fgets(e->e_dfp, SM_TIME_DEFAULT, buf, sizeof(buf))
 447                         != NULL)
 448                 {
 449                         if (mimeboundary(buf, boundaries) != MBT_NOTSEP)
 450                                 break;
 451                         for (p = buf; *p != '\0'; p++)
 452                         {
 453                                 /* count bytes with the high bit set */
 454                                 sectionsize++;
 455                                 if (bitset(0200, *p))
 456                                         sectionhighbits++;
 457                         }
 458
 459                         /*
 460                         **  Heuristic: if 1/4 of the first 4K bytes are 8-bit,
 461                         **  assume base64.  This heuristic avoids double-reading
 462                         **  large graphics or video files.
 463                         */
 464
 465                         if (sectionsize >= 4096 &&
 466                             sectionhighbits > sectionsize / 4)
 467                                 break;
 468                 }
 469
 470                 /* return to the original offset for processing */
 471                 /* XXX use relative seeks to handle >31 bit file sizes? */
 472                 if (sm_io_seek(e->e_dfp, SM_TIME_DEFAULT, offset, SEEK_SET) < 0)
 473                         syserr("mime8to7: cannot sm_io_fseek on %cf%s",
 474                                DATAFL_LETTER, e->e_id);
 475                 else
 476                         sm_io_clearerr(e->e_dfp);
 477         }
 478
 479         /*
 480         **  Heuristically determine encoding method.
 481         **      If more than 1/8 of the total characters have the
 482         **      eighth bit set, use base64; else use quoted-printable.
 483         **      However, only encode binary encoded data as base64,
 484         **      since otherwise the NL=>CRLF mapping will be a problem.
 485         */
 486
 487         if (tTd(43, 8))
 488         {
 489                 sm_dprintf("mime8to7: %ld high bit(s) in %ld byte(s), cte=%s, type=%s/%s\n",
 490                         (long) sectionhighbits, (long) sectionsize,
 491                         cte == NULL ? "[none]" : cte,
 492                         type == NULL ? "[none]" : type,
 493                         subtype == NULL ? "[none]" : subtype);
 494         }
 495         if (cte != NULL && sm_strcasecmp(cte, "binary") == 0)
 496                 sectionsize = sectionhighbits;
 497         linelen = 0;
 498         bp = buf;
 499         if (sectionhighbits == 0)
 500         {
 501                 /* no encoding necessary */
 502                 if (cte != NULL &&
 503                     bitset(MCIF_CVT8TO7|MCIF_CVT7TO8|MCIF_INMIME,
 504                            mci->mci_flags) &&
 505                     !bitset(M87F_NO8TO7, flags))
 506                 {
 507                         /*
 508                         **  Skip _unless_ in MIME mode and potentially
 509                         **  converting from 8 bit to 7 bit MIME.  See
 510                         **  putheader() for the counterpart where the
 511                         **  CTE header is skipped in the opposite
 512                         **  situation.
 513                         */
 514
 515                         (void) sm_snprintf(buf, sizeof(buf),
 516                                 "Content-Transfer-Encoding: %.200s", cte);
 517                         if (!putline(buf, mci))
 518                                 goto writeerr;
 519                         if (tTd(43, 36))
 520                                 sm_dprintf("  ...%s\n", buf);
 521                 }
 522                 if (!putline("", mci))
 523                         goto writeerr;
 524                 mci->mci_flags &= ~MCIF_INHEADER;
 525                 while (sm_io_fgets(e->e_dfp, SM_TIME_DEFAULT, buf, sizeof(buf))
 526                         != NULL)
 527                 {
 528                         if (!bitset(MCIF_INLONGLINE, mci->mci_flags))
 529                         {
 530                                 bt = mimeboundary(buf, boundaries);
 531                                 if (bt != MBT_NOTSEP)
 532                                         break;
 533                         }
 534                         if (!putxline(buf, strlen(buf), mci,
 535                                       PXLF_MAPFROM|PXLF_NOADDEOL))
 536                                 goto writeerr;
 537                 }
 538                 if (sm_io_eof(e->e_dfp))
 539                         bt = MBT_FINAL;
 540         }
 541         else if (!MapNLtoCRLF ||
 542                  (sectionsize / 8 < sectionhighbits && !use_qp))
 543         {
 544                 /* use base64 encoding */
 545                 int c1, c2;
 546
 547                 if (tTd(43, 36))
 548                         sm_dprintf("  ...Content-Transfer-Encoding: base64\n");
 549                 if (!putline("Content-Transfer-Encoding: base64", mci))
 550                         goto writeerr;
 551                 (void) sm_snprintf(buf, sizeof(buf),
 552                         "X-MIME-Autoconverted: from 8bit to base64 by %s id %s",
 553                         MyHostName, e->e_id);
 554                 if (!putline(buf, mci) || !putline("", mci))
 555                         goto writeerr;
 556                 mci->mci_flags &= ~MCIF_INHEADER;
 557                 while ((c1 = mime_getchar_crlf(e->e_dfp, boundaries, &bt)) !=
 558                         SM_IO_EOF)
 559                 {
 560                         if (linelen > 71)
 561                         {
 562                                 *bp = '\0';
 563                                 if (!putline(buf, mci))
 564                                         goto writeerr;
 565                                 linelen = 0;
 566                                 bp = buf;
 567                         }
 568                         linelen += 4;
 569                         *bp++ = Base64Code[(c1 >> 2)];
 570                         c1 = (c1 & 0x03) << 4;
 571                         c2 = mime_getchar_crlf(e->e_dfp, boundaries, &bt);
 572                         if (c2 == SM_IO_EOF)
 573                         {
 574                                 *bp++ = Base64Code[c1];
 575                                 *bp++ = '=';
 576                                 *bp++ = '=';
 577                                 break;
 578                         }
 579                         c1 |= (c2 >> 4) & 0x0f;
 580                         *bp++ = Base64Code[c1];
 581                         c1 = (c2 & 0x0f) << 2;
 582                         c2 = mime_getchar_crlf(e->e_dfp, boundaries, &bt);
 583                         if (c2 == SM_IO_EOF)
 584                         {
 585                                 *bp++ = Base64Code[c1];
 586                                 *bp++ = '=';
 587                                 break;
 588                         }
 589                         c1 |= (c2 >> 6) & 0x03;
 590                         *bp++ = Base64Code[c1];
 591                         *bp++ = Base64Code[c2 & 0x3f];
 592                 }
 593                 *bp = '\0';
 594                 if (!putline(buf, mci))
 595                         goto writeerr;
 596         }
 597         else
 598         {
 599                 /* use quoted-printable encoding */
 600                 int c1, c2;
 601                 int fromstate;
 602                 BITMAP256 badchars;
 603
 604                 /* set up map of characters that must be mapped */
 605                 clrbitmap(badchars);
 606                 for (c1 = 0x00; c1 < 0x20; c1++)
 607                         setbitn(c1, badchars);
 608                 clrbitn('\t', badchars);
 609                 for (c1 = 0x7f; c1 < 0x100; c1++)
 610                         setbitn(c1, badchars);
 611                 setbitn('=', badchars);
 612                 if (bitnset(M_EBCDIC, mci->mci_mailer->m_flags))
 613                         for (p = "!\"#$@[\\]^`{|}~"; *p != '\0'; p++)
 614                                 setbitn(*p, badchars);
 615
 616                 if (tTd(43, 36))
 617                         sm_dprintf("  ...Content-Transfer-Encoding: quoted-printable\n");
 618                 if (!putline("Content-Transfer-Encoding: quoted-printable",
 619                                 mci))
 620                         goto writeerr;
 621                 (void) sm_snprintf(buf, sizeof(buf),
 622                         "X-MIME-Autoconverted: from 8bit to quoted-printable by %s id %s",
 623                         MyHostName, e->e_id);
 624                 if (!putline(buf, mci) || !putline("", mci))
 625                         goto writeerr;
 626                 mci->mci_flags &= ~MCIF_INHEADER;
 627                 fromstate = 0;
 628                 c2 = '\n';
 629                 while ((c1 = mime_getchar(e->e_dfp, boundaries, &bt)) !=
 630                         SM_IO_EOF)
 631                 {
 632                         if (c1 == '\n')
 633                         {
 634                                 if (c2 == ' ' || c2 == '\t')
 635                                 {
 636                                         *bp++ = '=';
 637                                         *bp++ = Base16Code[(c2 >> 4) & 0x0f];
 638                                         *bp++ = Base16Code[c2 & 0x0f];
 639                                 }
 640                                 if (buf[0] == '.' && bp == &buf[1])
 641                                 {
 642                                         buf[0] = '=';
 643                                         *bp++ = Base16Code[('.' >> 4) & 0x0f];
 644                                         *bp++ = Base16Code['.' & 0x0f];
 645                                 }
 646                                 *bp = '\0';
 647                                 if (!putline(buf, mci))
 648                                         goto writeerr;
 649                                 linelen = fromstate = 0;
 650                                 bp = buf;
 651                                 c2 = c1;
 652                                 continue;
 653                         }
 654                         if (c2 == ' ' && linelen == 4 && fromstate == 4 &&
 655                             bitnset(M_ESCFROM, mci->mci_mailer->m_flags))
 656                         {
 657                                 *bp++ = '=';
 658                                 *bp++ = '2';
 659                                 *bp++ = '0';
 660                                 linelen += 3;
 661                         }
 662                         else if (c2 == ' ' || c2 == '\t')
 663                         {
 664                                 *bp++ = c2;
 665                                 linelen++;
 666                         }
 667                         if (linelen > 72 &&
 668                             (linelen > 75 || c1 != '.' ||
 669                              (linelen > 73 && c2 == '.')))
 670                         {
 671                                 if (linelen > 73 && c2 == '.')
 672                                         bp--;
 673                                 else
 674                                         c2 = '\n';
 675                                 *bp++ = '=';
 676                                 *bp = '\0';
 677                                 if (!putline(buf, mci))
 678                                         goto writeerr;
 679                                 linelen = fromstate = 0;
 680                                 bp = buf;
 681                                 if (c2 == '.')
 682                                 {
 683                                         *bp++ = '.';
 684                                         linelen++;
 685                                 }
 686                         }
 687                         if (bitnset(bitidx(c1), badchars))
 688                         {
 689                                 *bp++ = '=';
 690                                 *bp++ = Base16Code[(c1 >> 4) & 0x0f];
 691                                 *bp++ = Base16Code[c1 & 0x0f];
 692                                 linelen += 3;
 693                         }
 694                         else if (c1 != ' ' && c1 != '\t')
 695                         {
 696                                 if (linelen < 4 && c1 == "From"[linelen])
 697                                         fromstate++;
 698                                 *bp++ = c1;
 699                                 linelen++;
 700                         }
 701                         c2 = c1;
 702                 }
 703
 704                 /* output any saved character */
 705                 if (c2 == ' ' || c2 == '\t')
 706                 {
 707                         *bp++ = '=';
 708                         *bp++ = Base16Code[(c2 >> 4) & 0x0f];
 709                         *bp++ = Base16Code[c2 & 0x0f];
 710                         linelen += 3;
 711                 }
 712
 713                 if (linelen > 0 || boundaries[0] != NULL)
 714                 {
 715                         *bp = '\0';
 716                         if (!putline(buf, mci))
 717                                 goto writeerr;
 718                 }
 719
 720         }
 721         if (tTd(43, 3))
 722                 sm_dprintf("\t\t\tmime8to7=>%s (basic)\n", MimeBoundaryNames[bt]);
 723         return bt;
 724
 725   writeerr:
 726         return SM_IO_EOF;
 727 }
 728 /*
 729 **  MIME_GETCHAR -- get a character for MIME processing
 730 **
 731 **      Treats boundaries as SM_IO_EOF.
 732 **
 733 **      Parameters:
 734 **              fp -- the input file.
 735 **              boundaries -- the current MIME boundaries.
 736 **              btp -- if the return value is SM_IO_EOF, *btp is set to
 737 **                      the type of the boundary.
 738 **
 739 **      Returns:
 740 **              The next character in the input stream.
 741 */
 742
 743 static int
 744 mime_getchar(fp, boundaries, btp)
 745         register SM_FILE_T *fp;
 746         char **boundaries;
 747         int *btp;
 748 {
 749         int c;
 750         static unsigned char *bp = NULL;
 751         static int buflen = 0;
 752         static bool atbol = true;       /* at beginning of line */
 753         static int bt = MBT_SYNTAX;     /* boundary type of next SM_IO_EOF */
 754         static unsigned char buf[128];  /* need not be a full line */
 755         int start = 0;                  /* indicates position of - in buffer */
 756
 757         if (buflen == 1 && *bp == '\n')
 758         {
 759                 /* last \n in buffer may be part of next MIME boundary */
 760                 c = *bp;
 761         }
 762         else if (buflen > 0)
 763         {
 764                 buflen--;
 765                 return *bp++;
 766         }
 767         else
 768                 c = sm_io_getc(fp, SM_TIME_DEFAULT);
 769         bp = buf;
 770         buflen = 0;
 771         if (c == '\n')
 772         {
 773                 /* might be part of a MIME boundary */
 774                 *bp++ = c;
 775                 atbol = true;
 776                 c = sm_io_getc(fp, SM_TIME_DEFAULT);
 777                 if (c == '\n')
 778                 {
 779                         (void) sm_io_ungetc(fp, SM_TIME_DEFAULT, c);
 780                         return c;
 781                 }
 782                 start = 1;
 783         }
 784         if (c != SM_IO_EOF)
 785                 *bp++ = c;
 786         else
 787                 bt = MBT_FINAL;
 788         if (atbol && c == '-')
 789         {
 790                 /* check for a message boundary */
 791                 c = sm_io_getc(fp, SM_TIME_DEFAULT);
 792                 if (c != '-')
 793                 {
 794                         if (c != SM_IO_EOF)
 795                                 *bp++ = c;
 796                         else
 797                                 bt = MBT_FINAL;
 798                         buflen = bp - buf - 1;
 799                         bp = buf;
 800                         return *bp++;
 801                 }
 802
 803                 /* got "--", now check for rest of separator */
 804                 *bp++ = '-';
 805                 while (bp < &buf[sizeof(buf) - 2] &&
 806                        (c = sm_io_getc(fp, SM_TIME_DEFAULT)) != SM_IO_EOF &&
 807                        c != '\n')
 808                 {
 809                         *bp++ = c;
 810                 }
 811                 *bp = '\0';     /* XXX simply cut off? */
 812                 bt = mimeboundary((char *) &buf[start], boundaries);
 813                 switch (bt)
 814                 {
 815                   case MBT_FINAL:
 816                   case MBT_INTERMED:
 817                         /* we have a message boundary */
 818                         buflen = 0;
 819                         *btp = bt;
 820                         return SM_IO_EOF;
 821                 }
 822
 823                 if (bp < &buf[sizeof(buf) - 2] && c != SM_IO_EOF)
 824                         *bp++ = c;
 825         }
 826
 827         atbol = c == '\n';
 828         buflen = bp - buf - 1;
 829         if (buflen < 0)
 830         {
 831                 *btp = bt;
 832                 return SM_IO_EOF;
 833         }
 834         bp = buf;
 835         return *bp++;
 836 }
 837 /*
 838 **  MIME_GETCHAR_CRLF -- do mime_getchar, but translate NL => CRLF
 839 **
 840 **      Parameters:
 841 **              fp -- the input file.
 842 **              boundaries -- the current MIME boundaries.
 843 **              btp -- if the return value is SM_IO_EOF, *btp is set to
 844 **                      the type of the boundary.
 845 **
 846 **      Returns:
 847 **              The next character in the input stream.
 848 */
 849
 850 static int
 851 mime_getchar_crlf(fp, boundaries, btp)
 852         register SM_FILE_T *fp;
 853         char **boundaries;
 854         int *btp;
 855 {
 856         static bool sendlf = false;
 857         int c;
 858
 859         if (sendlf)
 860         {
 861                 sendlf = false;
 862                 return '\n';
 863         }
 864         c = mime_getchar(fp, boundaries, btp);
 865         if (c == '\n' && MapNLtoCRLF)
 866         {
 867                 sendlf = true;
 868                 return '\r';
 869         }
 870         return c;
 871 }
 872 /*
 873 **  MIMEBOUNDARY -- determine if this line is a MIME boundary & its type
 874 **
 875 **      Parameters:
 876 **              line -- the input line.
 877 **              boundaries -- the set of currently pending boundaries.
 878 **
 879 **      Returns:
 880 **              MBT_NOTSEP -- if this is not a separator line
 881 **              MBT_INTERMED -- if this is an intermediate separator
 882 **              MBT_FINAL -- if this is a final boundary
 883 **              MBT_SYNTAX -- if this is a boundary for the wrong
 884 **                      enclosure -- i.e., a syntax error.
 885 */
 886
 887 static int
 888 mimeboundary(line, boundaries)
 889         register char *line;
 890         char **boundaries;
 891 {
 892         int type = MBT_NOTSEP;
 893         int i;
 894         int savec;
 895
 896         if (line[0] != '-' || line[1] != '-' || boundaries == NULL)
 897                 return MBT_NOTSEP;
 898         i = strlen(line);
 899         if (i > 0 && line[i - 1] == '\n')
 900                 i--;
 901
 902         /* strip off trailing whitespace */
 903         while (i > 0 && (line[i - 1] == ' ' || line[i - 1] == '\t'
 904 #if _FFR_MIME_CR_OK
 905                 || line[i - 1] == '\r'
 906 #endif /* _FFR_MIME_CR_OK */
 907                ))
 908                 i--;
 909         savec = line[i];
 910         line[i] = '\0';
 911
 912         if (tTd(43, 5))
 913                 sm_dprintf("mimeboundary: line=\"%s\"... ", line);
 914
 915         /* check for this as an intermediate boundary */
 916         if (isboundary(&line[2], boundaries) >= 0)
 917                 type = MBT_INTERMED;
 918         else if (i > 2 && strncmp(&line[i - 2], "--", 2) == 0)
 919         {
 920                 /* check for a final boundary */
 921                 line[i - 2] = '\0';
 922                 if (isboundary(&line[2], boundaries) >= 0)
 923                         type = MBT_FINAL;
 924                 line[i - 2] = '-';
 925         }
 926
 927         line[i] = savec;
 928         if (tTd(43, 5))
 929                 sm_dprintf("%s\n", MimeBoundaryNames[type]);
 930         return type;
 931 }
 932 /*
 933 **  DEFCHARSET -- return default character set for message
 934 **
 935 **      The first choice for character set is for the mailer
 936 **      corresponding to the envelope sender.  If neither that
 937 **      nor the global configuration file has a default character
 938 **      set defined, return "unknown-8bit" as recommended by
 939 **      RFC 1428 section 3.
 940 **
 941 **      Parameters:
 942 **              e -- the envelope for this message.
 943 **
 944 **      Returns:
 945 **              The default character set for that mailer.
 946 */
 947
 948 char *
 949 defcharset(e)
 950         register ENVELOPE *e;
 951 {
 952         if (e != NULL && e->e_from.q_mailer != NULL &&
 953             e->e_from.q_mailer->m_defcharset != NULL)
 954                 return e->e_from.q_mailer->m_defcharset;
 955         if (DefaultCharSet != NULL)
 956                 return DefaultCharSet;
 957         return "unknown-8bit";
 958 }
 959 /*
 960 **  ISBOUNDARY -- is a given string a currently valid boundary?
 961 **
 962 **      Parameters:
 963 **              line -- the current input line.
 964 **              boundaries -- the list of valid boundaries.
 965 **
 966 **      Returns:
 967 **              The index number in boundaries if the line is found.
 968 **              -1 -- otherwise.
 969 **
 970 */
 971
 972 static int
 973 isboundary(line, boundaries)
 974         char *line;
 975         char **boundaries;
 976 {
 977         register int i;
 978
 979         for (i = 0; i <= MAXMIMENESTING && boundaries[i] != NULL; i++)
 980         {
 981                 if (strcmp(line, boundaries[i]) == 0)
 982                         return i;
 983         }
 984         return -1;
 985 }
 986 #endif /* MIME8TO7 */
 987
 988 #if MIME7TO8
 989 static int      mime_fromqp __P((unsigned char *, unsigned char **, int));
 990
 991 /*
 992 **  MIME7TO8 -- output 7 bit encoded MIME body in 8 bit format
 993 **
 994 **  This is a hack. Supports translating the two 7-bit body-encodings
 995 **  (quoted-printable and base64) to 8-bit coded bodies.
 996 **
 997 **  There is not much point in supporting multipart here, as the UA
 998 **  will be able to deal with encoded MIME bodies if it can parse MIME
 999 **  multipart messages.
1000 **
1001 **  Note also that we won't be called unless it is a text/plain MIME
1002 **  message, encoded base64 or QP and mailer flag '9' has been defined
1003 **  on mailer.
1004 **
1005 **  Contributed by Marius Olaffson <marius@rhi.hi.is>.
1006 **
1007 **      Parameters:
1008 **              mci -- mailer connection information.
1009 **              header -- the header for this body part.
1010 **              e -- envelope.
1011 **
1012 **      Returns:
1013 **              true iff body was written successfully
1014 */
1015
1016 static char index_64[128] =
1017 {
1018         -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1019         -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1020         -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
1021         52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,-1,-1,-1,
1022         -1, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
1023         15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
1024         -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
1025         41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
1026 };
1027
1028 # define CHAR64(c)  (((c) < 0 || (c) > 127) ? -1 : index_64[(c)])
1029
1030 bool
1031 mime7to8(mci, header, e)
1032         register MCI *mci;
1033         HDR *header;
1034         register ENVELOPE *e;
1035 {
1036         int pxflags;
1037         register char *p;
1038         char *cte;
1039         char **pvp;
1040         unsigned char *fbufp;
1041         char buf[MAXLINE];
1042         unsigned char fbuf[MAXLINE + 1];
1043         char pvpbuf[MAXLINE];
1044         extern unsigned char MimeTokenTab[256];
1045
1046         p = hvalue("Content-Transfer-Encoding", header);
1047         if (p == NULL ||
1048             (pvp = prescan(p, '\0', pvpbuf, sizeof(pvpbuf), NULL,
1049                            MimeTokenTab, false)) == NULL ||
1050             pvp[0] == NULL)
1051         {
1052                 /* "can't happen" -- upper level should have caught this */
1053                 syserr("mime7to8: unparsable CTE %s", p == NULL ? "<NULL>" : p);
1054
1055                 /* avoid bounce loops */
1056                 e->e_flags |= EF_DONT_MIME;
1057
1058                 /* cheap failsafe algorithm -- should work on text/plain */
1059                 if (p != NULL)
1060                 {
1061                         (void) sm_snprintf(buf, sizeof(buf),
1062                                 "Content-Transfer-Encoding: %s", p);
1063                         if (!putline(buf, mci))
1064                                 goto writeerr;
1065                 }
1066                 if (!putline("", mci))
1067                         goto writeerr;
1068                 mci->mci_flags &= ~MCIF_INHEADER;
1069                 while (sm_io_fgets(e->e_dfp, SM_TIME_DEFAULT, buf, sizeof(buf))
1070                         != NULL)
1071                 {
1072                         if (!putline(buf, mci))
1073                                 goto writeerr;
1074                 }
1075                 return true;
1076         }
1077         cataddr(pvp, NULL, buf, sizeof(buf), '\0', false);
1078         cte = sm_rpool_strdup_x(e->e_rpool, buf);
1079
1080         mci->mci_flags |= MCIF_INHEADER;
1081         if (!putline("Content-Transfer-Encoding: 8bit", mci))
1082                 goto writeerr;
1083         (void) sm_snprintf(buf, sizeof(buf),
1084                 "X-MIME-Autoconverted: from %.200s to 8bit by %s id %s",
1085                 cte, MyHostName, e->e_id);
1086         if (!putline(buf, mci) || !putline("", mci))
1087                 goto writeerr;
1088         mci->mci_flags &= ~MCIF_INHEADER;
1089
1090         /*
1091         **  Translate body encoding to 8-bit.  Supports two types of
1092         **  encodings; "base64" and "quoted-printable". Assume qp if
1093         **  it is not base64.
1094         */
1095
1096         pxflags = PXLF_MAPFROM;
1097         if (sm_strcasecmp(cte, "base64") == 0)
1098         {
1099                 int c1, c2, c3, c4;
1100
1101                 fbufp = fbuf;
1102                 while ((c1 = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT)) !=
1103                         SM_IO_EOF)
1104                 {
1105                         if (isascii(c1) && isspace(c1))
1106                                 continue;
1107
1108                         do
1109                         {
1110                                 c2 = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT);
1111                         } while (isascii(c2) && isspace(c2));
1112                         if (c2 == SM_IO_EOF)
1113                                 break;
1114
1115                         do
1116                         {
1117                                 c3 = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT);
1118                         } while (isascii(c3) && isspace(c3));
1119                         if (c3 == SM_IO_EOF)
1120                                 break;
1121
1122                         do
1123                         {
1124                                 c4 = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT);
1125                         } while (isascii(c4) && isspace(c4));
1126                         if (c4 == SM_IO_EOF)
1127                                 break;
1128
1129                         if (c1 == '=' || c2 == '=')
1130                                 continue;
1131                         c1 = CHAR64(c1);
1132                         c2 = CHAR64(c2);
1133
1134 #if MIME7TO8_OLD
1135 #define CHK_EOL if (*--fbufp != '\n' || (fbufp > fbuf && *--fbufp != '\r')) \
1136                         ++fbufp;
1137 #else /* MIME7TO8_OLD */
1138 #define CHK_EOL if (*--fbufp != '\n' || (fbufp > fbuf && *--fbufp != '\r')) \
1139                 {                                       \
1140                         ++fbufp;                        \
1141                         pxflags |= PXLF_NOADDEOL;       \
1142                 }
1143 #endif /* MIME7TO8_OLD */
1144
1145 #define PUTLINE64       \
1146         do              \
1147         {               \
1148                 if (*fbufp++ == '\n' || fbufp >= &fbuf[MAXLINE])        \
1149                 {                                                       \
1150                         CHK_EOL;                                        \
1151                         if (!putxline((char *) fbuf, fbufp - fbuf, mci, pxflags)) \
1152                                 goto writeerr;                          \
1153                         pxflags &= ~PXLF_NOADDEOL;                      \
1154                         fbufp = fbuf;                                   \
1155                 }       \
1156         } while (0)
1157
1158                         *fbufp = (c1 << 2) | ((c2 & 0x30) >> 4);
1159                         PUTLINE64;
1160                         if (c3 == '=')
1161                                 continue;
1162                         c3 = CHAR64(c3);
1163                         *fbufp = ((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2);
1164                         PUTLINE64;
1165                         if (c4 == '=')
1166                                 continue;
1167                         c4 = CHAR64(c4);
1168                         *fbufp = ((c3 & 0x03) << 6) | c4;
1169                         PUTLINE64;
1170                 }
1171         }
1172         else
1173         {
1174                 int off;
1175
1176                 /* quoted-printable */
1177                 pxflags |= PXLF_NOADDEOL;
1178                 fbufp = fbuf;
1179                 while (sm_io_fgets(e->e_dfp, SM_TIME_DEFAULT, buf,
1180                                    sizeof(buf)) != NULL)
1181                 {
1182                         off = mime_fromqp((unsigned char *) buf, &fbufp,
1183                                           &fbuf[MAXLINE] - fbufp);
1184 again:
1185                         if (off < -1)
1186                                 continue;
1187
1188                         if (fbufp - fbuf > 0)
1189                         {
1190                                 if (!putxline((char *) fbuf, fbufp - fbuf - 1,
1191                                                 mci, pxflags))
1192                                         goto writeerr;
1193                         }
1194                         fbufp = fbuf;
1195                         if (off >= 0 && buf[off] != '\0')
1196                         {
1197                                 off = mime_fromqp((unsigned char *) (buf + off),
1198                                                   &fbufp,
1199                                                   &fbuf[MAXLINE] - fbufp);
1200                                 goto again;
1201                         }
1202                 }
1203         }
1204
1205         /* force out partial last line */
1206         if (fbufp > fbuf)
1207         {
1208                 *fbufp = '\0';
1209                 if (!putxline((char *) fbuf, fbufp - fbuf, mci, pxflags))
1210                         goto writeerr;
1211         }
1212
1213         /*
1214         **  The decoded text may end without an EOL.  Since this function
1215         **  is only called for text/plain MIME messages, it is safe to
1216         **  add an extra one at the end just in case.  This is a hack,
1217         **  but so is auto-converting MIME in the first place.
1218         */
1219
1220         if (!putline("", mci))
1221                 goto writeerr;
1222
1223         if (tTd(43, 3))
1224                 sm_dprintf("\t\t\tmime7to8 => %s to 8bit done\n", cte);
1225         return true;
1226
1227   writeerr:
1228         return false;
1229 }
1230 /*
1231 **  The following is based on Borenstein's "codes.c" module, with simplifying
1232 **  changes as we do not deal with multipart, and to do the translation in-core,
1233 **  with an attempt to prevent overrun of output buffers.
1234 **
1235 **  What is needed here are changes to defend this code better against
1236 **  bad encodings. Questionable to always return 0xFF for bad mappings.
1237 */
1238
1239 static char index_hex[128] =
1240 {
1241         -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1242         -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1243         -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1244         0, 1, 2, 3,  4, 5, 6, 7,  8, 9,-1,-1, -1,-1,-1,-1,
1245         -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1246         -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1247         -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1248         -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1
1249 };
1250
1251 # define HEXCHAR(c)  (((c) < 0 || (c) > 127) ? -1 : index_hex[(c)])
1252
1253 /*
1254 **  MIME_FROMQP -- decode quoted printable string
1255 **
1256 **      Parameters:
1257 **              infile -- input (encoded) string
1258 **              outfile -- output string
1259 **              maxlen -- size of output buffer
1260 **
1261 **      Returns:
1262 **              -2 if decoding failure
1263 **              -1 if infile completely decoded into outfile
1264 **              >= 0 is the position in infile decoding
1265 **                      reached before maxlen was reached
1266 */
1267
1268 static int
1269 mime_fromqp(infile, outfile, maxlen)
1270         unsigned char *infile;
1271         unsigned char **outfile;
1272         int maxlen;             /* Max # of chars allowed in outfile */
1273 {
1274         int c1, c2;
1275         int nchar = 0;
1276         unsigned char *b;
1277
1278         /* decrement by one for trailing '\0', at least one other char */
1279         if (--maxlen < 1)
1280                 return 0;
1281
1282         b = infile;
1283         while ((c1 = *infile++) != '\0' && nchar < maxlen)
1284         {
1285                 if (c1 == '=')
1286                 {
1287                         if ((c1 = *infile++) == '\0')
1288                                 break;
1289
1290                         if (c1 == '\n' || (c1 = HEXCHAR(c1)) == -1)
1291                         {
1292                                 /* ignore it and the rest of the buffer */
1293                                 return -2;
1294                         }
1295                         else
1296                         {
1297                                 do
1298                                 {
1299                                         if ((c2 = *infile++) == '\0')
1300                                         {
1301                                                 c2 = -1;
1302                                                 break;
1303                                         }
1304                                 } while ((c2 = HEXCHAR(c2)) == -1);
1305
1306                                 if (c2 == -1)
1307                                         break;
1308                                 nchar++;
1309                                 *(*outfile)++ = c1 << 4 | c2;
1310                         }
1311                 }
1312                 else
1313                 {
1314                         nchar++;
1315                         *(*outfile)++ = c1;
1316                         if (c1 == '\n')
1317                                 break;
1318                 }
1319         }
1320         *(*outfile)++ = '\0';
1321         if (nchar >= maxlen)
1322                 return (infile - b - 1);
1323         return -1;
1324 }
1325 #endif /* MIME7TO8 */