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.146 2006/08/16 16:52: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 bt = mimeboundary(buf, boundaries); 529 if (bt != MBT_NOTSEP) 530 break; 531 if (!putline(buf, mci)) 532 goto writeerr; 533 } 534 if (sm_io_eof(e->e_dfp)) 535 bt = MBT_FINAL; 536 } 537 else if (!MapNLtoCRLF || 538 (sectionsize / 8 < sectionhighbits && !use_qp)) 539 { 540 /* use base64 encoding */ 541 int c1, c2; 542 543 if (tTd(43, 36)) 544 sm_dprintf(" ...Content-Transfer-Encoding: base64\n"); 545 if (!putline("Content-Transfer-Encoding: base64", mci)) 546 goto writeerr; 547 (void) sm_snprintf(buf, sizeof(buf), 548 "X-MIME-Autoconverted: from 8bit to base64 by %s id %s", 549 MyHostName, e->e_id); 550 if (!putline(buf, mci) || !putline("", mci)) 551 goto writeerr; 552 mci->mci_flags &= ~MCIF_INHEADER; 553 while ((c1 = mime_getchar_crlf(e->e_dfp, boundaries, &bt)) != 554 SM_IO_EOF) 555 { 556 if (linelen > 71) 557 { 558 *bp = '\0'; 559 if (!putline(buf, mci)) 560 goto writeerr; 561 linelen = 0; 562 bp = buf; 563 } 564 linelen += 4; 565 *bp++ = Base64Code[(c1 >> 2)]; 566 c1 = (c1 & 0x03) << 4; 567 c2 = mime_getchar_crlf(e->e_dfp, boundaries, &bt); 568 if (c2 == SM_IO_EOF) 569 { 570 *bp++ = Base64Code[c1]; 571 *bp++ = '='; 572 *bp++ = '='; 573 break; 574 } 575 c1 |= (c2 >> 4) & 0x0f; 576 *bp++ = Base64Code[c1]; 577 c1 = (c2 & 0x0f) << 2; 578 c2 = mime_getchar_crlf(e->e_dfp, boundaries, &bt); 579 if (c2 == SM_IO_EOF) 580 { 581 *bp++ = Base64Code[c1]; 582 *bp++ = '='; 583 break; 584 } 585 c1 |= (c2 >> 6) & 0x03; 586 *bp++ = Base64Code[c1]; 587 *bp++ = Base64Code[c2 & 0x3f]; 588 } 589 *bp = '\0'; 590 if (!putline(buf, mci)) 591 goto writeerr; 592 } 593 else 594 { 595 /* use quoted-printable encoding */ 596 int c1, c2; 597 int fromstate; 598 BITMAP256 badchars; 599 600 /* set up map of characters that must be mapped */ 601 clrbitmap(badchars); 602 for (c1 = 0x00; c1 < 0x20; c1++) 603 setbitn(c1, badchars); 604 clrbitn('\t', badchars); 605 for (c1 = 0x7f; c1 < 0x100; c1++) 606 setbitn(c1, badchars); 607 setbitn('=', badchars); 608 if (bitnset(M_EBCDIC, mci->mci_mailer->m_flags)) 609 for (p = "!\"#$@[\\]^`{|}~"; *p != '\0'; p++) 610 setbitn(*p, badchars); 611 612 if (tTd(43, 36)) 613 sm_dprintf(" ...Content-Transfer-Encoding: quoted-printable\n"); 614 if (!putline("Content-Transfer-Encoding: quoted-printable", 615 mci)) 616 goto writeerr; 617 (void) sm_snprintf(buf, sizeof(buf), 618 "X-MIME-Autoconverted: from 8bit to quoted-printable by %s id %s", 619 MyHostName, e->e_id); 620 if (!putline(buf, mci) || !putline("", mci)) 621 goto writeerr; 622 mci->mci_flags &= ~MCIF_INHEADER; 623 fromstate = 0; 624 c2 = '\n'; 625 while ((c1 = mime_getchar(e->e_dfp, boundaries, &bt)) != 626 SM_IO_EOF) 627 { 628 if (c1 == '\n') 629 { 630 if (c2 == ' ' || c2 == '\t') 631 { 632 *bp++ = '='; 633 *bp++ = Base16Code[(c2 >> 4) & 0x0f]; 634 *bp++ = Base16Code[c2 & 0x0f]; 635 } 636 if (buf[0] == '.' && bp == &buf[1]) 637 { 638 buf[0] = '='; 639 *bp++ = Base16Code[('.' >> 4) & 0x0f]; 640 *bp++ = Base16Code['.' & 0x0f]; 641 } 642 *bp = '\0'; 643 if (!putline(buf, mci)) 644 goto writeerr; 645 linelen = fromstate = 0; 646 bp = buf; 647 c2 = c1; 648 continue; 649 } 650 if (c2 == ' ' && linelen == 4 && fromstate == 4 && 651 bitnset(M_ESCFROM, mci->mci_mailer->m_flags)) 652 { 653 *bp++ = '='; 654 *bp++ = '2'; 655 *bp++ = '0'; 656 linelen += 3; 657 } 658 else if (c2 == ' ' || c2 == '\t') 659 { 660 *bp++ = c2; 661 linelen++; 662 } 663 if (linelen > 72 && 664 (linelen > 75 || c1 != '.' || 665 (linelen > 73 && c2 == '.'))) 666 { 667 if (linelen > 73 && c2 == '.') 668 bp--; 669 else 670 c2 = '\n'; 671 *bp++ = '='; 672 *bp = '\0'; 673 if (!putline(buf, mci)) 674 goto writeerr; 675 linelen = fromstate = 0; 676 bp = buf; 677 if (c2 == '.') 678 { 679 *bp++ = '.'; 680 linelen++; 681 } 682 } 683 if (bitnset(bitidx(c1), badchars)) 684 { 685 *bp++ = '='; 686 *bp++ = Base16Code[(c1 >> 4) & 0x0f]; 687 *bp++ = Base16Code[c1 & 0x0f]; 688 linelen += 3; 689 } 690 else if (c1 != ' ' && c1 != '\t') 691 { 692 if (linelen < 4 && c1 == "From"[linelen]) 693 fromstate++; 694 *bp++ = c1; 695 linelen++; 696 } 697 c2 = c1; 698 } 699 700 /* output any saved character */ 701 if (c2 == ' ' || c2 == '\t') 702 { 703 *bp++ = '='; 704 *bp++ = Base16Code[(c2 >> 4) & 0x0f]; 705 *bp++ = Base16Code[c2 & 0x0f]; 706 linelen += 3; 707 } 708 709 if (linelen > 0 || boundaries[0] != NULL) 710 { 711 *bp = '\0'; 712 if (!putline(buf, mci)) 713 goto writeerr; 714 } 715 716 } 717 if (tTd(43, 3)) 718 sm_dprintf("\t\t\tmime8to7=>%s (basic)\n", MimeBoundaryNames[bt]); 719 return bt; 720 721 writeerr: 722 return SM_IO_EOF; 723 } 724 /* 725 ** MIME_GETCHAR -- get a character for MIME processing 726 ** 727 ** Treats boundaries as SM_IO_EOF. 728 ** 729 ** Parameters: 730 ** fp -- the input file. 731 ** boundaries -- the current MIME boundaries. 732 ** btp -- if the return value is SM_IO_EOF, *btp is set to 733 ** the type of the boundary. 734 ** 735 ** Returns: 736 ** The next character in the input stream. 737 */ 738 739 static int 740 mime_getchar(fp, boundaries, btp) 741 register SM_FILE_T *fp; 742 char **boundaries; 743 int *btp; 744 { 745 int c; 746 static unsigned char *bp = NULL; 747 static int buflen = 0; 748 static bool atbol = true; /* at beginning of line */ 749 static int bt = MBT_SYNTAX; /* boundary type of next SM_IO_EOF */ 750 static unsigned char buf[128]; /* need not be a full line */ 751 int start = 0; /* indicates position of - in buffer */ 752 753 if (buflen == 1 && *bp == '\n') 754 { 755 /* last \n in buffer may be part of next MIME boundary */ 756 c = *bp; 757 } 758 else if (buflen > 0) 759 { 760 buflen--; 761 return *bp++; 762 } 763 else 764 c = sm_io_getc(fp, SM_TIME_DEFAULT); 765 bp = buf; 766 buflen = 0; 767 if (c == '\n') 768 { 769 /* might be part of a MIME boundary */ 770 *bp++ = c; 771 atbol = true; 772 c = sm_io_getc(fp, SM_TIME_DEFAULT); 773 if (c == '\n') 774 { 775 (void) sm_io_ungetc(fp, SM_TIME_DEFAULT, c); 776 return c; 777 } 778 start = 1; 779 } 780 if (c != SM_IO_EOF) 781 *bp++ = c; 782 else 783 bt = MBT_FINAL; 784 if (atbol && c == '-') 785 { 786 /* check for a message boundary */ 787 c = sm_io_getc(fp, SM_TIME_DEFAULT); 788 if (c != '-') 789 { 790 if (c != SM_IO_EOF) 791 *bp++ = c; 792 else 793 bt = MBT_FINAL; 794 buflen = bp - buf - 1; 795 bp = buf; 796 return *bp++; 797 } 798 799 /* got "--", now check for rest of separator */ 800 *bp++ = '-'; 801 while (bp < &buf[sizeof(buf) - 2] && 802 (c = sm_io_getc(fp, SM_TIME_DEFAULT)) != SM_IO_EOF && 803 c != '\n') 804 { 805 *bp++ = c; 806 } 807 *bp = '\0'; /* XXX simply cut off? */ 808 bt = mimeboundary((char *) &buf[start], boundaries); 809 switch (bt) 810 { 811 case MBT_FINAL: 812 case MBT_INTERMED: 813 /* we have a message boundary */ 814 buflen = 0; 815 *btp = bt; 816 return SM_IO_EOF; 817 } 818 819 if (bp < &buf[sizeof(buf) - 2] && c != SM_IO_EOF) 820 *bp++ = c; 821 } 822 823 atbol = c == '\n'; 824 buflen = bp - buf - 1; 825 if (buflen < 0) 826 { 827 *btp = bt; 828 return SM_IO_EOF; 829 } 830 bp = buf; 831 return *bp++; 832 } 833 /* 834 ** MIME_GETCHAR_CRLF -- do mime_getchar, but translate NL => CRLF 835 ** 836 ** Parameters: 837 ** fp -- the input file. 838 ** boundaries -- the current MIME boundaries. 839 ** btp -- if the return value is SM_IO_EOF, *btp is set to 840 ** the type of the boundary. 841 ** 842 ** Returns: 843 ** The next character in the input stream. 844 */ 845 846 static int 847 mime_getchar_crlf(fp, boundaries, btp) 848 register SM_FILE_T *fp; 849 char **boundaries; 850 int *btp; 851 { 852 static bool sendlf = false; 853 int c; 854 855 if (sendlf) 856 { 857 sendlf = false; 858 return '\n'; 859 } 860 c = mime_getchar(fp, boundaries, btp); 861 if (c == '\n' && MapNLtoCRLF) 862 { 863 sendlf = true; 864 return '\r'; 865 } 866 return c; 867 } 868 /* 869 ** MIMEBOUNDARY -- determine if this line is a MIME boundary & its type 870 ** 871 ** Parameters: 872 ** line -- the input line. 873 ** boundaries -- the set of currently pending boundaries. 874 ** 875 ** Returns: 876 ** MBT_NOTSEP -- if this is not a separator line 877 ** MBT_INTERMED -- if this is an intermediate separator 878 ** MBT_FINAL -- if this is a final boundary 879 ** MBT_SYNTAX -- if this is a boundary for the wrong 880 ** enclosure -- i.e., a syntax error. 881 */ 882 883 static int 884 mimeboundary(line, boundaries) 885 register char *line; 886 char **boundaries; 887 { 888 int type = MBT_NOTSEP; 889 int i; 890 int savec; 891 892 if (line[0] != '-' || line[1] != '-' || boundaries == NULL) 893 return MBT_NOTSEP; 894 i = strlen(line); 895 if (i > 0 && line[i - 1] == '\n') 896 i--; 897 898 /* strip off trailing whitespace */ 899 while (i > 0 && (line[i - 1] == ' ' || line[i - 1] == '\t' 900 #if _FFR_MIME_CR_OK 901 || line[i - 1] == '\r' 902 #endif /* _FFR_MIME_CR_OK */ 903 )) 904 i--; 905 savec = line[i]; 906 line[i] = '\0'; 907 908 if (tTd(43, 5)) 909 sm_dprintf("mimeboundary: line=\"%s\"... ", line); 910 911 /* check for this as an intermediate boundary */ 912 if (isboundary(&line[2], boundaries) >= 0) 913 type = MBT_INTERMED; 914 else if (i > 2 && strncmp(&line[i - 2], "--", 2) == 0) 915 { 916 /* check for a final boundary */ 917 line[i - 2] = '\0'; 918 if (isboundary(&line[2], boundaries) >= 0) 919 type = MBT_FINAL; 920 line[i - 2] = '-'; 921 } 922 923 line[i] = savec; 924 if (tTd(43, 5)) 925 sm_dprintf("%s\n", MimeBoundaryNames[type]); 926 return type; 927 } 928 /* 929 ** DEFCHARSET -- return default character set for message 930 ** 931 ** The first choice for character set is for the mailer 932 ** corresponding to the envelope sender. If neither that 933 ** nor the global configuration file has a default character 934 ** set defined, return "unknown-8bit" as recommended by 935 ** RFC 1428 section 3. 936 ** 937 ** Parameters: 938 ** e -- the envelope for this message. 939 ** 940 ** Returns: 941 ** The default character set for that mailer. 942 */ 943 944 char * 945 defcharset(e) 946 register ENVELOPE *e; 947 { 948 if (e != NULL && e->e_from.q_mailer != NULL && 949 e->e_from.q_mailer->m_defcharset != NULL) 950 return e->e_from.q_mailer->m_defcharset; 951 if (DefaultCharSet != NULL) 952 return DefaultCharSet; 953 return "unknown-8bit"; 954 } 955 /* 956 ** ISBOUNDARY -- is a given string a currently valid boundary? 957 ** 958 ** Parameters: 959 ** line -- the current input line. 960 ** boundaries -- the list of valid boundaries. 961 ** 962 ** Returns: 963 ** The index number in boundaries if the line is found. 964 ** -1 -- otherwise. 965 ** 966 */ 967 968 static int 969 isboundary(line, boundaries) 970 char *line; 971 char **boundaries; 972 { 973 register int i; 974 975 for (i = 0; i <= MAXMIMENESTING && boundaries[i] != NULL; i++) 976 { 977 if (strcmp(line, boundaries[i]) == 0) 978 return i; 979 } 980 return -1; 981 } 982 #endif /* MIME8TO7 */ 983 984 #if MIME7TO8 985 static int mime_fromqp __P((unsigned char *, unsigned char **, int)); 986 987 /* 988 ** MIME7TO8 -- output 7 bit encoded MIME body in 8 bit format 989 ** 990 ** This is a hack. Supports translating the two 7-bit body-encodings 991 ** (quoted-printable and base64) to 8-bit coded bodies. 992 ** 993 ** There is not much point in supporting multipart here, as the UA 994 ** will be able to deal with encoded MIME bodies if it can parse MIME 995 ** multipart messages. 996 ** 997 ** Note also that we won't be called unless it is a text/plain MIME 998 ** message, encoded base64 or QP and mailer flag '9' has been defined 999 ** on mailer. 1000 ** 1001 ** Contributed by Marius Olaffson <marius@rhi.hi.is>. 1002 ** 1003 ** Parameters: 1004 ** mci -- mailer connection information. 1005 ** header -- the header for this body part. 1006 ** e -- envelope. 1007 ** 1008 ** Returns: 1009 ** true iff body was written successfully 1010 */ 1011 1012 static char index_64[128] = 1013 { 1014 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, 1015 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, 1016 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63, 1017 52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,-1,-1,-1, 1018 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14, 1019 15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1, 1020 -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40, 1021 41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1 1022 }; 1023 1024 # define CHAR64(c) (((c) < 0 || (c) > 127) ? -1 : index_64[(c)]) 1025 1026 bool 1027 mime7to8(mci, header, e) 1028 register MCI *mci; 1029 HDR *header; 1030 register ENVELOPE *e; 1031 { 1032 int pxflags; 1033 register char *p; 1034 char *cte; 1035 char **pvp; 1036 unsigned char *fbufp; 1037 char buf[MAXLINE]; 1038 unsigned char fbuf[MAXLINE + 1]; 1039 char pvpbuf[MAXLINE]; 1040 extern unsigned char MimeTokenTab[256]; 1041 1042 p = hvalue("Content-Transfer-Encoding", header); 1043 if (p == NULL || 1044 (pvp = prescan(p, '\0', pvpbuf, sizeof(pvpbuf), NULL, 1045 MimeTokenTab, false)) == NULL || 1046 pvp[0] == NULL) 1047 { 1048 /* "can't happen" -- upper level should have caught this */ 1049 syserr("mime7to8: unparsable CTE %s", p == NULL ? "<NULL>" : p); 1050 1051 /* avoid bounce loops */ 1052 e->e_flags |= EF_DONT_MIME; 1053 1054 /* cheap failsafe algorithm -- should work on text/plain */ 1055 if (p != NULL) 1056 { 1057 (void) sm_snprintf(buf, sizeof(buf), 1058 "Content-Transfer-Encoding: %s", p); 1059 if (!putline(buf, mci)) 1060 goto writeerr; 1061 } 1062 if (!putline("", mci)) 1063 goto writeerr; 1064 mci->mci_flags &= ~MCIF_INHEADER; 1065 while (sm_io_fgets(e->e_dfp, SM_TIME_DEFAULT, buf, sizeof(buf)) 1066 != NULL) 1067 { 1068 if (!putline(buf, mci)) 1069 goto writeerr; 1070 } 1071 return true; 1072 } 1073 cataddr(pvp, NULL, buf, sizeof(buf), '\0', false); 1074 cte = sm_rpool_strdup_x(e->e_rpool, buf); 1075 1076 mci->mci_flags |= MCIF_INHEADER; 1077 if (!putline("Content-Transfer-Encoding: 8bit", mci)) 1078 goto writeerr; 1079 (void) sm_snprintf(buf, sizeof(buf), 1080 "X-MIME-Autoconverted: from %.200s to 8bit by %s id %s", 1081 cte, MyHostName, e->e_id); 1082 if (!putline(buf, mci) || !putline("", mci)) 1083 goto writeerr; 1084 mci->mci_flags &= ~MCIF_INHEADER; 1085 1086 /* 1087 ** Translate body encoding to 8-bit. Supports two types of 1088 ** encodings; "base64" and "quoted-printable". Assume qp if 1089 ** it is not base64. 1090 */ 1091 1092 pxflags = PXLF_MAPFROM; 1093 if (sm_strcasecmp(cte, "base64") == 0) 1094 { 1095 int c1, c2, c3, c4; 1096 1097 fbufp = fbuf; 1098 while ((c1 = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT)) != 1099 SM_IO_EOF) 1100 { 1101 if (isascii(c1) && isspace(c1)) 1102 continue; 1103 1104 do 1105 { 1106 c2 = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT); 1107 } while (isascii(c2) && isspace(c2)); 1108 if (c2 == SM_IO_EOF) 1109 break; 1110 1111 do 1112 { 1113 c3 = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT); 1114 } while (isascii(c3) && isspace(c3)); 1115 if (c3 == SM_IO_EOF) 1116 break; 1117 1118 do 1119 { 1120 c4 = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT); 1121 } while (isascii(c4) && isspace(c4)); 1122 if (c4 == SM_IO_EOF) 1123 break; 1124 1125 if (c1 == '=' || c2 == '=') 1126 continue; 1127 c1 = CHAR64(c1); 1128 c2 = CHAR64(c2); 1129 1130 #if MIME7TO8_OLD 1131 #define CHK_EOL if (*--fbufp != '\n' || (fbufp > fbuf && *--fbufp != '\r')) \ 1132 ++fbufp; 1133 #else /* MIME7TO8_OLD */ 1134 #define CHK_EOL if (*--fbufp != '\n' || (fbufp > fbuf && *--fbufp != '\r')) \ 1135 { \ 1136 ++fbufp; \ 1137 pxflags |= PXLF_NOADDEOL; \ 1138 } 1139 #endif /* MIME7TO8_OLD */ 1140 1141 #define PUTLINE64 \ 1142 do \ 1143 { \ 1144 if (*fbufp++ == '\n' || fbufp >= &fbuf[MAXLINE]) \ 1145 { \ 1146 CHK_EOL; \ 1147 if (!putxline((char *) fbuf, fbufp - fbuf, mci, pxflags)) \ 1148 goto writeerr; \ 1149 pxflags &= ~PXLF_NOADDEOL; \ 1150 fbufp = fbuf; \ 1151 } \ 1152 } while (0) 1153 1154 *fbufp = (c1 << 2) | ((c2 & 0x30) >> 4); 1155 PUTLINE64; 1156 if (c3 == '=') 1157 continue; 1158 c3 = CHAR64(c3); 1159 *fbufp = ((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2); 1160 PUTLINE64; 1161 if (c4 == '=') 1162 continue; 1163 c4 = CHAR64(c4); 1164 *fbufp = ((c3 & 0x03) << 6) | c4; 1165 PUTLINE64; 1166 } 1167 } 1168 else 1169 { 1170 int off; 1171 1172 /* quoted-printable */ 1173 pxflags |= PXLF_NOADDEOL; 1174 fbufp = fbuf; 1175 while (sm_io_fgets(e->e_dfp, SM_TIME_DEFAULT, buf, 1176 sizeof(buf)) != NULL) 1177 { 1178 off = mime_fromqp((unsigned char *) buf, &fbufp, 1179 &fbuf[MAXLINE] - fbufp); 1180 again: 1181 if (off < -1) 1182 continue; 1183 1184 if (fbufp - fbuf > 0) 1185 { 1186 if (!putxline((char *) fbuf, fbufp - fbuf - 1, 1187 mci, pxflags)) 1188 goto writeerr; 1189 } 1190 fbufp = fbuf; 1191 if (off >= 0 && buf[off] != '\0') 1192 { 1193 off = mime_fromqp((unsigned char *) (buf + off), 1194 &fbufp, 1195 &fbuf[MAXLINE] - fbufp); 1196 goto again; 1197 } 1198 } 1199 } 1200 1201 /* force out partial last line */ 1202 if (fbufp > fbuf) 1203 { 1204 *fbufp = '\0'; 1205 if (!putxline((char *) fbuf, fbufp - fbuf, mci, pxflags)) 1206 goto writeerr; 1207 } 1208 1209 /* 1210 ** The decoded text may end without an EOL. Since this function 1211 ** is only called for text/plain MIME messages, it is safe to 1212 ** add an extra one at the end just in case. This is a hack, 1213 ** but so is auto-converting MIME in the first place. 1214 */ 1215 1216 if (!putline("", mci)) 1217 goto writeerr; 1218 1219 if (tTd(43, 3)) 1220 sm_dprintf("\t\t\tmime7to8 => %s to 8bit done\n", cte); 1221 return true; 1222 1223 writeerr: 1224 return false; 1225 } 1226 /* 1227 ** The following is based on Borenstein's "codes.c" module, with simplifying 1228 ** changes as we do not deal with multipart, and to do the translation in-core, 1229 ** with an attempt to prevent overrun of output buffers. 1230 ** 1231 ** What is needed here are changes to defend this code better against 1232 ** bad encodings. Questionable to always return 0xFF for bad mappings. 1233 */ 1234 1235 static char index_hex[128] = 1236 { 1237 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, 1238 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, 1239 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, 1240 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1, -1,-1,-1,-1, 1241 -1,10,11,12, 13,14,15,-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,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1, 1244 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1 1245 }; 1246 1247 # define HEXCHAR(c) (((c) < 0 || (c) > 127) ? -1 : index_hex[(c)]) 1248 1249 /* 1250 ** MIME_FROMQP -- decode quoted printable string 1251 ** 1252 ** Parameters: 1253 ** infile -- input (encoded) string 1254 ** outfile -- output string 1255 ** maxlen -- size of output buffer 1256 ** 1257 ** Returns: 1258 ** -2 if decoding failure 1259 ** -1 if infile completely decoded into outfile 1260 ** >= 0 is the position in infile decoding 1261 ** reached before maxlen was reached 1262 */ 1263 1264 static int 1265 mime_fromqp(infile, outfile, maxlen) 1266 unsigned char *infile; 1267 unsigned char **outfile; 1268 int maxlen; /* Max # of chars allowed in outfile */ 1269 { 1270 int c1, c2; 1271 int nchar = 0; 1272 unsigned char *b; 1273 1274 /* decrement by one for trailing '\0', at least one other char */ 1275 if (--maxlen < 1) 1276 return 0; 1277 1278 b = infile; 1279 while ((c1 = *infile++) != '\0' && nchar < maxlen) 1280 { 1281 if (c1 == '=') 1282 { 1283 if ((c1 = *infile++) == '\0') 1284 break; 1285 1286 if (c1 == '\n' || (c1 = HEXCHAR(c1)) == -1) 1287 { 1288 /* ignore it and the rest of the buffer */ 1289 return -2; 1290 } 1291 else 1292 { 1293 do 1294 { 1295 if ((c2 = *infile++) == '\0') 1296 { 1297 c2 = -1; 1298 break; 1299 } 1300 } while ((c2 = HEXCHAR(c2)) == -1); 1301 1302 if (c2 == -1) 1303 break; 1304 nchar++; 1305 *(*outfile)++ = c1 << 4 | c2; 1306 } 1307 } 1308 else 1309 { 1310 nchar++; 1311 *(*outfile)++ = c1; 1312 if (c1 == '\n') 1313 break; 1314 } 1315 } 1316 *(*outfile)++ = '\0'; 1317 if (nchar >= maxlen) 1318 return (infile - b - 1); 1319 return -1; 1320 } 1321 #endif /* MIME7TO8 */ 1322