开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email客户端 > 查看源码
headers.c
资源名称：sendmail.8.10.0.Beta10.tar.Z　[点击查看]
上传用户：xu_441
上传日期：2007-01-04
资源大小：1640k
文件大小：37k
源码类别：

Email客户端

开发平台：

Unix_Linux

headers.c：源码内容
  1. /*
  2.  * Copyright (c) 1998, 1999 Sendmail, Inc. and its suppliers.
  3.  * All rights reserved.
  4.  * Copyright (c) 1983, 1995-1997 Eric P. Allman.  All rights reserved.
  5.  * Copyright (c) 1988, 1993
  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.  */
  14. #ifndef lint
  15. static char id[] = "@(#)$Id: headers.c,v 8.196 1999/12/07 00:00:37 gshapiro Exp $";
  16. #endif /* ! lint */
  18. #include <sendmail.h>
  20. static bool fix_mime_header __P((char *));
  21. static int priencode __P((char *));
  22. static void put_vanilla_header __P((HDR *, char *, MCI *));
  24. /*
  25. **  SETUPHEADERS -- initialize headers in symbol table
  26. **
  27. ** Parameters:
  28. ** none
  29. **
  30. ** Returns:
  31. ** none
  32. */
  34. void
  35. setupheaders()
  36. {
  37. struct hdrinfo *hi;
  38. STAB *s;
  40. for (hi = HdrInfo; hi->hi_field != NULL; hi++)
  41. {
  42. s = stab(hi->hi_field, ST_HEADER, ST_ENTER);
  43. s->s_header.hi_flags = hi->hi_flags;
  44. s->s_header.hi_ruleset = NULL;
  45. }
  46. }
  47. /*
  48. **  CHOMPHEADER -- process and save a header line.
  49. **
  50. ** Called by collect, readcf, and readqf to deal with header lines.
  51. **
  52. ** Parameters:
  53. ** line -- header as a text line.
  54. ** pflag -- flags:
  55. ** CHHDR_DEF: this is a default value.
  56. ** CHHDR_CHECK: call rulesets.
  57. ** hdrp -- a pointer to the place to save the header.
  58. ** e -- the envelope including this header.
  59. **
  60. ** Returns:
  61. ** flags for this header.
  62. **
  63. ** Side Effects:
  64. ** The header is saved on the header list.
  65. ** Contents of 'line' are destroyed.
  66. */
  68. static struct hdrinfo NormalHeader = { NULL, 0, NULL };
  70. u_long
  71. chompheader(line, pflag, hdrp, e)
  72. char *line;
  73. int *pflag;
  74. HDR **hdrp;
  75. register ENVELOPE *e;
  76. {
  77. u_char mid = '';
  78. register char *p;
  79. register HDR *h;
  80. HDR **hp;
  81. char *fname;
  82. char *fvalue;
  83. bool cond = FALSE;
  84. bool headeronly;
  85. STAB *s;
  86. struct hdrinfo *hi;
  87. bool nullheader = FALSE;
  88. BITMAP256 mopts;
  90. if (tTd(31, 6))
  91. {
  92. dprintf("chompheader: ");
  93. xputs(line);
  94. dprintf("n");
  95. }
  97. headeronly = hdrp != NULL;
  98. if (!headeronly)
  99. hdrp = &e->e_header;
  101. /* strip off options */
  102. clrbitmap(mopts);
  103. p = line;
  104. if (*p == '?')
  105. {
  106. /* have some */
  107. register char *q = strchr(p + 1, *p);
  109. if (q != NULL)
  110. {
  111. *q++ = '';
  112. while (*++p != '')
  113. setbitn(*p, mopts);
  114. p = q;
  115. }
  116. else
  117. syserr("553 5.3.0 header syntax error, line "%s"",
  118.        line);
  119. cond = TRUE;
  120. }
  121. else if (!isascii(*p) || *p == '$')
  122. {
  123. int c;
  125. /* possibly macro conditional */
  126. c = *p & 0377;
  127. if (c == MACROEXPAND)
  128. {
  129. p++;
  130. mid = (u_char) *p++;
  131. }
  132. else if (c == '$')
  133. {
  134. p++;
  135. mid = (u_char)macid(p, NULL);
  136. if (bitset(0200, mid))
  137. p += strlen(macname(mid)) + 2;
  138. else
  139. p++;
  140. }
  141. }
  143. /* find canonical name */
  144. fname = p;
  145. while (isascii(*p) && isgraph(*p) && *p != ':')
  146. p++;
  147. fvalue = p;
  148. while (isascii(*p) && isspace(*p))
  149. p++;
  150. if (*p++ != ':' || fname == fvalue)
  151. {
  152. syserr("553 5.3.0 header syntax error, line "%s"", line);
  153. return 0;
  154. }
  155. *fvalue = '';
  157. /* strip field value on front */
  158. if (*p == ' ')
  159. p++;
  160. fvalue = p;
  162. /* if the field is null, go ahead and use the default */
  163. while (isascii(*p) && isspace(*p))
  164. p++;
  165. if (*p == '')
  166. nullheader = TRUE;
  168. /* security scan: long field names are end-of-header */
  169. if (strlen(fname) > 100)
  170. return H_EOH;
  172. /* check to see if it represents a ruleset call */
  173. if (bitset(*pflag, CHHDR_DEF))
  174. {
  175. char hbuf[50];
  177. (void) expand(fvalue, hbuf, sizeof hbuf, e);
  178. for (p = hbuf; isascii(*p) && isspace(*p); )
  179. p++;
  180. if ((*p++ & 0377) == CALLSUBR)
  181. {
  182. auto char *endp;
  183. bool strc;
  185. strc = *p == '+'; /* strip comments? */
  186. if (strc)
  187. ++p;
  188. if (strtorwset(p, &endp, ST_ENTER) > 0)
  189. {
  190. *endp = '';
  191. s = stab(fname, ST_HEADER, ST_ENTER);
  192. s->s_header.hi_ruleset = newstr(p);
  193. if (!strc)
  194. s->s_header.hi_flags |= H_STRIPCOMM;
  195. }
  196. return 0;
  197. }
  198. }
  200. /* see if it is a known type */
  201. s = stab(fname, ST_HEADER, ST_FIND);
  202. if (s != NULL)
  203. hi = &s->s_header;
  204. else
  205. hi = &NormalHeader;
  207. if (tTd(31, 9))
  208. {
  209. if (s == NULL)
  210. dprintf("no header flags matchn");
  211. else
  212. dprintf("header match, flags=%lx, ruleset=%sn",
  213. hi->hi_flags,
  214. hi->hi_ruleset == NULL ? "<NULL>" : hi->hi_ruleset);
  215. }
  217. /* see if this is a resent message */
  218. if (!bitset(*pflag, CHHDR_DEF) && !headeronly &&
  219.     bitset(H_RESENT, hi->hi_flags))
  220. e->e_flags |= EF_RESENT;
  222. /* if this is an Errors-To: header keep track of it now */
  223. if (UseErrorsTo && !bitset(*pflag, CHHDR_DEF) && !headeronly &&
  224.     bitset(H_ERRORSTO, hi->hi_flags))
  225. (void) sendtolist(fvalue, NULLADDR, &e->e_errorqueue, 0, e);
  227. /* if this means "end of header" quit now */
  228. if (!headeronly && bitset(H_EOH, hi->hi_flags))
  229. return hi->hi_flags;
  231. /*
  232. **  Horrible hack to work around problem with Lotus Notes SMTP
  233. **  mail gateway, which generates From: headers with newlines in
  234. **  them and the <address> on the second line.  Although this is
  235. **  legal RFC 822, many MUAs don't handle this properly and thus
  236. **  never find the actual address.
  237. */
  239. if (bitset(H_FROM, hi->hi_flags) && SingleLineFromHeader)
  240. {
  241. while ((p = strchr(fvalue, 'n')) != NULL)
  242. *p = ' ';
  243. }
  245. /*
  246. **  If there is a check ruleset, verify it against the header.
  247. */
  249. if (bitset(*pflag, CHHDR_CHECK))
  250. {
  251. bool stripcom = FALSE;
  252. char *rs;
  254. /* no ruleset? look for default */
  255. rs = hi->hi_ruleset;
  256. if (rs == NULL)
  257. {
  258. s = stab("*", ST_HEADER, ST_FIND);
  259. if (s != NULL)
  260. {
  261. rs = (&s->s_header)->hi_ruleset;
  262. stripcom = bitset((&s->s_header)->hi_flags,
  263.   H_STRIPCOMM);
  264. }
  265. }
  266. else
  267. stripcom = bitset(hi->hi_flags, H_STRIPCOMM);
  268. if (rs != NULL)
  269. {
  270. int l;
  271. char qval[MAXNAME];
  272. char hlen[16];
  273. char *sp, *dp;
  275. dp = qval;
  276. l = 0;
  277. dp[l++] = '"';
  278. for (sp = fvalue; *sp != '' && l < MAXNAME - 2; sp++)
  279. {
  280. switch(*sp)
  281. {
  282.   case '11': /* ht */
  283.   case '12': /* nl */
  284.   case '13': /* vt */
  285.   case '14': /* np */
  286.   case '15': /* cr */
  287. dp[l++] = ' ';
  288. break;
  289.   case '"':
  290. dp[l++] = '\';
  291. /* FALLTHROUGH */
  292.   default:
  293. dp[l++] = *sp;
  294. break;
  295. }
  296. }
  297. dp[l++] = '"';
  298. dp[l++] = '';
  299. l = strlen(fvalue);
  300. snprintf(hlen, sizeof hlen, "%d", l);
  301. define(macid("{hdrlen}", NULL), newstr(hlen), e);
  302. if (l >= MAXNAME)
  303. {
  304. if (LogLevel > 9)
  305. sm_syslog(LOG_WARNING, e->e_id,
  306.   "Warning: truncated header '%s' before check with '%s' len=%d max=%d",
  307.   fname, rs, l, MAXNAME);
  308. }
  309. if ((sp = macvalue(macid("{currHeader}", NULL), e)) !=
  310.     NULL)
  311. free(sp);
  312. define(macid("{currHeader}", NULL), newstr(qval), e);
  313. define(macid("{hdr_name}", NULL), newstr(fname), e);
  314. (void) rscheck(rs, fvalue, NULL, e, stripcom, TRUE);
  315. }
  316. }
  319. /*
  320. **  Drop explicit From: if same as what we would generate.
  321. **  This is to make MH (which doesn't always give a full name)
  322. **  insert the full name information in all circumstances.
  323. */
  325. p = "resent-from";
  326. if (!bitset(EF_RESENT, e->e_flags))
  327. p += 7;
  328. if (!bitset(*pflag, CHHDR_DEF) && !headeronly &&
  329.     !bitset(EF_QUEUERUN, e->e_flags) && strcasecmp(fname, p) == 0)
  330. {
  331. if (tTd(31, 2))
  332. {
  333. dprintf("comparing header from (%s) against default (%s or %s)n",
  334. fvalue, e->e_from.q_paddr, e->e_from.q_user);
  335. }
  336. if (e->e_from.q_paddr != NULL &&
  337.     e->e_from.q_mailer != NULL &&
  338.     bitnset(M_LOCALMAILER, e->e_from.q_mailer->m_flags) &&
  339.     (strcmp(fvalue, e->e_from.q_paddr) == 0 ||
  340.      strcmp(fvalue, e->e_from.q_user) == 0))
  341. return hi->hi_flags;
  342. }
  344. /* delete default value for this header */
  345. for (hp = hdrp; (h = *hp) != NULL; hp = &h->h_link)
  346. {
  347. if (strcasecmp(fname, h->h_field) == 0 &&
  348.     bitset(H_DEFAULT, h->h_flags) &&
  349.     !bitset(H_FORCE, h->h_flags))
  350. {
  351. if (nullheader)
  352. {
  353. /* user-supplied value was null */
  354. return 0;
  355. }
  356. h->h_value = NULL;
  357. if (!cond)
  358. {
  359. /* copy conditions from default case */
  360. memmove((char *)mopts, (char *)h->h_mflags,
  361. sizeof mopts);
  362. }
  363. h->h_macro = mid;
  364. }
  365. }
  367. /* create a new node */
  368. h = (HDR *) xalloc(sizeof *h);
  369. h->h_field = newstr(fname);
  370. h->h_value = newstr(fvalue);
  371. h->h_link = NULL;
  372. memmove((char *) h->h_mflags, (char *) mopts, sizeof mopts);
  373. h->h_macro = mid;
  374. *hp = h;
  375. h->h_flags = hi->hi_flags;
  377. /* strip EOH flag if parsing MIME headers */
  378. if (headeronly)
  379. h->h_flags &= ~H_EOH;
  380. if (bitset(*pflag, CHHDR_DEF))
  381. h->h_flags |= H_DEFAULT;
  382. if (cond || mid != '')
  383. h->h_flags |= H_CHECK;
  385. /* hack to see if this is a new format message */
  386. if (!bitset(*pflag, CHHDR_DEF) && !headeronly &&
  387.     bitset(H_RCPT|H_FROM, h->h_flags) &&
  388.     (strchr(fvalue, ',') != NULL || strchr(fvalue, '(') != NULL ||
  389.      strchr(fvalue, '<') != NULL || strchr(fvalue, ';') != NULL))
  390. {
  391. e->e_flags &= ~EF_OLDSTYLE;
  392. }
  394. return h->h_flags;
  395. }
  396. /*
  397. **  ADDHEADER -- add a header entry to the end of the queue.
  398. **
  399. ** This bypasses the special checking of chompheader.
  400. **
  401. ** Parameters:
  402. ** field -- the name of the header field.
  403. ** value -- the value of the field.
  404. ** hdrlist -- an indirect pointer to the header structure list.
  405. **
  406. ** Returns:
  407. ** none.
  408. **
  409. ** Side Effects:
  410. ** adds the field on the list of headers for this envelope.
  411. */
  413. void
  414. addheader(field, value, hdrlist)
  415. char *field;
  416. char *value;
  417. HDR **hdrlist;
  418. {
  419. register HDR *h;
  420. STAB *s;
  421. HDR **hp;
  423. /* find info struct */
  424. s = stab(field, ST_HEADER, ST_FIND);
  426. /* find current place in list -- keep back pointer? */
  427. for (hp = hdrlist; (h = *hp) != NULL; hp = &h->h_link)
  428. {
  429. if (strcasecmp(field, h->h_field) == 0)
  430. break;
  431. }
  433. /* allocate space for new header */
  434. h = (HDR *) xalloc(sizeof *h);
  435. h->h_field = field;
  436. h->h_value = newstr(value);
  437. h->h_link = *hp;
  438. h->h_flags = H_DEFAULT;
  439. if (s != NULL)
  440. h->h_flags |= s->s_header.hi_flags;
  441. clrbitmap(h->h_mflags);
  442. h->h_macro = '';
  443. *hp = h;
  444. }
  445. /*
  446. **  HVALUE -- return value of a header.
  447. **
  448. ** Only "real" fields (i.e., ones that have not been supplied
  449. ** as a default) are used.
  450. **
  451. ** Parameters:
  452. ** field -- the field name.
  453. ** header -- the header list.
  454. **
  455. ** Returns:
  456. ** pointer to the value part.
  457. ** NULL if not found.
  458. **
  459. ** Side Effects:
  460. ** none.
  461. */
  463. char *
  464. hvalue(field, header)
  465. char *field;
  466. HDR *header;
  467. {
  468. register HDR *h;
  470. for (h = header; h != NULL; h = h->h_link)
  471. {
  472. if (!bitset(H_DEFAULT, h->h_flags) &&
  473.     strcasecmp(h->h_field, field) == 0)
  474. return h->h_value;
  475. }
  476. return NULL;
  477. }
  478. /*
  479. **  ISHEADER -- predicate telling if argument is a header.
  480. **
  481. ** A line is a header if it has a single word followed by
  482. ** optional white space followed by a colon.
  483. **
  484. ** Header fields beginning with two dashes, although technically
  485. ** permitted by RFC822, are automatically rejected in order
  486. ** to make MIME work out.  Without this we could have a technically
  487. ** legal header such as ``--"foo:bar"'' that would also be a legal
  488. ** MIME separator.
  489. **
  490. ** Parameters:
  491. ** h -- string to check for possible headerness.
  492. **
  493. ** Returns:
  494. ** TRUE if h is a header.
  495. ** FALSE otherwise.
  496. **
  497. ** Side Effects:
  498. ** none.
  499. */
  501. bool
  502. isheader(h)
  503. char *h;
  504. {
  505. register char *s = h;
  507. if (s[0] == '-' && s[1] == '-')
  508. return FALSE;
  510. while (*s > ' ' && *s != ':' && *s != '')
  511. s++;
  513. if (h == s)
  514. return FALSE;
  516. /* following technically violates RFC822 */
  517. while (isascii(*s) && isspace(*s))
  518. s++;
  520. return (*s == ':');
  521. }
  522. /*
  523. **  EATHEADER -- run through the stored header and extract info.
  524. **
  525. ** Parameters:
  526. ** e -- the envelope to process.
  527. ** full -- if set, do full processing (e.g., compute
  528. ** message priority).  This should not be set
  529. ** when reading a queue file because some info
  530. ** needed to compute the priority is wrong.
  531. **
  532. ** Returns:
  533. ** none.
  534. **
  535. ** Side Effects:
  536. ** Sets a bunch of global variables from information
  537. ** in the collected header.
  538. ** Aborts the message if the hop count is exceeded.
  539. */
  541. void
  542. eatheader(e, full)
  543. register ENVELOPE *e;
  544. bool full;
  545. {
  546. register HDR *h;
  547. register char *p;
  548. int hopcnt = 0;
  549. char *msgid;
  550. char buf[MAXLINE];
  552. /*
  553. **  Set up macros for possible expansion in headers.
  554. */
  556. define('f', e->e_sender, e);
  557. define('g', e->e_sender, e);
  558. if (e->e_origrcpt != NULL && *e->e_origrcpt != '')
  559. define('u', e->e_origrcpt, e);
  560. else
  561. define('u', NULL, e);
  563. /* full name of from person */
  564. p = hvalue("full-name", e->e_header);
  565. if (p != NULL)
  566. {
  567. if (!rfc822_string(p))
  568. {
  569. /*
  570. **  Quote a full name with special characters
  571. **  as a comment so crackaddr() doesn't destroy
  572. **  the name portion of the address.
  573. */
  574. p = addquotes(p);
  575. }
  576. define('x', p, e);
  577. }
  579. if (tTd(32, 1))
  580. dprintf("----- collected header -----n");
  581. msgid = NULL;
  582. for (h = e->e_header; h != NULL; h = h->h_link)
  583. {
  584. if (tTd(32, 1))
  585. dprintf("%s: ", h->h_field);
  586. if (h->h_value == NULL)
  587. {
  588. if (tTd(32, 1))
  589. dprintf("<NULL>n");
  590. continue;
  591. }
  593. /* do early binding */
  594. if (bitset(H_DEFAULT, h->h_flags) &&
  595.     !bitset(H_BINDLATE, h->h_flags))
  596. {
  597. if (tTd(32, 1))
  598. {
  599. dprintf("(");
  600. xputs(h->h_value);
  601. dprintf(") ");
  602. }
  603. expand(h->h_value, buf, sizeof buf, e);
  604. if (buf[0] != '')
  605. {
  606. if (bitset(H_FROM, h->h_flags))
  607. expand(crackaddr(buf), buf, sizeof buf, e);
  608. h->h_value = newstr(buf);
  609. h->h_flags &= ~H_DEFAULT;
  610. }
  611. }
  613. if (tTd(32, 1))
  614. {
  615. xputs(h->h_value);
  616. dprintf("n");
  617. }
  619. /* count the number of times it has been processed */
  620. if (bitset(H_TRACE, h->h_flags))
  621. hopcnt++;
  623. /* send to this person if we so desire */
  624. if (GrabTo && bitset(H_RCPT, h->h_flags) &&
  625.     !bitset(H_DEFAULT, h->h_flags) &&
  626.     (!bitset(EF_RESENT, e->e_flags) || bitset(H_RESENT, h->h_flags)))
  627. {
  628. #if 0
  629. int saveflags = e->e_flags;
  630. #endif /* 0 */
  632. (void) sendtolist(h->h_value, NULLADDR,
  633.   &e->e_sendqueue, 0, e);
  635. #if 0
  636. /*
  637. **  Change functionality so a fatal error on an
  638. **  address doesn't affect the entire envelope.
  639. */
  641. /* delete fatal errors generated by this address */
  642. if (!bitset(EF_FATALERRS, saveflags))
  643. e->e_flags &= ~EF_FATALERRS;
  644. #endif /* 0 */
  645. }
  647. /* save the message-id for logging */
  648. p = "resent-message-id";
  649. if (!bitset(EF_RESENT, e->e_flags))
  650. p += 7;
  651. if (strcasecmp(h->h_field, p) == 0)
  652. {
  653. msgid = h->h_value;
  654. while (isascii(*msgid) && isspace(*msgid))
  655. msgid++;
  656. }
  657. }
  658. if (tTd(32, 1))
  659. dprintf("----------------------------n");
  661. /* if we are just verifying (that is, sendmail -t -bv), drop out now */
  662. if (OpMode == MD_VERIFY)
  663. return;
  665. /* store hop count */
  666. if (hopcnt > e->e_hopcount)
  667. e->e_hopcount = hopcnt;
  669. /* message priority */
  670. p = hvalue("precedence", e->e_header);
  671. if (p != NULL)
  672. e->e_class = priencode(p);
  673. if (e->e_class < 0)
  674. e->e_timeoutclass = TOC_NONURGENT;
  675. else if (e->e_class > 0)
  676. e->e_timeoutclass = TOC_URGENT;
  677. if (full)
  678. {
  679. e->e_msgpriority = e->e_msgsize
  680.  - e->e_class * WkClassFact
  681.  + e->e_nrcpts * WkRecipFact;
  682. }
  684. /* message timeout priority */
  685. p = hvalue("priority", e->e_header);
  686. if (p != NULL)
  687. {
  688. /* (this should be in the configuration file) */
  689. if (strcasecmp(p, "urgent") == 0)
  690. e->e_timeoutclass = TOC_URGENT;
  691. else if (strcasecmp(p, "normal") == 0)
  692. e->e_timeoutclass = TOC_NORMAL;
  693. else if (strcasecmp(p, "non-urgent") == 0)
  694. e->e_timeoutclass = TOC_NONURGENT;
  695. }
  697. /* date message originated */
  698. p = hvalue("posted-date", e->e_header);
  699. if (p == NULL)
  700. p = hvalue("date", e->e_header);
  701. if (p != NULL)
  702. define('a', p, e);
  704. /* check to see if this is a MIME message */
  705. if ((e->e_bodytype != NULL &&
  706.      strcasecmp(e->e_bodytype, "8BITMIME") == 0) ||
  707.     hvalue("MIME-Version", e->e_header) != NULL)
  708. {
  709. e->e_flags |= EF_IS_MIME;
  710. if (HasEightBits)
  711. e->e_bodytype = "8BITMIME";
  712. }
  713. else if ((p = hvalue("Content-Type", e->e_header)) != NULL)
  714. {
  715. /* this may be an RFC 1049 message */
  716. p = strpbrk(p, ";/");
  717. if (p == NULL || *p == ';')
  718. {
  719. /* yep, it is */
  720. e->e_flags |= EF_DONT_MIME;
  721. }
  722. }
  724. /*
  725. **  From person in antiquated ARPANET mode
  726. ** required by UK Grey Book e-mail gateways (sigh)
  727. */
  729. if (OpMode == MD_ARPAFTP)
  730. {
  731. register struct hdrinfo *hi;
  733. for (hi = HdrInfo; hi->hi_field != NULL; hi++)
  734. {
  735. if (bitset(H_FROM, hi->hi_flags) &&
  736.     (!bitset(H_RESENT, hi->hi_flags) ||
  737.      bitset(EF_RESENT, e->e_flags)) &&
  738.     (p = hvalue(hi->hi_field, e->e_header)) != NULL)
  739. break;
  740. }
  741. if (hi->hi_field != NULL)
  742. {
  743. if (tTd(32, 2))
  744. dprintf("eatheader: setsender(*%s == %s)n",
  745. hi->hi_field, p);
  746. setsender(p, e, NULL, '', TRUE);
  747. }
  748. }
  750. /*
  751. **  Log collection information.
  752. */
  754. if (bitset(EF_LOGSENDER, e->e_flags) && LogLevel > 4)
  755. logsender(e, msgid);
  756. e->e_flags &= ~EF_LOGSENDER;
  757. }
  758. /*
  759. **  LOGSENDER -- log sender information
  760. **
  761. ** Parameters:
  762. ** e -- the envelope to log
  763. ** msgid -- the message id
  764. **
  765. ** Returns:
  766. ** none
  767. */
  769. void
  770. logsender(e, msgid)
  771. register ENVELOPE *e;
  772. char *msgid;
  773. {
  774. char *name;
  775. register char *sbp;
  776. register char *p;
  777. int l;
  778. char hbuf[MAXNAME + 1];
  779. char sbuf[MAXLINE + 1];
  780. char mbuf[MAXNAME + 1];
  782. /* don't allow newlines in the message-id */
  783. if (msgid != NULL)
  784. {
  785. l = strlen(msgid);
  786. if (l > sizeof mbuf - 1)
  787. l = sizeof mbuf - 1;
  788. memmove(mbuf, msgid, l);
  789. mbuf[l] = '';
  790. p = mbuf;
  791. while ((p = strchr(p, 'n')) != NULL)
  792. *p++ = ' ';
  793. }
  795. if (bitset(EF_RESPONSE, e->e_flags))
  796. name = "[RESPONSE]";
  797. else if ((name = macvalue('_', e)) != NULL)
  798. /* EMPTY */
  799. ;
  800. else if (RealHostName == NULL)
  801. name = "localhost";
  802. else if (RealHostName[0] == '[')
  803. name = RealHostName;
  804. else
  805. {
  806. name = hbuf;
  807. (void) snprintf(hbuf, sizeof hbuf, "%.80s", RealHostName);
  808. if (RealHostAddr.sa.sa_family != 0)
  809. {
  810. p = &hbuf[strlen(hbuf)];
  811. (void) snprintf(p, SPACELEFT(hbuf, p), " (%.100s)",
  812. anynet_ntoa(&RealHostAddr));
  813. }
  814. }
  816. /* some versions of syslog only take 5 printf args */
  817. #if (SYSLOG_BUFSIZE) >= 256
  818. sbp = sbuf;
  819. snprintf(sbp, SPACELEFT(sbuf, sbp),
  820.     "from=%.200s, size=%ld, class=%d, nrcpts=%d",
  821.     e->e_from.q_paddr == NULL ? "<NONE>" : e->e_from.q_paddr,
  822.     e->e_msgsize, e->e_class, e->e_nrcpts);
  823. sbp += strlen(sbp);
  824. if (msgid != NULL)
  825. {
  826. snprintf(sbp, SPACELEFT(sbuf, sbp), ", msgid=%.100s", mbuf);
  827. sbp += strlen(sbp);
  828. }
  829. if (e->e_bodytype != NULL)
  830. {
  831. (void) snprintf(sbp, SPACELEFT(sbuf, sbp), ", bodytype=%.20s",
  832. e->e_bodytype);
  833. sbp += strlen(sbp);
  834. }
  835. p = macvalue('r', e);
  836. if (p != NULL)
  837. {
  838. (void) snprintf(sbp, SPACELEFT(sbuf, sbp), ", proto=%.20s", p);
  839. sbp += strlen(sbp);
  840. }
  841. p = macvalue(macid("{daemon_name}", NULL), e);
  842. if (p != NULL)
  843. {
  844. (void) snprintf(sbp, SPACELEFT(sbuf, sbp), ", daemon=%.20s", p);
  845. sbp += strlen(sbp);
  846. }
  847. sm_syslog(LOG_INFO, e->e_id,
  848.   "%.850s, relay=%.100s",
  849.   sbuf, name);
  851. #else /* (SYSLOG_BUFSIZE) >= 256 */
  853. sm_syslog(LOG_INFO, e->e_id,
  854.   "from=%s",
  855.   e->e_from.q_paddr == NULL ? "<NONE>"
  856.     : shortenstring(e->e_from.q_paddr, 83));
  857. sm_syslog(LOG_INFO, e->e_id,
  858.   "size=%ld, class=%ld, nrcpts=%d",
  859.   e->e_msgsize, e->e_class, e->e_nrcpts);
  860. if (msgid != NULL)
  861. sm_syslog(LOG_INFO, e->e_id,
  862.   "msgid=%s",
  863.   shortenstring(mbuf, 83));
  864. sbp = sbuf;
  865. *sbp = '';
  866. if (e->e_bodytype != NULL)
  867. {
  868. snprintf(sbp, SPACELEFT(sbuf, sbp), "bodytype=%.20s, ", e->e_bodytype);
  869. sbp += strlen(sbp);
  870. }
  871. p = macvalue('r', e);
  872. if (p != NULL)
  873. {
  874. snprintf(sbp, SPACELEFT(sbuf, sbp), "proto=%.20s, ", p);
  875. sbp += strlen(sbp);
  876. }
  877. sm_syslog(LOG_INFO, e->e_id,
  878.   "%.400srelay=%.100s", sbuf, name);
  879. #endif /* (SYSLOG_BUFSIZE) >= 256 */
  880. }
  881. /*
  882. **  PRIENCODE -- encode external priority names into internal values.
  883. **
  884. ** Parameters:
  885. ** p -- priority in ascii.
  886. **
  887. ** Returns:
  888. ** priority as a numeric level.
  889. **
  890. ** Side Effects:
  891. ** none.
  892. */
  894. static int
  895. priencode(p)
  896. char *p;
  897. {
  898. register int i;
  900. for (i = 0; i < NumPriorities; i++)
  901. {
  902. if (!strcasecmp(p, Priorities[i].pri_name))
  903. return Priorities[i].pri_val;
  904. }
  906. /* unknown priority */
  907. return 0;
  908. }
  909. /*
  910. **  CRACKADDR -- parse an address and turn it into a macro
  911. **
  912. ** This doesn't actually parse the address -- it just extracts
  913. ** it and replaces it with "$g".  The parse is totally ad hoc
  914. ** and isn't even guaranteed to leave something syntactically
  915. ** identical to what it started with.  However, it does leave
  916. ** something semantically identical.
  917. **
  918. ** This algorithm has been cleaned up to handle a wider range
  919. ** of cases -- notably quoted and backslash escaped strings.
  920. ** This modification makes it substantially better at preserving
  921. ** the original syntax.
  922. **
  923. ** Parameters:
  924. ** addr -- the address to be cracked.
  925. **
  926. ** Returns:
  927. ** a pointer to the new version.
  928. **
  929. ** Side Effects:
  930. ** none.
  931. **
  932. ** Warning:
  933. ** The return value is saved in local storage and should
  934. ** be copied if it is to be reused.
  935. */
  937. char *
  938. crackaddr(addr)
  939. register char *addr;
  940. {
  941. register char *p;
  942. register char c;
  943. int cmtlev;
  944. int realcmtlev;
  945. int anglelev, realanglelev;
  946. int copylev;
  947. int bracklev;
  948. bool qmode;
  949. bool realqmode;
  950. bool skipping;
  951. bool putgmac = FALSE;
  952. bool quoteit = FALSE;
  953. bool gotangle = FALSE;
  954. bool gotcolon = FALSE;
  955. register char *bp;
  956. char *buflim;
  957. char *bufhead;
  958. char *addrhead;
  959. static char buf[MAXNAME + 1];
  961. if (tTd(33, 1))
  962. dprintf("crackaddr(%s)n", addr);
  964. /* strip leading spaces */
  965. while (*addr != '' && isascii(*addr) && isspace(*addr))
  966. addr++;
  968. /*
  969. **  Start by assuming we have no angle brackets.  This will be
  970. **  adjusted later if we find them.
  971. */
  973. bp = bufhead = buf;
  974. buflim = &buf[sizeof buf - 7];
  975. p = addrhead = addr;
  976. copylev = anglelev = realanglelev = cmtlev = realcmtlev = 0;
  977. bracklev = 0;
  978. qmode = realqmode = FALSE;
  980. while ((c = *p++) != '')
  981. {
  982. /*
  983. **  If the buffer is overful, go into a special "skipping"
  984. **  mode that tries to keep legal syntax but doesn't actually
  985. **  output things.
  986. */
  988. skipping = bp >= buflim;
  990. if (copylev > 0 && !skipping)
  991. *bp++ = c;
  993. /* check for backslash escapes */
  994. if (c == '\')
  995. {
  996. /* arrange to quote the address */
  997. if (cmtlev <= 0 && !qmode)
  998. quoteit = TRUE;
  1000. if ((c = *p++) == '')
  1001. {
  1002. /* too far */
  1003. p--;
  1004. goto putg;
  1005. }
  1006. if (copylev > 0 && !skipping)
  1007. *bp++ = c;
  1008. goto putg;
  1009. }
  1011. /* check for quoted strings */
  1012. if (c == '"' && cmtlev <= 0)
  1013. {
  1014. qmode = !qmode;
  1015. if (copylev > 0 && !skipping)
  1016. realqmode = !realqmode;
  1017. continue;
  1018. }
  1019. if (qmode)
  1020. goto putg;
  1022. /* check for comments */
  1023. if (c == '(')
  1024. {
  1025. cmtlev++;
  1027. /* allow space for closing paren */
  1028. if (!skipping)
  1029. {
  1030. buflim--;
  1031. realcmtlev++;
  1032. if (copylev++ <= 0)
  1033. {
  1034. if (bp != bufhead)
  1035. *bp++ = ' ';
  1036. *bp++ = c;
  1037. }
  1038. }
  1039. }
  1040. if (cmtlev > 0)
  1041. {
  1042. if (c == ')')
  1043. {
  1044. cmtlev--;
  1045. copylev--;
  1046. if (!skipping)
  1047. {
  1048. realcmtlev--;
  1049. buflim++;
  1050. }
  1051. }
  1052. continue;
  1053. }
  1054. else if (c == ')')
  1055. {
  1056. /* syntax error: unmatched ) */
  1057. if (copylev > 0 && !skipping)
  1058. bp--;
  1059. }
  1061. /* count nesting on [ ... ] (for IPv6 domain literals) */
  1062. if (c == '[')
  1063. bracklev++;
  1064. else if (c == ']')
  1065. bracklev--;
  1067. /* check for group: list; syntax */
  1068. if (c == ':' && anglelev <= 0 && bracklev <= 0 &&
  1069.     !gotcolon && !ColonOkInAddr)
  1070. {
  1071. register char *q;
  1073. /*
  1074. **  Check for DECnet phase IV ``::'' (host::user)
  1075. **  or **  DECnet phase V ``:.'' syntaxes.  The latter
  1076. **  covers ``user@DEC:.tay.myhost'' and
  1077. **  ``DEC:.tay.myhost::user'' syntaxes (bletch).
  1078. */
  1080. if (*p == ':' || *p == '.')
  1081. {
  1082. if (cmtlev <= 0 && !qmode)
  1083. quoteit = TRUE;
  1084. if (copylev > 0 && !skipping)
  1085. {
  1086. *bp++ = c;
  1087. *bp++ = *p;
  1088. }
  1089. p++;
  1090. goto putg;
  1091. }
  1093. gotcolon = TRUE;
  1095. bp = bufhead;
  1096. if (quoteit)
  1097. {
  1098. *bp++ = '"';
  1100. /* back up over the ':' and any spaces */
  1101. --p;
  1102. while (isascii(*--p) && isspace(*p))
  1103. continue;
  1104. p++;
  1105. }
  1106. for (q = addrhead; q < p; )
  1107. {
  1108. c = *q++;
  1109. if (bp < buflim)
  1110. {
  1111. if (quoteit && c == '"')
  1112. *bp++ = '\';
  1113. *bp++ = c;
  1114. }
  1115. }
  1116. if (quoteit)
  1117. {
  1118. if (bp == &bufhead[1])
  1119. bp--;
  1120. else
  1121. *bp++ = '"';
  1122. while ((c = *p++) != ':')
  1123. {
  1124. if (bp < buflim)
  1125. *bp++ = c;
  1126. }
  1127. *bp++ = c;
  1128. }
  1130. /* any trailing white space is part of group: */
  1131. while (isascii(*p) && isspace(*p) && bp < buflim)
  1132. *bp++ = *p++;
  1133. copylev = 0;
  1134. putgmac = quoteit = FALSE;
  1135. bufhead = bp;
  1136. addrhead = p;
  1137. continue;
  1138. }
  1140. if (c == ';' && copylev <= 0 && !ColonOkInAddr)
  1141. {
  1142. if (bp < buflim)
  1143. *bp++ = c;
  1144. }
  1146. /* check for characters that may have to be quoted */
  1147. if (strchr(MustQuoteChars, c) != NULL)
  1148. {
  1149. /*
  1150. **  If these occur as the phrase part of a <>
  1151. **  construct, but are not inside of () or already
  1152. **  quoted, they will have to be quoted.  Note that
  1153. **  now (but don't actually do the quoting).
  1154. */
  1156. if (cmtlev <= 0 && !qmode)
  1157. quoteit = TRUE;
  1158. }
  1160. /* check for angle brackets */
  1161. if (c == '<')
  1162. {
  1163. register char *q;
  1165. /* assume first of two angles is bogus */
  1166. if (gotangle)
  1167. quoteit = TRUE;
  1168. gotangle = TRUE;
  1170. /* oops -- have to change our mind */
  1171. anglelev = 1;
  1172. if (!skipping)
  1173. realanglelev = 1;
  1175. bp = bufhead;
  1176. if (quoteit)
  1177. {
  1178. *bp++ = '"';
  1180. /* back up over the '<' and any spaces */
  1181. --p;
  1182. while (isascii(*--p) && isspace(*p))
  1183. continue;
  1184. p++;
  1185. }
  1186. for (q = addrhead; q < p; )
  1187. {
  1188. c = *q++;
  1189. if (bp < buflim)
  1190. {
  1191. if (quoteit && c == '"')
  1192. *bp++ = '\';
  1193. *bp++ = c;
  1194. }
  1195. }
  1196. if (quoteit)
  1197. {
  1198. if (bp == &buf[1])
  1199. bp--;
  1200. else
  1201. *bp++ = '"';
  1202. while ((c = *p++) != '<')
  1203. {
  1204. if (bp < buflim)
  1205. *bp++ = c;
  1206. }
  1207. *bp++ = c;
  1208. }
  1209. copylev = 0;
  1210. putgmac = quoteit = FALSE;
  1211. continue;
  1212. }
  1214. if (c == '>')
  1215. {
  1216. if (anglelev > 0)
  1217. {
  1218. anglelev--;
  1219. if (!skipping)
  1220. {
  1221. realanglelev--;
  1222. buflim++;
  1223. }
  1224. }
  1225. else if (!skipping)
  1226. {
  1227. /* syntax error: unmatched > */
  1228. if (copylev > 0)
  1229. bp--;
  1230. quoteit = TRUE;
  1231. continue;
  1232. }
  1233. if (copylev++ <= 0)
  1234. *bp++ = c;
  1235. continue;
  1236. }
  1238. /* must be a real address character */
  1239. putg:
  1240. if (copylev <= 0 && !putgmac)
  1241. {
  1242. if (bp > bufhead && bp[-1] == ')')
  1243. *bp++ = ' ';
  1244. *bp++ = MACROEXPAND;
  1245. *bp++ = 'g';
  1246. putgmac = TRUE;
  1247. }
  1248. }
  1250. /* repair any syntactic damage */
  1251. if (realqmode)
  1252. *bp++ = '"';
  1253. while (realcmtlev-- > 0)
  1254. *bp++ = ')';
  1255. while (realanglelev-- > 0)
  1256. *bp++ = '>';
  1257. *bp++ = '';
  1259. if (tTd(33, 1))
  1260. {
  1261. dprintf("crackaddr=>`");
  1262. xputs(buf);
  1263. dprintf("'n");
  1264. }
  1266. return buf;
  1267. }
  1268. /*
  1269. **  PUTHEADER -- put the header part of a message from the in-core copy
  1270. **
  1271. ** Parameters:
  1272. ** mci -- the connection information.
  1273. ** hdr -- the header to put.
  1274. ** e -- envelope to use.
  1275. ** flags -- MIME conversion flags.
  1276. **
  1277. ** Returns:
  1278. ** none.
  1279. **
  1280. ** Side Effects:
  1281. ** none.
  1282. */
  1284. /*
  1285.  * Macro for fast max (not available in e.g. DG/UX, 386/ix).
  1286.  */
  1287. #ifndef MAX
  1288. # define MAX(a,b) (((a)>(b))?(a):(b))
  1289. #endif /* ! MAX */
  1291. void
  1292. putheader(mci, hdr, e, flags)
  1293. register MCI *mci;
  1294. HDR *hdr;
  1295. register ENVELOPE *e;
  1296. int flags;
  1297. {
  1298. register HDR *h;
  1299. char buf[MAX(MAXLINE,BUFSIZ)];
  1300. char obuf[MAXLINE];
  1302. if (tTd(34, 1))
  1303. dprintf("--- putheader, mailer = %s ---n",
  1304. mci->mci_mailer->m_name);
  1306. /*
  1307. **  If we're in MIME mode, we're not really in the header of the
  1308. **  message, just the header of one of the parts of the body of
  1309. **  the message.  Therefore MCIF_INHEADER should not be turned on.
  1310. */
  1312. if (!bitset(MCIF_INMIME, mci->mci_flags))
  1313. mci->mci_flags |= MCIF_INHEADER;
  1315. for (h = hdr; h != NULL; h = h->h_link)
  1316. {
  1317. register char *p = h->h_value;
  1319. if (tTd(34, 11))
  1320. {
  1321. dprintf("  %s: ", h->h_field);
  1322. xputs(p);
  1323. }
  1325. /* heuristic shortening of MIME fields to avoid MUA overflows */
  1326. if (MaxMimeFieldLength > 0 &&
  1327.     wordinclass(h->h_field,
  1328. macid("{checkMIMEFieldHeaders}", NULL)))
  1329. {
  1330. if (fix_mime_header(h->h_value))
  1331. {
  1332. sm_syslog(LOG_ALERT, e->e_id,
  1333.   "Truncated MIME %s header due to field size (possible attack)",
  1334.   h->h_field);
  1335. if (tTd(34, 11))
  1336. dprintf("  truncated MIME %s header due to field size (possible attack)n",
  1337. h->h_field);
  1338. }
  1339. }
  1341. if (MaxMimeHeaderLength > 0 &&
  1342.     wordinclass(h->h_field,
  1343. macid("{checkMIMETextHeaders}", NULL)))
  1344. {
  1345. if (strlen(h->h_value) > MaxMimeHeaderLength)
  1346. {
  1347. h->h_value[MaxMimeHeaderLength - 1] = '';
  1348. sm_syslog(LOG_ALERT, e->e_id,
  1349.   "Truncated long MIME %s header (possible attack)",
  1350.   h->h_field);
  1351. if (tTd(34, 11))
  1352. dprintf("  truncated long MIME %s header (possible attack)n",
  1353. h->h_field);
  1354. }
  1355. }
  1357. if (MaxMimeHeaderLength > 0 &&
  1358.     wordinclass(h->h_field,
  1359. macid("{checkMIMEHeaders}", NULL)))
  1360. {
  1361. if (shorten_rfc822_string(h->h_value, MaxMimeHeaderLength))
  1362. {
  1363. sm_syslog(LOG_ALERT, e->e_id,
  1364.   "Truncated long MIME %s header (possible attack)",
  1365.   h->h_field);
  1366. if (tTd(34, 11))
  1367. dprintf("  truncated long MIME %s header (possible attack)n",
  1368. h->h_field);
  1369. }
  1370. }
  1372. /*
  1373. **  Suppress Content-Transfer-Encoding: if we are MIMEing
  1374. **  and we are potentially converting from 8 bit to 7 bit
  1375. **  MIME.  If converting, add a new CTE header in
  1376. **  mime8to7().
  1377. */
  1378. if (bitset(H_CTE, h->h_flags) &&
  1379.     bitset(MCIF_CVT8TO7|MCIF_CVT7TO8|MCIF_INMIME,
  1380.    mci->mci_flags) &&
  1381.     !bitset(M87F_NO8TO7, flags))
  1382. {
  1383. if (tTd(34, 11))
  1384. dprintf(" (skipped (content-transfer-encoding))n");
  1385. continue;
  1386. }
  1388. if (bitset(MCIF_INMIME, mci->mci_flags))
  1389. {
  1390. if (tTd(34, 11))
  1391. dprintf("n");
  1392. put_vanilla_header(h, p, mci);
  1393. continue;
  1394. }
  1396. if (bitset(H_CHECK|H_ACHECK, h->h_flags) &&
  1397.     !bitintersect(h->h_mflags, mci->mci_mailer->m_flags) &&
  1398.     (h->h_macro == '' ||
  1399.      macvalue(h->h_macro & 0377, e) == NULL))
  1400. {
  1401. if (tTd(34, 11))
  1402. dprintf(" (skipped)n");
  1403. continue;
  1404. }
  1406. /* handle Resent-... headers specially */
  1407. if (bitset(H_RESENT, h->h_flags) && !bitset(EF_RESENT, e->e_flags))
  1408. {
  1409. if (tTd(34, 11))
  1410. dprintf(" (skipped (resent))n");
  1411. continue;
  1412. }
  1414. /* suppress return receipts if requested */
  1415. if (bitset(H_RECEIPTTO, h->h_flags) &&
  1416.     (RrtImpliesDsn || bitset(EF_NORECEIPT, e->e_flags)))
  1417. {
  1418. if (tTd(34, 11))
  1419. dprintf(" (skipped (receipt))n");
  1420. continue;
  1421. }
  1423. /* macro expand value if generated internally */
  1424. if (bitset(H_DEFAULT, h->h_flags) ||
  1425.     bitset(H_BINDLATE, h->h_flags))
  1426. {
  1427. expand(p, buf, sizeof buf, e);
  1428. p = buf;
  1429. if (*p == '')
  1430. {
  1431. if (tTd(34, 11))
  1432. dprintf(" (skipped -- null value)n");
  1433. continue;
  1434. }
  1435. }
  1437. if (bitset(H_BCC, h->h_flags))
  1438. {
  1439. /* Bcc: field -- either truncate or delete */
  1440. if (bitset(EF_DELETE_BCC, e->e_flags))
  1441. {
  1442. if (tTd(34, 11))
  1443. dprintf(" (skipped -- bcc)n");
  1444. }
  1445. else
  1446. {
  1447. /* no other recipient headers: truncate value */
  1448. (void) snprintf(obuf, sizeof obuf, "%s:",
  1449. h->h_field);
  1450. putline(obuf, mci);
  1451. }
  1452. continue;
  1453. }
  1455. if (tTd(34, 11))
  1456. dprintf("n");
  1458. if (bitset(H_FROM|H_RCPT, h->h_flags))
  1459. {
  1460. /* address field */
  1461. bool oldstyle = bitset(EF_OLDSTYLE, e->e_flags);
  1463. if (bitset(H_FROM, h->h_flags))
  1464. oldstyle = FALSE;
  1465. commaize(h, p, oldstyle, mci, e);
  1466. }
  1467. else
  1468. {
  1469. put_vanilla_header(h, p, mci);
  1470. }
  1471. }
  1473. /*
  1474. **  If we are converting this to a MIME message, add the
  1475. **  MIME headers (but not in MIME mode!).
  1476. */
  1478. #if MIME8TO7
  1479. if (bitset(MM_MIME8BIT, MimeMode) &&
  1480.     bitset(EF_HAS8BIT, e->e_flags) &&
  1481.     !bitset(EF_DONT_MIME, e->e_flags) &&
  1482.     !bitnset(M_8BITS, mci->mci_mailer->m_flags) &&
  1483.     !bitset(MCIF_CVT8TO7|MCIF_CVT7TO8|MCIF_INMIME, mci->mci_flags) &&
  1484.     hvalue("MIME-Version", e->e_header) == NULL)
  1485. {
  1486. putline("MIME-Version: 1.0", mci);
  1487. if (hvalue("Content-Type", e->e_header) == NULL)
  1488. {
  1489. snprintf(obuf, sizeof obuf,
  1490. "Content-Type: text/plain; charset=%s",
  1491. defcharset(e));
  1492. putline(obuf, mci);
  1493. }
  1494. if (hvalue("Content-Transfer-Encoding", e->e_header) == NULL)
  1495. putline("Content-Transfer-Encoding: 8bit", mci);
  1496. }
  1497. #endif /* MIME8TO7 */
  1498. }
  1499. /*
  1500. **  PUT_VANILLA_HEADER -- output a fairly ordinary header
  1501. **
  1502. ** Parameters:
  1503. ** h -- the structure describing this header
  1504. ** v -- the value of this header
  1505. ** mci -- the connection info for output
  1506. **
  1507. ** Returns:
  1508. ** none.
  1509. */
  1511. static void
  1512. put_vanilla_header(h, v, mci)
  1513. HDR *h;
  1514. char *v;
  1515. MCI *mci;
  1516. {
  1517. register char *nlp;
  1518. register char *obp;
  1519. int putflags;
  1520. char obuf[MAXLINE];
  1522. putflags = PXLF_HEADER;
  1523. if (bitnset(M_7BITHDRS, mci->mci_mailer->m_flags))
  1524. putflags |= PXLF_STRIP8BIT;
  1525. (void) snprintf(obuf, sizeof obuf, "%.200s: ", h->h_field);
  1526. obp = obuf + strlen(obuf);
  1527. while ((nlp = strchr(v, 'n')) != NULL)
  1528. {
  1529. int l;
  1531. l = nlp - v;
  1532. if (SPACELEFT(obuf, obp) - 1 < l)
  1533. l = SPACELEFT(obuf, obp) - 1;
  1535. snprintf(obp, SPACELEFT(obuf, obp), "%.*s", l, v);
  1536. putxline(obuf, strlen(obuf), mci, putflags);
  1537. v += l + 1;
  1538. obp = obuf;
  1539. if (*v != ' ' && *v != 't')
  1540. *obp++ = ' ';
  1541. }
  1542. snprintf(obp, SPACELEFT(obuf, obp), "%.*s",
  1543. (int) sizeof obuf - (obp - obuf) - 1, v);
  1544. putxline(obuf, strlen(obuf), mci, putflags);
  1545. }
  1546. /*
  1547. **  COMMAIZE -- output a header field, making a comma-translated list.
  1548. **
  1549. ** Parameters:
  1550. ** h -- the header field to output.
  1551. ** p -- the value to put in it.
  1552. ** oldstyle -- TRUE if this is an old style header.
  1553. ** mci -- the connection information.
  1554. ** e -- the envelope containing the message.
  1555. **
  1556. ** Returns:
  1557. ** none.
  1558. **
  1559. ** Side Effects:
  1560. ** outputs "p" to file "fp".
  1561. */
  1563. void
  1564. commaize(h, p, oldstyle, mci, e)
  1565. register HDR *h;
  1566. register char *p;
  1567. bool oldstyle;
  1568. register MCI *mci;
  1569. register ENVELOPE *e;
  1570. {
  1571. register char *obp;
  1572. int opos;
  1573. int omax;
  1574. bool firstone = TRUE;
  1575. int putflags = PXLF_HEADER;
  1576. char obuf[MAXLINE + 3];
  1578. /*
  1579. **  Output the address list translated by the
  1580. **  mailer and with commas.
  1581. */
  1583. if (tTd(14, 2))
  1584. dprintf("commaize(%s: %s)n", h->h_field, p);
  1586. if (bitnset(M_7BITHDRS, mci->mci_mailer->m_flags))
  1587. putflags |= PXLF_STRIP8BIT;
  1589. obp = obuf;
  1590. (void) snprintf(obp, SPACELEFT(obuf, obp), "%.200s: ", h->h_field);
  1591. opos = strlen(h->h_field) + 2;
  1592. if (opos > 202)
  1593. opos = 202;
  1594. obp += opos;
  1595. omax = mci->mci_mailer->m_linelimit - 2;
  1596. if (omax < 0 || omax > 78)
  1597. omax = 78;
  1599. /*
  1600. **  Run through the list of values.
  1601. */
  1603. while (*p != '')
  1604. {
  1605. register char *name;
  1606. register int c;
  1607. char savechar;
  1608. int flags;
  1609. auto int status;
  1611. /*
  1612. **  Find the end of the name.  New style names
  1613. **  end with a comma, old style names end with
  1614. **  a space character.  However, spaces do not
  1615. **  necessarily delimit an old-style name -- at
  1616. **  signs mean keep going.
  1617. */
  1619. /* find end of name */
  1620. while ((isascii(*p) && isspace(*p)) || *p == ',')
  1621. p++;
  1622. name = p;
  1623. for (;;)
  1624. {
  1625. auto char *oldp;
  1626. char pvpbuf[PSBUFSIZE];
  1628. (void) prescan(p, oldstyle ? ' ' : ',', pvpbuf,
  1629.        sizeof pvpbuf, &oldp, NULL);
  1630. p = oldp;
  1632. /* look to see if we have an at sign */
  1633. while (*p != '' && isascii(*p) && isspace(*p))
  1634. p++;
  1636. if (*p != '@')
  1637. {
  1638. p = oldp;
  1639. break;
  1640. }
  1641. p += *p == '@' ? 1 : 2;
  1642. while (*p != '' && isascii(*p) && isspace(*p))
  1643. p++;
  1644. }
  1645. /* at the end of one complete name */
  1647. /* strip off trailing white space */
  1648. while (p >= name &&
  1649.        ((isascii(*p) && isspace(*p)) || *p == ',' || *p == ''))
  1650. p--;
  1651. if (++p == name)
  1652. continue;
  1653. savechar = *p;
  1654. *p = '';
  1656. /* translate the name to be relative */
  1657. flags = RF_HEADERADDR|RF_ADDDOMAIN;
  1658. if (bitset(H_FROM, h->h_flags))
  1659. flags |= RF_SENDERADDR;
  1660. #if USERDB
  1661. else if (e->e_from.q_mailer != NULL &&
  1662.  bitnset(M_UDBRECIPIENT, e->e_from.q_mailer->m_flags))
  1663. {
  1664. char *q;
  1666. q = udbsender(name);
  1667. if (q != NULL)
  1668. name = q;
  1669. }
  1670. #endif /* USERDB */
  1671. status = EX_OK;
  1672. name = remotename(name, mci->mci_mailer, flags, &status, e);
  1673. if (*name == '')
  1674. {
  1675. *p = savechar;
  1676. continue;
  1677. }
  1678. name = denlstring(name, FALSE, TRUE);
  1680. /*
  1681. **  record data progress so DNS timeouts
  1682. **  don't cause DATA timeouts
  1683. */
  1685. DataProgress = TRUE;
  1687. /* output the name with nice formatting */
  1688. opos += strlen(name);
  1689. if (!firstone)
  1690. opos += 2;
  1691. if (opos > omax && !firstone)
  1692. {
  1693. snprintf(obp, SPACELEFT(obuf, obp), ",n");
  1694. putxline(obuf, strlen(obuf), mci, putflags);
  1695. obp = obuf;
  1696. (void) strlcpy(obp, "        ", sizeof obp);
  1697. opos = strlen(obp);
  1698. obp += opos;
  1699. opos += strlen(name);
  1700. }
  1701. else if (!firstone)
  1702. {
  1703. snprintf(obp, SPACELEFT(obuf, obp), ", ");
  1704. obp += 2;
  1705. }
  1707. while ((c = *name++) != '' && obp < &obuf[MAXLINE])
  1708. *obp++ = c;
  1709. firstone = FALSE;
  1710. *p = savechar;
  1711. }
  1712. *obp = '';
  1713. putxline(obuf, strlen(obuf), mci, putflags);
  1714. }
  1715. /*
  1716. **  COPYHEADER -- copy header list
  1717. **
  1718. ** This routine is the equivalent of newstr for header lists
  1719. **
  1720. ** Parameters:
  1721. ** header -- list of header structures to copy.
  1722. **
  1723. ** Returns:
  1724. ** a copy of 'header'.
  1725. **
  1726. ** Side Effects:
  1727. ** none.
  1728. */
  1730. HDR *
  1731. copyheader(header)
  1732. register HDR *header;
  1733. {
  1734. register HDR *newhdr;
  1735. HDR *ret;
  1736. register HDR **tail = &ret;
  1738. while (header != NULL)
  1739. {
  1740. newhdr = (HDR *) xalloc(sizeof *newhdr);
  1741. STRUCTCOPY(*header, *newhdr);
  1742. *tail = newhdr;
  1743. tail = &newhdr->h_link;
  1744. header = header->h_link;
  1745. }
  1746. *tail = NULL;
  1748. return ret;
  1749. }
  1750. /*
  1751. **  FIX_MIME_HEADER -- possibly truncate/rebalance parameters in a MIME header
  1752. **
  1753. ** Run through all of the parameters of a MIME header and
  1754. ** possibly truncate and rebalance the parameter according
  1755. ** to MaxMimeFieldLength.
  1756. **
  1757. ** Parameters:
  1758. ** string -- the full header
  1759. **
  1760. ** Returns:
  1761. ** TRUE if the header was modified, FALSE otherwise
  1762. **
  1763. ** Side Effects:
  1764. ** string modified in place
  1765. */
  1767. static bool
  1768. fix_mime_header(string)
  1769. char *string;
  1770. {
  1771. bool modified = FALSE;
  1772. char *begin = string;
  1773. char *end;
  1775. if (string == NULL || *string == '')
  1776. return FALSE;
  1778. /* Split on each ';' */
  1779. while ((end = find_character(begin, ';')) != NULL)
  1780. {
  1781. char save = *end;
  1782. char *bp;
  1784. *end = '';
  1786. /* Shorten individual parameter */
  1787. if (shorten_rfc822_string(begin, MaxMimeFieldLength))
  1788. modified = TRUE;
  1790. /* Collapse the possibly shortened string with rest */
  1791. bp = begin + strlen(begin);
  1792. if (bp != end)
  1793. {
  1794. char *ep = end;
  1796. *end = save;
  1797. end = bp;
  1799. /* copy character by character due to overlap */
  1800. while (*ep != '')
  1801. *bp++ = *ep++;
  1802. *bp = '';
  1803. }
  1804. else
  1805. *end = save;
  1806. if (*end == '')
  1807. break;
  1809. /* Move past ';' */
  1810. begin = end + 1;
  1811. }
  1812. return modified;
  1813. }