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

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

Email客户端

开发平台：

Unix_Linux

collect.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: collect.c,v 8.130 1999/12/06 21:48:49 ca Exp $";
  16. #endif /* ! lint */
  18. #include <sendmail.h>
  20. static void collecttimeout __P((time_t));
  21. static void dferror __P((FILE *volatile, char *, ENVELOPE *));
  22. static void eatfrom __P((char *volatile, ENVELOPE *));
  24. /*
  25. **  COLLECT -- read & parse message header & make temp file.
  26. **
  27. ** Creates a temporary file name and copies the standard
  28. ** input to that file.  Leading UNIX-style "From" lines are
  29. ** stripped off (after important information is extracted).
  30. **
  31. ** Parameters:
  32. ** fp -- file to read.
  33. ** smtpmode -- if set, we are running SMTP: give an RFC821
  34. ** style message to say we are ready to collect
  35. ** input, and never ignore a single dot to mean
  36. ** end of message.
  37. ** hdrp -- the location to stash the header.
  38. ** e -- the current envelope.
  39. **
  40. ** Returns:
  41. ** none.
  42. **
  43. ** Side Effects:
  44. ** Temp file is created and filled.
  45. ** The from person may be set.
  46. */
  48. static jmp_buf CtxCollectTimeout;
  49. static bool CollectProgress;
  50. static EVENT *CollectTimeout;
  52. /* values for input state machine */
  53. #define IS_NORM 0 /* middle of line */
  54. #define IS_BOL 1 /* beginning of line */
  55. #define IS_DOT 2 /* read a dot at beginning of line */
  56. #define IS_DOTCR 3 /* read ".r" at beginning of line */
  57. #define IS_CR 4 /* read a carriage return */
  59. /* values for message state machine */
  60. #define MS_UFROM 0 /* reading Unix from line */
  61. #define MS_HEADER 1 /* reading message header */
  62. #define MS_BODY 2 /* reading message body */
  63. #define MS_DISCARD 3 /* discarding rest of message */
  65. void
  66. collect(fp, smtpmode, hdrp, e)
  67. FILE *fp;
  68. bool smtpmode;
  69. HDR **hdrp;
  70. register ENVELOPE *e;
  71. {
  72. register FILE *volatile df;
  73. volatile bool ignrdot = smtpmode ? FALSE : IgnrDot;
  74. volatile time_t dbto = smtpmode ? TimeOuts.to_datablock : 0;
  75. register char *volatile bp;
  76. volatile int c = EOF;
  77. volatile bool inputerr = FALSE;
  78. bool headeronly;
  79. char *volatile buf;
  80. volatile int buflen;
  81. volatile int istate;
  82. volatile int mstate;
  83. volatile int hdrslen = 0;
  84. volatile int numhdrs = 0;
  85. volatile int dfd;
  86. volatile int afd;
  87. volatile int chompflags = CHHDR_CHECK;
  88. volatile int rstat = EX_OK;
  89. u_char *volatile pbp;
  90. u_char peekbuf[8];
  91. char hsize[16];
  92. char hnum[16];
  93. char dfname[MAXPATHLEN];
  94. char bufbuf[MAXLINE];
  96. headeronly = hdrp != NULL;
  98. /*
  99. **  Create the temp file name and create the file.
  100. */
  102. if (!headeronly)
  103. {
  104. struct stat stbuf;
  106. (void) strlcpy(dfname, queuename(e, 'd'), sizeof dfname);
  107. df = bfopen(dfname, FileMode, DataFileBufferSize, SFF_OPENASROOT);
  108. if (df == NULL)
  109. {
  110. syserr("Cannot create %s", dfname);
  111. e->e_flags |= EF_NO_BODY_RETN;
  112. finis(TRUE, ExitStat);
  113. /* NOTREACHED */
  114. }
  115. dfd = fileno(df);
  116. if (dfd < 0 || fstat(dfd, &stbuf) < 0)
  117. e->e_dfino = -1;
  118. else
  119. {
  120. e->e_dfdev = stbuf.st_dev;
  121. e->e_dfino = stbuf.st_ino;
  122. }
  123. HasEightBits = FALSE;
  124. e->e_msgsize = 0;
  125. e->e_flags |= EF_HAS_DF;
  126. }
  128. /*
  129. **  Tell ARPANET to go ahead.
  130. */
  132. if (smtpmode)
  133. message("354 Enter mail, end with "." on a line by itself");
  135. if (tTd(30, 2))
  136. dprintf("collectn");
  138. /*
  139. **  Read the message.
  140. **
  141. ** This is done using two interleaved state machines.
  142. ** The input state machine is looking for things like
  143. ** hidden dots; the message state machine is handling
  144. ** the larger picture (e.g., header versus body).
  145. */
  147. buf = bp = bufbuf;
  148. buflen = sizeof bufbuf;
  149. pbp = peekbuf;
  150. istate = IS_BOL;
  151. mstate = SaveFrom ? MS_HEADER : MS_UFROM;
  152. CollectProgress = FALSE;
  154. if (dbto != 0)
  155. {
  156. /* handle possible input timeout */
  157. if (setjmp(CtxCollectTimeout) != 0)
  158. {
  159. if (LogLevel > 2)
  160. sm_syslog(LOG_NOTICE, e->e_id,
  161.     "timeout waiting for input from %s during message collect",
  162.     CurHostName ? CurHostName : "<local machine>");
  163. errno = 0;
  164. usrerr("451 4.4.1 timeout waiting for input during message collect");
  165. goto readerr;
  166. }
  167. CollectTimeout = setevent(dbto, collecttimeout, dbto);
  168. }
  170. for (;;)
  171. {
  172. if (tTd(30, 35))
  173. dprintf("top, istate=%d, mstate=%dn", istate, mstate);
  174. for (;;)
  175. {
  176. if (pbp > peekbuf)
  177. c = *--pbp;
  178. else
  179. {
  180. while (!feof(fp) && !ferror(fp))
  181. {
  182. errno = 0;
  183. c = getc(fp);
  184. if (errno != EINTR)
  185. break;
  186. clearerr(fp);
  187. }
  188. CollectProgress = TRUE;
  189. if (TrafficLogFile != NULL && !headeronly)
  190. {
  191. if (istate == IS_BOL)
  192. (void) fprintf(TrafficLogFile, "%05d <<< ",
  193. (int) getpid());
  194. if (c == EOF)
  195. (void) fprintf(TrafficLogFile, "[EOF]n");
  196. else
  197. (void) putc(c, TrafficLogFile);
  198. }
  199. if (c == EOF)
  200. goto readerr;
  201. if (SevenBitInput)
  202. c &= 0x7f;
  203. else
  204. HasEightBits |= bitset(0x80, c);
  205. }
  206. if (tTd(30, 94))
  207. dprintf("istate=%d, c=%c (0x%x)n",
  208. istate, (char) c, c);
  209. switch (istate)
  210. {
  211.   case IS_BOL:
  212. if (c == '.')
  213. {
  214. istate = IS_DOT;
  215. continue;
  216. }
  217. break;
  219.   case IS_DOT:
  220. if (c == 'n' && !ignrdot &&
  221.     !bitset(EF_NL_NOT_EOL, e->e_flags))
  222. goto readerr;
  223. else if (c == 'r' &&
  224.  !bitset(EF_CRLF_NOT_EOL, e->e_flags))
  225. {
  226. istate = IS_DOTCR;
  227. continue;
  228. }
  229. else if (c != '.' ||
  230.  (OpMode != MD_SMTP &&
  231.   OpMode != MD_DAEMON &&
  232.   OpMode != MD_ARPAFTP))
  233. {
  234. *pbp++ = c;
  235. c = '.';
  236. }
  237. break;
  239.   case IS_DOTCR:
  240. if (c == 'n' && !ignrdot)
  241. goto readerr;
  242. else
  243. {
  244. /* push back the ".rx" */
  245. *pbp++ = c;
  246. *pbp++ = 'r';
  247. c = '.';
  248. }
  249. break;
  251.   case IS_CR:
  252. if (c == 'n')
  253. istate = IS_BOL;
  254. else
  255. {
  256. (void) ungetc(c, fp);
  257. c = 'r';
  258. istate = IS_NORM;
  259. }
  260. goto bufferchar;
  261. }
  263. if (c == 'r' && !bitset(EF_CRLF_NOT_EOL, e->e_flags))
  264. {
  265. istate = IS_CR;
  266. continue;
  267. }
  268. else if (c == 'n' && !bitset(EF_NL_NOT_EOL, e->e_flags))
  269. istate = IS_BOL;
  270. else
  271. istate = IS_NORM;
  273. bufferchar:
  274. if (!headeronly)
  275. e->e_msgsize++;
  276. switch (mstate)
  277. {
  278.   case MS_BODY:
  279. /* just put the character out */
  280. if (MaxMessageSize <= 0 ||
  281.     e->e_msgsize <= MaxMessageSize)
  282. (void) putc(c, df);
  284. /* FALLTHROUGH */
  286.   case MS_DISCARD:
  287. continue;
  288. }
  290. /* header -- buffer up */
  291. if (bp >= &buf[buflen - 2])
  292. {
  293. char *obuf;
  295. if (mstate != MS_HEADER)
  296. break;
  298. /* out of space for header */
  299. obuf = buf;
  300. if (buflen < MEMCHUNKSIZE)
  301. buflen *= 2;
  302. else
  303. buflen += MEMCHUNKSIZE;
  304. buf = xalloc(buflen);
  305. memmove(buf, obuf, bp - obuf);
  306. bp = &buf[bp - obuf];
  307. if (obuf != bufbuf)
  308. free(obuf);
  309. }
  310. if (c >= 0200 && c <= 0237)
  311. {
  312. #if 0 /* causes complaints -- figure out something for 8.11 */
  313. usrerr("Illegal character 0x%x in header", c);
  314. #else /* 0 */
  315. /* EMPTY */
  316. #endif /* 0 */
  317. }
  318. else if (c != '')
  319. {
  320. *bp++ = c;
  321. if (MaxHeadersLength > 0 &&
  322.     ++hdrslen > MaxHeadersLength)
  323. {
  324. sm_syslog(LOG_NOTICE, e->e_id,
  325.   "headers too large (%d max) from %s during message collect",
  326.   MaxHeadersLength,
  327.   CurHostName != NULL ? CurHostName : "localhost");
  328. errno = 0;
  329. e->e_flags |= EF_CLRQUEUE;
  330. e->e_status = "5.6.0";
  331. usrerrenh(e->e_status,
  332.   "552 Headers too large (%d max)",
  333.   MaxHeadersLength);
  334. mstate = MS_DISCARD;
  335. }
  336. }
  337. if (istate == IS_BOL)
  338. break;
  339. }
  340. *bp = '';
  342. nextstate:
  343. if (tTd(30, 35))
  344. dprintf("nextstate, istate=%d, mstate=%d, line = "%s"n",
  345. istate, mstate, buf);
  346. switch (mstate)
  347. {
  348.   case MS_UFROM:
  349. mstate = MS_HEADER;
  350. #ifndef NOTUNIX
  351. if (strncmp(buf, "From ", 5) == 0)
  352. {
  353. bp = buf;
  354. eatfrom(buf, e);
  355. continue;
  356. }
  357. #endif /* ! NOTUNIX */
  358. /* FALLTHROUGH */
  360.   case MS_HEADER:
  361. if (!isheader(buf))
  362. {
  363. mstate = MS_BODY;
  364. goto nextstate;
  365. }
  367. /* check for possible continuation line */
  368. do
  369. {
  370. clearerr(fp);
  371. errno = 0;
  372. c = getc(fp);
  373. } while (errno == EINTR);
  374. if (c != EOF)
  375. (void) ungetc(c, fp);
  376. if (c == ' ' || c == 't')
  377. {
  378. /* yep -- defer this */
  379. continue;
  380. }
  382. /* trim off trailing CRLF or NL */
  383. if (*--bp != 'n' || *--bp != 'r')
  384. bp++;
  385. *bp = '';
  388. if (bitset(H_EOH, chompheader(buf, (int *)&chompflags,
  389.       hdrp, e)))
  390. {
  391. mstate = MS_BODY;
  392. goto nextstate;
  393. }
  394. numhdrs++;
  395. break;
  397.   case MS_BODY:
  398. if (tTd(30, 1))
  399. dprintf("EOHn");
  401. if (headeronly)
  402. goto readerr;
  404. /* call the end-of-header check ruleset */
  405. snprintf(hnum, sizeof hnum, "%d", numhdrs);
  406. snprintf(hsize, sizeof hsize, "%d", hdrslen);
  407. if (tTd(30, 10))
  408. dprintf("collect: rscheck("check_eoh", "%s $| %s")n",
  409. hnum, hsize);
  410. rstat = rscheck("check_eoh", hnum, hsize, e, FALSE,
  411. TRUE);
  414. bp = buf;
  416. /* toss blank line */
  417. if ((!bitset(EF_CRLF_NOT_EOL, e->e_flags) &&
  418. bp[0] == 'r' && bp[1] == 'n') ||
  419.     (!bitset(EF_NL_NOT_EOL, e->e_flags) &&
  420. bp[0] == 'n'))
  421. {
  422. break;
  423. }
  425. /* if not a blank separator, write it out */
  426. if (MaxMessageSize <= 0 ||
  427.     e->e_msgsize <= MaxMessageSize)
  428. {
  429. while (*bp != '')
  430. (void) putc(*bp++, df);
  431. }
  432. break;
  433. }
  434. bp = buf;
  435. }
  437. readerr:
  438. if ((feof(fp) && smtpmode) || ferror(fp))
  439. {
  440. const char *errmsg = errstring(errno);
  442. if (tTd(30, 1))
  443. dprintf("collect: premature EOM: %sn", errmsg);
  444. if (LogLevel >= 2)
  445. sm_syslog(LOG_WARNING, e->e_id,
  446. "collect: premature EOM: %s", errmsg);
  447. inputerr = TRUE;
  448. }
  450. /* reset global timer */
  451. clrevent(CollectTimeout);
  453. if (headeronly)
  454. return;
  456. if (df == NULL)
  457. {
  458. /* skip next few clauses */
  459. /* EMPTY */
  460. }
  461. else if (fflush(df) != 0 || ferror(df))
  462. {
  463. dferror(df, "fflush||ferror", e);
  464. flush_errors(TRUE);
  465. finis(TRUE, ExitStat);
  466. /* NOTREACHED */
  467. }
  468. else if (!SuperSafe)
  469. {
  470. /* skip next few clauses */
  471. /* EMPTY */
  472. }
  473. else if ((afd = fileno(df)) >= 0 && fsync(afd) < 0)
  474. {
  475. dferror(df, "fsync", e);
  476. flush_errors(TRUE);
  477. finis(TRUE, ExitStat);
  478. /* NOTREACHED */
  479. }
  480. else if (bfcommit(df) < 0)
  481. {
  482. int save_errno = errno;
  484. if (save_errno == EEXIST)
  485. {
  486. char *dfile;
  487. struct stat st;
  489. dfile = queuename(e, 'd');
  490. if (stat(dfile, &st) < 0)
  491. st.st_size = -1;
  492. errno = EEXIST;
  493. syserr("collect: bfcommit(%s): already on disk, size = %ld",
  494.        dfile, st.st_size);
  495. dfd = fileno(df);
  496. if (dfd >= 0)
  497. dumpfd(dfd, TRUE, TRUE);
  498. }
  499. errno = save_errno;
  500. dferror(df, "bfcommit", e);
  501. flush_errors(TRUE);
  502. finis(save_errno != EEXIST, ExitStat);
  503. }
  504. else if (bfclose(df) < 0)
  505. {
  506. dferror(df, "bfclose", e);
  507. flush_errors(TRUE);
  508. finis(TRUE, ExitStat);
  509. /* NOTREACHED */
  510. }
  511. else
  512. {
  513. /* everything is happily flushed to disk */
  514. df = NULL;
  515. }
  517. /* An EOF when running SMTP is an error */
  518. if (inputerr && (OpMode == MD_SMTP || OpMode == MD_DAEMON))
  519. {
  520. char *host;
  521. char *problem;
  523. host = RealHostName;
  524. if (host == NULL)
  525. host = "localhost";
  527. if (feof(fp))
  528. problem = "unexpected close";
  529. else if (ferror(fp))
  530. problem = "I/O error";
  531. else
  532. problem = "read timeout";
  533. if (LogLevel > 0 && feof(fp))
  534. sm_syslog(LOG_NOTICE, e->e_id,
  535.     "collect: %s on connection from %.100s, sender=%s: %s",
  536.     problem, host,
  537.     shortenstring(e->e_from.q_paddr, MAXSHORTSTR),
  538.     errstring(errno));
  539. if (feof(fp))
  540. usrerr("451 4.4.1 collect: %s on connection from %s, from=%s",
  541. problem, host,
  542. shortenstring(e->e_from.q_paddr, MAXSHORTSTR));
  543. else
  544. syserr("451 4.4.1 collect: %s on connection from %s, from=%s",
  545. problem, host,
  546. shortenstring(e->e_from.q_paddr, MAXSHORTSTR));
  548. /* don't return an error indication */
  549. e->e_to = NULL;
  550. e->e_flags &= ~EF_FATALERRS;
  551. e->e_flags |= EF_CLRQUEUE;
  553. /* and don't try to deliver the partial message either */
  554. if (InChild)
  555. ExitStat = EX_QUIT;
  556. finis(TRUE, ExitStat);
  557. /* NOTREACHED */
  558. }
  560. /*
  561. **  Find out some information from the headers.
  562. ** Examples are who is the from person & the date.
  563. */
  565. eatheader(e, TRUE);
  567. if (GrabTo && e->e_sendqueue == NULL)
  568. usrerr("No recipient addresses found in header");
  570. /* collect statistics */
  571. if (OpMode != MD_VERIFY)
  572. markstats(e, (ADDRESS *) NULL, FALSE);
  574. /*
  575. **  If we have a Return-Receipt-To:, turn it into a DSN.
  576. */
  578. if (RrtImpliesDsn && hvalue("return-receipt-to", e->e_header) != NULL)
  579. {
  580. ADDRESS *q;
  582. for (q = e->e_sendqueue; q != NULL; q = q->q_next)
  583. if (!bitset(QHASNOTIFY, q->q_flags))
  584. q->q_flags |= QHASNOTIFY|QPINGONSUCCESS;
  585. }
  587. /*
  588. **  Add an Apparently-To: line if we have no recipient lines.
  589. */
  591. if (hvalue("to", e->e_header) != NULL ||
  592.     hvalue("cc", e->e_header) != NULL ||
  593.     hvalue("apparently-to", e->e_header) != NULL)
  594. {
  595. /* have a valid recipient header -- delete Bcc: headers */
  596. e->e_flags |= EF_DELETE_BCC;
  597. }
  598. else if (hvalue("bcc", e->e_header) == NULL)
  599. {
  600. /* no valid recipient headers */
  601. register ADDRESS *q;
  602. char *hdr = NULL;
  604. /* create an Apparently-To: field */
  605. /*    that or reject the message.... */
  606. switch (NoRecipientAction)
  607. {
  608.   case NRA_ADD_APPARENTLY_TO:
  609. hdr = "Apparently-To";
  610. break;
  612.   case NRA_ADD_TO:
  613. hdr = "To";
  614. break;
  616.   case NRA_ADD_BCC:
  617. addheader("Bcc", " ", &e->e_header);
  618. break;
  620.   case NRA_ADD_TO_UNDISCLOSED:
  621. addheader("To", "undisclosed-recipients:;", &e->e_header);
  622. break;
  623. }
  625. if (hdr != NULL)
  626. {
  627. for (q = e->e_sendqueue; q != NULL; q = q->q_next)
  628. {
  629. if (q->q_alias != NULL)
  630. continue;
  631. if (tTd(30, 3))
  632. dprintf("Adding %s: %sn",
  633. hdr, q->q_paddr);
  634. addheader(hdr, q->q_paddr, &e->e_header);
  635. }
  636. }
  637. }
  639. /* check for message too large */
  640. if (MaxMessageSize > 0 && e->e_msgsize > MaxMessageSize)
  641. {
  642. e->e_flags |= EF_NO_BODY_RETN|EF_CLRQUEUE;
  643. e->e_status = "5.2.3";
  644. usrerrenh(e->e_status,
  645.   "552 Message exceeds maximum fixed size (%ld)",
  646.   MaxMessageSize);
  647. if (LogLevel > 6)
  648. sm_syslog(LOG_NOTICE, e->e_id,
  649. "message size (%ld) exceeds maximum (%ld)",
  650. e->e_msgsize, MaxMessageSize);
  651. }
  653. /* check for illegal 8-bit data */
  654. if (HasEightBits)
  655. {
  656. e->e_flags |= EF_HAS8BIT;
  657. if (!bitset(MM_PASS8BIT|MM_MIME8BIT, MimeMode) &&
  658.     !bitset(EF_IS_MIME, e->e_flags))
  659. {
  660. e->e_status = "5.6.1";
  661. usrerrenh(e->e_status, "554 Eight bit data not allowed");
  662. }
  663. }
  664. else
  665. {
  666. /* if it claimed to be 8 bits, well, it lied.... */
  667. if (e->e_bodytype != NULL &&
  668.     strcasecmp(e->e_bodytype, "8BITMIME") == 0)
  669. e->e_bodytype = "7BIT";
  670. }
  672. if (SuperSafe)
  673. {
  674. if ((e->e_dfp = fopen(dfname, "r")) == NULL)
  675. {
  676. /* we haven't acked receipt yet, so just chuck this */
  677. syserr("Cannot reopen %s", dfname);
  678. finis(TRUE, ExitStat);
  679. /* NOTREACHED */
  680. }
  681. }
  682. else
  683. e->e_dfp = df;
  684. if (e->e_dfp == NULL)
  685. syserr("!collect: no e_dfp");
  686. }
  689. static void
  690. collecttimeout(timeout)
  691. time_t timeout;
  692. {
  693. /* if no progress was made, die now */
  694. if (!CollectProgress)
  695. longjmp(CtxCollectTimeout, 1);
  697. /* otherwise reset the timeout */
  698. CollectTimeout = setevent(timeout, collecttimeout, timeout);
  699. CollectProgress = FALSE;
  700. }
  701. /*
  702. **  DFERROR -- signal error on writing the data file.
  703. **
  704. ** Parameters:
  705. ** df -- the file pointer for the data file.
  706. ** msg -- detailed message.
  707. ** e -- the current envelope.
  708. **
  709. ** Returns:
  710. ** none.
  711. **
  712. ** Side Effects:
  713. ** Gives an error message.
  714. ** Arranges for following output to go elsewhere.
  715. */
  717. static void
  718. dferror(df, msg, e)
  719. FILE *volatile df;
  720. char *msg;
  721. register ENVELOPE *e;
  722. {
  723. char *dfname;
  725. dfname = queuename(e, 'd');
  726. setstat(EX_IOERR);
  727. if (errno == ENOSPC)
  728. {
  729. #if STAT64 > 0
  730. struct stat64 st;
  731. #else /* STAT64 > 0 */
  732. struct stat st;
  733. #endif /* STAT64 > 0 */
  734. long avail;
  735. long bsize;
  737. e->e_flags |= EF_NO_BODY_RETN;
  739. if (
  740. #if STAT64 > 0
  741.     fstat64(fileno(df), &st)
  742. #else /* STAT64 > 0 */
  743.     fstat(fileno(df), &st)
  744. #endif /* STAT64 > 0 */
  745.     < 0)
  746.   st.st_size = 0;
  747. (void) freopen(dfname, "w", df);
  748. if (st.st_size <= 0)
  749. fprintf(df, "n*** Mail could not be accepted");
  750. /*CONSTCOND*/
  751. else if (sizeof st.st_size > sizeof (long))
  752. fprintf(df, "n*** Mail of at least %s bytes could not be acceptedn",
  753. quad_to_string(st.st_size));
  754. else
  755. fprintf(df, "n*** Mail of at least %lu bytes could not be acceptedn",
  756. (unsigned long) st.st_size);
  757. fprintf(df, "*** at %s due to lack of disk space for temp file.n",
  758. MyHostName);
  759. avail = freediskspace(qid_printqueue(e->e_queuedir), &bsize);
  760. if (avail > 0)
  761. {
  762. if (bsize > 1024)
  763. avail *= bsize / 1024;
  764. else if (bsize < 1024)
  765. avail /= 1024 / bsize;
  766. fprintf(df, "*** Currently, %ld kilobytes are available for mail temp files.n",
  767. avail);
  768. }
  769. e->e_status = "4.3.1";
  770. usrerrenh(e->e_status, "452 Out of disk space for temp file");
  771. }
  772. else
  773. syserr("collect: Cannot write %s (%s, uid=%d)",
  774. dfname, msg, geteuid());
  775. if (freopen("/dev/null", "w", df) == NULL)
  776. sm_syslog(LOG_ERR, e->e_id,
  777.   "dferror: freopen("/dev/null") failed: %s",
  778.   errstring(errno));
  779. }
  780. /*
  781. **  EATFROM -- chew up a UNIX style from line and process
  782. **
  783. ** This does indeed make some assumptions about the format
  784. ** of UNIX messages.
  785. **
  786. ** Parameters:
  787. ** fm -- the from line.
  788. **
  789. ** Returns:
  790. ** none.
  791. **
  792. ** Side Effects:
  793. ** extracts what information it can from the header,
  794. ** such as the date.
  795. */
  797. #ifndef NOTUNIX
  799. static char *DowList[] =
  800. {
  801. "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL
  802. };
  804. static char *MonthList[] =
  805. {
  806. "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  807. "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
  808. NULL
  809. };
  811. static void
  812. eatfrom(fm, e)
  813. char *volatile fm;
  814. register ENVELOPE *e;
  815. {
  816. register char *p;
  817. register char **dt;
  819. if (tTd(30, 2))
  820. dprintf("eatfrom(%s)n", fm);
  822. /* find the date part */
  823. p = fm;
  824. while (*p != '')
  825. {
  826. /* skip a word */
  827. while (*p != '' && *p != ' ')
  828. p++;
  829. while (*p == ' ')
  830. p++;
  831. if (!(isascii(*p) && isupper(*p)) ||
  832.     p[3] != ' ' || p[13] != ':' || p[16] != ':')
  833. continue;
  835. /* we have a possible date */
  836. for (dt = DowList; *dt != NULL; dt++)
  837. if (strncmp(*dt, p, 3) == 0)
  838. break;
  839. if (*dt == NULL)
  840. continue;
  842. for (dt = MonthList; *dt != NULL; dt++)
  843. if (strncmp(*dt, &p[4], 3) == 0)
  844. break;
  845. if (*dt != NULL)
  846. break;
  847. }
  849. if (*p != '')
  850. {
  851. char *q;
  853. /* we have found a date */
  854. q = xalloc(25);
  855. (void) strlcpy(q, p, 25);
  856. q = arpadate(q);
  857. define('a', newstr(q), e);
  858. }
  859. }
  860. #endif /* ! NOTUNIX */