![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to usersmtp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / sendmail / src|
Return to usersmtp.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / sendmail / src |
1.1 root 1: /*
2: * Copyright (c) 1983 Eric P. Allman
3: * Copyright (c) 1988 Regents of the University of California.
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms are permitted provided
7: * that: (1) source distributions retain this entire copyright notice and
8: * comment, and (2) distributions including binaries display the following
9: * acknowledgement: ``This product includes software developed by the
10: * University of California, Berkeley and its contributors'' in the
11: * documentation or other materials provided with the distribution and in
12: * all advertising materials mentioning features or use of this software.
13: * Neither the name of the University nor the names of its contributors may
14: * be used to endorse or promote products derived from this software without
15: * specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: */
20:
21: # include "sendmail.h"
22:
23: #ifndef lint
24: #ifdef SMTP
25: static char sccsid[] = "@(#)usersmtp.c 5.15 (Berkeley) 6/1/90 (with SMTP)";
26: #else
27: static char sccsid[] = "@(#)usersmtp.c 5.15 (Berkeley) 6/1/90 (without SMTP)";
28: #endif
29: #endif /* not lint */
30:
31: # include <sysexits.h>
32: # include <errno.h>
33:
34: # ifdef SMTP
35:
36: /*
37: ** USERSMTP -- run SMTP protocol from the user end.
38: **
39: ** This protocol is described in RFC821.
40: */
41:
42: #define REPLYTYPE(r) ((r) / 100) /* first digit of reply code */
43: #define REPLYCLASS(r) (((r) / 10) % 10) /* second digit of reply code */
44: #define SMTPCLOSING 421 /* "Service Shutting Down" */
45:
46: char SmtpMsgBuffer[MAXLINE]; /* buffer for commands */
47: char SmtpReplyBuffer[MAXLINE]; /* buffer for replies */
48: char SmtpError[MAXLINE] = ""; /* save failure error messages */
49: FILE *SmtpOut; /* output file */
50: FILE *SmtpIn; /* input file */
51: int SmtpPid; /* pid of mailer */
52:
53: /* following represents the state of the SMTP connection */
54: int SmtpState; /* connection state, see below */
55:
56: #define SMTP_CLOSED 0 /* connection is closed */
57: #define SMTP_OPEN 1 /* connection is open for business */
58: #define SMTP_SSD 2 /* service shutting down */
59: /*
60: ** SMTPINIT -- initialize SMTP.
61: **
62: ** Opens the connection and sends the initial protocol.
63: **
64: ** Parameters:
65: ** m -- mailer to create connection to.
66: ** pvp -- pointer to parameter vector to pass to
67: ** the mailer.
68: **
69: ** Returns:
70: ** appropriate exit status -- EX_OK on success.
71: ** If not EX_OK, it should close the connection.
72: **
73: ** Side Effects:
74: ** creates connection and sends initial protocol.
75: */
76:
77: jmp_buf CtxGreeting;
78:
79: smtpinit(m, pvp)
80: struct mailer *m;
81: char **pvp;
82: {
83: register int r;
84: EVENT *gte;
85: char buf[MAXNAME];
86: extern greettimeout();
87:
88: /*
89: ** Open the connection to the mailer.
90: */
91:
92: if (SmtpState == SMTP_OPEN)
93: syserr("smtpinit: already open");
94:
95: SmtpIn = SmtpOut = NULL;
96: SmtpState = SMTP_CLOSED;
97: SmtpError[0] = '\0';
98: SmtpPhase = "user open";
99: setproctitle("%s %s: %s", CurEnv->e_id, pvp[1], SmtpPhase);
100: SmtpPid = openmailer(m, pvp, (ADDRESS *) NULL, TRUE, &SmtpOut, &SmtpIn);
101: if (SmtpPid < 0)
102: {
103: if (tTd(18, 1))
104: printf("smtpinit: cannot open %s: stat %d errno %d\n",
105: pvp[0], ExitStat, errno);
106: if (CurEnv->e_xfp != NULL)
107: {
108: register char *p;
109: extern char *errstring();
110: extern char *statstring();
111:
112: if (errno == 0)
113: {
114: p = statstring(ExitStat);
115: fprintf(CurEnv->e_xfp,
116: "%.3s %s.%s... %s\n",
117: p, pvp[1], m->m_name, p);
118: }
119: else
120: {
121: r = errno;
122: fprintf(CurEnv->e_xfp,
123: "421 %s.%s... Deferred: %s\n",
124: pvp[1], m->m_name, errstring(errno));
125: errno = r;
126: }
127: }
128: return (ExitStat);
129: }
130: SmtpState = SMTP_OPEN;
131:
132: /*
133: ** Get the greeting message.
134: ** This should appear spontaneously. Give it five minutes to
135: ** happen.
136: */
137:
138: if (setjmp(CtxGreeting) != 0)
139: goto tempfail;
140: gte = setevent((time_t) 300, greettimeout, 0);
141: SmtpPhase = "greeting wait";
142: setproctitle("%s %s: %s", CurEnv->e_id, CurHostName, SmtpPhase);
143: r = reply(m);
144: clrevent(gte);
145: if (r < 0 || REPLYTYPE(r) != 2)
146: goto tempfail;
147:
148: /*
149: ** Send the HELO command.
150: ** My mother taught me to always introduce myself.
151: */
152:
153: smtpmessage("HELO %s", m, MyHostName);
154: SmtpPhase = "HELO wait";
155: setproctitle("%s %s: %s", CurEnv->e_id, CurHostName, SmtpPhase);
156: r = reply(m);
157: if (r < 0)
158: goto tempfail;
159: else if (REPLYTYPE(r) == 5)
160: goto unavailable;
161: else if (REPLYTYPE(r) != 2)
162: goto tempfail;
163:
164: /*
165: ** If this is expected to be another sendmail, send some internal
166: ** commands.
167: */
168:
169: if (bitnset(M_INTERNAL, m->m_flags))
170: {
171: /* tell it to be verbose */
172: smtpmessage("VERB", m);
173: r = reply(m);
174: if (r < 0)
175: goto tempfail;
176:
177: /* tell it we will be sending one transaction only */
178: smtpmessage("ONEX", m);
179: r = reply(m);
180: if (r < 0)
181: goto tempfail;
182: }
183:
184: /*
185: ** Send the MAIL command.
186: ** Designates the sender.
187: */
188:
189: expand("\001g", buf, &buf[sizeof buf - 1], CurEnv);
190: if (CurEnv->e_from.q_mailer == LocalMailer ||
191: !bitnset(M_FROMPATH, m->m_flags))
192: {
193: smtpmessage("MAIL From:<%s>", m, buf);
194: }
195: else
196: {
197: smtpmessage("MAIL From:<@%s%c%s>", m, MyHostName,
198: buf[0] == '@' ? ',' : ':', buf);
199: }
200: SmtpPhase = "MAIL wait";
201: setproctitle("%s %s: %s", CurEnv->e_id, CurHostName, SmtpPhase);
202: r = reply(m);
203: if (r < 0 || REPLYTYPE(r) == 4)
204: goto tempfail;
205: else if (r == 250)
206: return (EX_OK);
207: else if (r == 552)
208: goto unavailable;
209:
210: /* protocol error -- close up */
211: smtpquit(m);
212: return (EX_PROTOCOL);
213:
214: /* signal a temporary failure */
215: tempfail:
216: smtpquit(m);
217: return (EX_TEMPFAIL);
218:
219: /* signal service unavailable */
220: unavailable:
221: smtpquit(m);
222: return (EX_UNAVAILABLE);
223: }
224:
225:
226: static
227: greettimeout()
228: {
229: /* timeout reading the greeting message */
230: longjmp(CtxGreeting, 1);
231: }
232: /*
233: ** SMTPRCPT -- designate recipient.
234: **
235: ** Parameters:
236: ** to -- address of recipient.
237: ** m -- the mailer we are sending to.
238: **
239: ** Returns:
240: ** exit status corresponding to recipient status.
241: **
242: ** Side Effects:
243: ** Sends the mail via SMTP.
244: */
245:
246: smtprcpt(to, m)
247: ADDRESS *to;
248: register MAILER *m;
249: {
250: register int r;
251: extern char *remotename();
252:
253: smtpmessage("RCPT To:<%s>", m, remotename(to->q_user, m, FALSE, TRUE));
254:
255: SmtpPhase = "RCPT wait";
256: setproctitle("%s %s: %s", CurEnv->e_id, CurHostName, SmtpPhase);
257: r = reply(m);
258: if (r < 0 || REPLYTYPE(r) == 4)
259: return (EX_TEMPFAIL);
260: else if (REPLYTYPE(r) == 2)
261: return (EX_OK);
262: else if (r == 550 || r == 551 || r == 553)
263: return (EX_NOUSER);
264: else if (r == 552 || r == 554)
265: return (EX_UNAVAILABLE);
266: return (EX_PROTOCOL);
267: }
268: /*
269: ** SMTPDATA -- send the data and clean up the transaction.
270: **
271: ** Parameters:
272: ** m -- mailer being sent to.
273: ** e -- the envelope for this message.
274: **
275: ** Returns:
276: ** exit status corresponding to DATA command.
277: **
278: ** Side Effects:
279: ** none.
280: */
281:
282: smtpdata(m, e)
283: struct mailer *m;
284: register ENVELOPE *e;
285: {
286: register int r;
287:
288: /*
289: ** Send the data.
290: ** First send the command and check that it is ok.
291: ** Then send the data.
292: ** Follow it up with a dot to terminate.
293: ** Finally get the results of the transaction.
294: */
295:
296: /* send the command and check ok to proceed */
297: smtpmessage("DATA", m);
298: SmtpPhase = "DATA wait";
299: setproctitle("%s %s: %s", CurEnv->e_id, CurHostName, SmtpPhase);
300: r = reply(m);
301: if (r < 0 || REPLYTYPE(r) == 4)
302: return (EX_TEMPFAIL);
303: else if (r == 554)
304: return (EX_UNAVAILABLE);
305: else if (r != 354)
306: return (EX_PROTOCOL);
307:
308: /* now output the actual message */
309: (*e->e_puthdr)(SmtpOut, m, CurEnv);
310: putline("\n", SmtpOut, m);
311: (*e->e_putbody)(SmtpOut, m, CurEnv);
312:
313: /* terminate the message */
314: fprintf(SmtpOut, ".%s", m->m_eol);
315: if (Verbose && !HoldErrs)
316: nmessage(Arpa_Info, ">>> .");
317:
318: /* check for the results of the transaction */
319: SmtpPhase = "result wait";
320: setproctitle("%s %s: %s", CurEnv->e_id, CurHostName, SmtpPhase);
321: r = reply(m);
322: if (r < 0 || REPLYTYPE(r) == 4)
323: return (EX_TEMPFAIL);
324: else if (r == 250)
325: return (EX_OK);
326: else if (r == 552 || r == 554)
327: return (EX_UNAVAILABLE);
328: return (EX_PROTOCOL);
329: }
330: /*
331: ** SMTPQUIT -- close the SMTP connection.
332: **
333: ** Parameters:
334: ** m -- a pointer to the mailer.
335: **
336: ** Returns:
337: ** none.
338: **
339: ** Side Effects:
340: ** sends the final protocol and closes the connection.
341: */
342:
343: smtpquit(m)
344: register MAILER *m;
345: {
346: int i;
347:
348: /* if the connection is already closed, don't bother */
349: if (SmtpIn == NULL)
350: return;
351:
352: /* send the quit message if not a forced quit */
353: if (SmtpState == SMTP_OPEN || SmtpState == SMTP_SSD)
354: {
355: smtpmessage("QUIT", m);
356: (void) reply(m);
357: if (SmtpState == SMTP_CLOSED)
358: return;
359: }
360:
361: /* now actually close the connection */
362: (void) fclose(SmtpIn);
363: (void) fclose(SmtpOut);
364: SmtpIn = SmtpOut = NULL;
365: SmtpState = SMTP_CLOSED;
366:
367: /* and pick up the zombie */
368: i = endmailer(SmtpPid, m->m_argv[0]);
369: if (i != EX_OK)
370: syserr("smtpquit %s: stat %d", m->m_argv[0], i);
371: }
372: /*
373: ** REPLY -- read arpanet reply
374: **
375: ** Parameters:
376: ** m -- the mailer we are reading the reply from.
377: **
378: ** Returns:
379: ** reply code it reads.
380: **
381: ** Side Effects:
382: ** flushes the mail file.
383: */
384:
385: reply(m)
386: MAILER *m;
387: {
388: (void) fflush(SmtpOut);
389:
390: if (tTd(18, 1))
391: printf("reply\n");
392:
393: /*
394: ** Read the input line, being careful not to hang.
395: */
396:
397: for (;;)
398: {
399: register int r;
400: register char *p;
401:
402: /* actually do the read */
403: if (CurEnv->e_xfp != NULL)
404: (void) fflush(CurEnv->e_xfp); /* for debugging */
405:
406: /* if we are in the process of closing just give the code */
407: if (SmtpState == SMTP_CLOSED)
408: return (SMTPCLOSING);
409:
410: /* get the line from the other side */
411: p = sfgets(SmtpReplyBuffer, sizeof SmtpReplyBuffer, SmtpIn);
412: if (p == NULL)
413: {
414: extern char MsgBuf[]; /* err.c */
415: extern char Arpa_TSyserr[]; /* conf.c */
416:
417: /* if the remote end closed early, fake an error */
418: if (errno == 0)
419: # ifdef ECONNRESET
420: errno = ECONNRESET;
421: # else ECONNRESET
422: errno = EPIPE;
423: # endif ECONNRESET
424:
425: message(Arpa_TSyserr, "reply: read error");
426: /* if debugging, pause so we can see state */
427: if (tTd(18, 100))
428: pause();
429: # ifdef LOG
430: syslog(LOG_INFO, "%s", &MsgBuf[4]);
431: # endif LOG
432: SmtpState = SMTP_CLOSED;
433: smtpquit(m);
434: return (-1);
435: }
436: fixcrlf(SmtpReplyBuffer, TRUE);
437:
438: if (CurEnv->e_xfp != NULL && index("45", SmtpReplyBuffer[0]) != NULL)
439: {
440: /* serious error -- log the previous command */
441: if (SmtpMsgBuffer[0] != '\0')
442: fprintf(CurEnv->e_xfp, ">>> %s\n", SmtpMsgBuffer);
443: SmtpMsgBuffer[0] = '\0';
444:
445: /* now log the message as from the other side */
446: fprintf(CurEnv->e_xfp, "<<< %s\n", SmtpReplyBuffer);
447: }
448:
449: /* display the input for verbose mode */
450: if (Verbose && !HoldErrs)
451: nmessage(Arpa_Info, "%s", SmtpReplyBuffer);
452:
453: /* if continuation is required, we can go on */
454: if (SmtpReplyBuffer[3] == '-' || !isdigit(SmtpReplyBuffer[0]))
455: continue;
456:
457: /* decode the reply code */
458: r = atoi(SmtpReplyBuffer);
459:
460: /* extra semantics: 0xx codes are "informational" */
461: if (r < 100)
462: continue;
463:
464: /* reply code 421 is "Service Shutting Down" */
465: if (r == SMTPCLOSING && SmtpState != SMTP_SSD)
466: {
467: /* send the quit protocol */
468: SmtpState = SMTP_SSD;
469: smtpquit(m);
470: }
471:
472: /* save temporary failure messages for posterity */
473: if (SmtpReplyBuffer[0] == '4' && SmtpError[0] == '\0')
474: (void) strcpy(SmtpError, &SmtpReplyBuffer[4]);
475:
476: return (r);
477: }
478: }
479: /*
480: ** SMTPMESSAGE -- send message to server
481: **
482: ** Parameters:
483: ** f -- format
484: ** m -- the mailer to control formatting.
485: ** a, b, c -- parameters
486: **
487: ** Returns:
488: ** none.
489: **
490: ** Side Effects:
491: ** writes message to SmtpOut.
492: */
493:
494: /*VARARGS1*/
495: smtpmessage(f, m, a, b, c)
496: char *f;
497: MAILER *m;
498: {
499: (void) sprintf(SmtpMsgBuffer, f, a, b, c);
500: if (tTd(18, 1) || (Verbose && !HoldErrs))
501: nmessage(Arpa_Info, ">>> %s", SmtpMsgBuffer);
502: if (SmtpOut != NULL)
503: fprintf(SmtpOut, "%s%s", SmtpMsgBuffer,
504: m == 0 ? "\r\n" : m->m_eol);
505: }
506:
507: # endif SMTP
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.