![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to collect.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.lib / sendmail / src|
Return to collect.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.lib / sendmail / src |
1.1 root 1: /*
2: ** Sendmail
3: ** Copyright (c) 1983 Eric P. Allman
4: ** Berkeley, California
5: **
6: ** Copyright (c) 1983 Regents of the University of California.
7: ** All rights reserved. The Berkeley software License Agreement
8: ** specifies the terms and conditions for redistribution.
9: */
10:
11: #ifndef lint
12: static char SccsId[] = "@(#)collect.c 5.2 (Berkeley) 6/8/85";
13: #endif not lint
14:
15: # include <errno.h>
16: # include "sendmail.h"
17:
18: /*
19: ** COLLECT -- read & parse message header & make temp file.
20: **
21: ** Creates a temporary file name and copies the standard
22: ** input to that file. Leading UNIX-style "From" lines are
23: ** stripped off (after important information is extracted).
24: **
25: ** Parameters:
26: ** sayok -- if set, give an ARPANET style message
27: ** to say we are ready to collect input.
28: **
29: ** Returns:
30: ** none.
31: **
32: ** Side Effects:
33: ** Temp file is created and filled.
34: ** The from person may be set.
35: */
36:
37: collect(sayok)
38: bool sayok;
39: {
40: register FILE *tf;
41: char buf[MAXFIELD+2];
42: register char *p;
43: extern char *hvalue();
44:
45: /*
46: ** Create the temp file name and create the file.
47: */
48:
49: CurEnv->e_df = newstr(queuename(CurEnv, 'd'));
50: if ((tf = dfopen(CurEnv->e_df, "w")) == NULL)
51: {
52: syserr("Cannot create %s", CurEnv->e_df);
53: NoReturn = TRUE;
54: finis();
55: }
56: (void) chmod(CurEnv->e_df, FileMode);
57:
58: /*
59: ** Tell ARPANET to go ahead.
60: */
61:
62: if (sayok)
63: message("354", "Enter mail, end with \".\" on a line by itself");
64:
65: /*
66: ** Try to read a UNIX-style From line
67: */
68:
69: (void) sfgets(buf, sizeof buf, InChannel);
70: fixcrlf(buf, FALSE);
71: # ifndef NOTUNIX
72: if (!SaveFrom && strncmp(buf, "From ", 5) == 0)
73: {
74: eatfrom(buf);
75: (void) sfgets(buf, sizeof buf, InChannel);
76: fixcrlf(buf, FALSE);
77: }
78: # endif NOTUNIX
79:
80: /*
81: ** Copy InChannel to temp file & do message editing.
82: ** To keep certain mailers from getting confused,
83: ** and to keep the output clean, lines that look
84: ** like UNIX "From" lines are deleted in the header.
85: */
86:
87: do
88: {
89: int c;
90: extern bool isheader();
91:
92: /* drop out on error */
93: if (ferror(InChannel))
94: break;
95:
96: /* if the line is too long, throw the rest away */
97: if (index(buf, '\n') == NULL)
98: {
99: while ((c = getc(InChannel)) != '\n' && c != EOF)
100: continue;
101: /* give an error? */
102: }
103:
104: fixcrlf(buf, TRUE);
105:
106: /* see if the header is over */
107: if (!isheader(buf))
108: break;
109:
110: /* get the rest of this field */
111: while ((c = getc(InChannel)) == ' ' || c == '\t')
112: {
113: p = &buf[strlen(buf)];
114: *p++ = '\n';
115: *p++ = c;
116: if (sfgets(p, MAXFIELD - (p - buf), InChannel) == NULL)
117: break;
118: fixcrlf(p, TRUE);
119: }
120: if (!feof(InChannel) && !ferror(InChannel))
121: (void) ungetc(c, InChannel);
122:
123: CurEnv->e_msgsize += strlen(buf);
124:
125: /*
126: ** Snarf header away.
127: */
128:
129: if (bitset(H_EOH, chompheader(buf, FALSE)))
130: break;
131: } while (sfgets(buf, MAXFIELD, InChannel) != NULL);
132:
133: # ifdef DEBUG
134: if (tTd(30, 1))
135: printf("EOH\n");
136: # endif DEBUG
137:
138: /* throw away a blank line */
139: if (buf[0] == '\0')
140: (void) sfgets(buf, MAXFIELD, InChannel);
141:
142: /*
143: ** Collect the body of the message.
144: */
145:
146: do
147: {
148: register char *bp = buf;
149:
150: fixcrlf(buf, TRUE);
151:
152: /* check for end-of-message */
153: if (!IgnrDot && buf[0] == '.' && (buf[1] == '\n' || buf[1] == '\0'))
154: break;
155:
156: /* check for transparent dot */
157: if (OpMode == MD_SMTP && !IgnrDot && bp[0] == '.' && bp[1] == '.')
158: bp++;
159:
160: /*
161: ** Figure message length, output the line to the temp
162: ** file, and insert a newline if missing.
163: */
164:
165: CurEnv->e_msgsize += strlen(bp) + 1;
166: fputs(bp, tf);
167: fputs("\n", tf);
168: if (ferror(tf))
169: tferror(tf);
170: } while (sfgets(buf, MAXFIELD, InChannel) != NULL);
171: if (fflush(tf) != 0)
172: tferror(tf);
173: (void) fclose(tf);
174:
175: /* An EOF when running SMTP is an error */
176: if ((feof(InChannel) || ferror(InChannel)) && OpMode == MD_SMTP)
177: {
178: syserr("collect: unexpected close, from=%s", CurEnv->e_from.q_paddr);
179:
180: /* don't return an error indication */
181: CurEnv->e_to = NULL;
182: CurEnv->e_flags &= ~EF_FATALERRS;
183:
184: /* and don't try to deliver the partial message either */
185: finis();
186: }
187:
188: /*
189: ** Find out some information from the headers.
190: ** Examples are who is the from person & the date.
191: */
192:
193: eatheader(CurEnv);
194:
195: /*
196: ** Add an Apparently-To: line if we have no recipient lines.
197: */
198:
199: if (hvalue("to") == NULL && hvalue("cc") == NULL &&
200: hvalue("bcc") == NULL && hvalue("apparently-to") == NULL)
201: {
202: register ADDRESS *q;
203:
204: /* create an Apparently-To: field */
205: /* that or reject the message.... */
206: for (q = CurEnv->e_sendqueue; q != NULL; q = q->q_next)
207: {
208: if (q->q_alias != NULL)
209: continue;
210: # ifdef DEBUG
211: if (tTd(30, 3))
212: printf("Adding Apparently-To: %s\n", q->q_paddr);
213: # endif DEBUG
214: addheader("apparently-to", q->q_paddr, CurEnv);
215: }
216: }
217:
218: if ((CurEnv->e_dfp = fopen(CurEnv->e_df, "r")) == NULL)
219: syserr("Cannot reopen %s", CurEnv->e_df);
220: }
221: /*
222: ** TFERROR -- signal error on writing the temporary file.
223: **
224: ** Parameters:
225: ** tf -- the file pointer for the temporary file.
226: **
227: ** Returns:
228: ** none.
229: **
230: ** Side Effects:
231: ** Gives an error message.
232: ** Arranges for following output to go elsewhere.
233: */
234:
235: tferror(tf)
236: FILE *tf;
237: {
238: if (errno == ENOSPC)
239: {
240: (void) freopen(CurEnv->e_df, "w", tf);
241: fputs("\nMAIL DELETED BECAUSE OF LACK OF DISK SPACE\n\n", tf);
242: usrerr("452 Out of disk space for temp file");
243: }
244: else
245: syserr("collect: Cannot write %s", CurEnv->e_df);
246: (void) freopen("/dev/null", "w", tf);
247: }
248: /*
249: ** EATFROM -- chew up a UNIX style from line and process
250: **
251: ** This does indeed make some assumptions about the format
252: ** of UNIX messages.
253: **
254: ** Parameters:
255: ** fm -- the from line.
256: **
257: ** Returns:
258: ** none.
259: **
260: ** Side Effects:
261: ** extracts what information it can from the header,
262: ** such as the date.
263: */
264:
265: # ifndef NOTUNIX
266:
267: char *DowList[] =
268: {
269: "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL
270: };
271:
272: char *MonthList[] =
273: {
274: "Jan", "Feb", "Mar", "Apr", "May", "Jun",
275: "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
276: NULL
277: };
278:
279: eatfrom(fm)
280: char *fm;
281: {
282: register char *p;
283: register char **dt;
284:
285: # ifdef DEBUG
286: if (tTd(30, 2))
287: printf("eatfrom(%s)\n", fm);
288: # endif DEBUG
289:
290: /* find the date part */
291: p = fm;
292: while (*p != '\0')
293: {
294: /* skip a word */
295: while (*p != '\0' && *p != ' ')
296: p++;
297: while (*p == ' ')
298: p++;
299: if (!isupper(*p) || p[3] != ' ' || p[13] != ':' || p[16] != ':')
300: continue;
301:
302: /* we have a possible date */
303: for (dt = DowList; *dt != NULL; dt++)
304: if (strncmp(*dt, p, 3) == 0)
305: break;
306: if (*dt == NULL)
307: continue;
308:
309: for (dt = MonthList; *dt != NULL; dt++)
310: if (strncmp(*dt, &p[4], 3) == 0)
311: break;
312: if (*dt != NULL)
313: break;
314: }
315:
316: if (*p != NULL)
317: {
318: char *q;
319: extern char *arpadate();
320:
321: /* we have found a date */
322: q = xalloc(25);
323: (void) strncpy(q, p, 25);
324: q[24] = '\0';
325: define('d', q, CurEnv);
326: q = arpadate(q);
327: define('a', newstr(q), CurEnv);
328: }
329: }
330:
331: # endif NOTUNIX
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.