1 /*
2  * Copyright (c) 1983 Eric P. Allman
3  * Copyright (c) 1988, 1993
4  *	The Regents of the University of California.  All rights reserved.
5  *
6  * %sccs.include.redist.c%
7  */
8 
9 # include "sendmail.h"
10 
11 #ifndef lint
12 #ifdef SMTP
13 static char sccsid[] = "@(#)usersmtp.c	8.31 (Berkeley) 11/27/94 (with SMTP)";
14 #else
15 static char sccsid[] = "@(#)usersmtp.c	8.31 (Berkeley) 11/27/94 (without SMTP)";
16 #endif
17 #endif /* not lint */
18 
19 # include <sysexits.h>
20 # include <errno.h>
21 
22 # ifdef SMTP
23 
24 /*
25 **  USERSMTP -- run SMTP protocol from the user end.
26 **
27 **	This protocol is described in RFC821.
28 */
29 
30 #define REPLYTYPE(r)	((r) / 100)		/* first digit of reply code */
31 #define REPLYCLASS(r)	(((r) / 10) % 10)	/* second digit of reply code */
32 #define SMTPCLOSING	421			/* "Service Shutting Down" */
33 
34 char	SmtpMsgBuffer[MAXLINE];		/* buffer for commands */
35 char	SmtpReplyBuffer[MAXLINE];	/* buffer for replies */
36 char	SmtpError[MAXLINE] = "";	/* save failure error messages */
37 int	SmtpPid;			/* pid of mailer */
38 bool	SmtpNeedIntro;			/* need "while talking" in transcript */
39 
40 #ifdef __STDC__
41 extern	smtpmessage(char *f, MAILER *m, MCI *mci, ...);
42 #endif
43 /*
44 **  SMTPINIT -- initialize SMTP.
45 **
46 **	Opens the connection and sends the initial protocol.
47 **
48 **	Parameters:
49 **		m -- mailer to create connection to.
50 **		pvp -- pointer to parameter vector to pass to
51 **			the mailer.
52 **
53 **	Returns:
54 **		none.
55 **
56 **	Side Effects:
57 **		creates connection and sends initial protocol.
58 */
59 
60 smtpinit(m, mci, e)
61 	struct mailer *m;
62 	register MCI *mci;
63 	ENVELOPE *e;
64 {
65 	register int r;
66 	register char *p;
67 	extern void esmtp_check();
68 	extern void helo_options();
69 
70 	if (tTd(18, 1))
71 	{
72 		printf("smtpinit ");
73 		mci_dump(mci, FALSE);
74 	}
75 
76 	/*
77 	**  Open the connection to the mailer.
78 	*/
79 
80 	SmtpError[0] = '\0';
81 	CurHostName = mci->mci_host;		/* XXX UGLY XXX */
82 	SmtpNeedIntro = TRUE;
83 	switch (mci->mci_state)
84 	{
85 	  case MCIS_ACTIVE:
86 		/* need to clear old information */
87 		smtprset(m, mci, e);
88 		/* fall through */
89 
90 	  case MCIS_OPEN:
91 		return;
92 
93 	  case MCIS_ERROR:
94 	  case MCIS_SSD:
95 		/* shouldn't happen */
96 		smtpquit(m, mci, e);
97 		/* fall through */
98 
99 	  case MCIS_CLOSED:
100 		syserr("451 smtpinit: state CLOSED");
101 		return;
102 
103 	  case MCIS_OPENING:
104 		break;
105 	}
106 
107 	mci->mci_state = MCIS_OPENING;
108 
109 	/*
110 	**  Get the greeting message.
111 	**	This should appear spontaneously.  Give it five minutes to
112 	**	happen.
113 	*/
114 
115 	SmtpPhase = mci->mci_phase = "client greeting";
116 	setproctitle("%s %s: %s", e->e_id, CurHostName, mci->mci_phase);
117 	r = reply(m, mci, e, TimeOuts.to_initial, esmtp_check);
118 	if (r < 0 || REPLYTYPE(r) == 4)
119 		goto tempfail1;
120 	if (REPLYTYPE(r) != 2)
121 		goto unavailable;
122 
123 	/*
124 	**  Send the HELO command.
125 	**	My mother taught me to always introduce myself.
126 	*/
127 
128 	if (bitnset(M_ESMTP, m->m_flags))
129 		mci->mci_flags |= MCIF_ESMTP;
130 
131 tryhelo:
132 	if (bitset(MCIF_ESMTP, mci->mci_flags))
133 	{
134 		smtpmessage("EHLO %s", m, mci, MyHostName);
135 		SmtpPhase = mci->mci_phase = "client EHLO";
136 	}
137 	else
138 	{
139 		smtpmessage("HELO %s", m, mci, MyHostName);
140 		SmtpPhase = mci->mci_phase = "client HELO";
141 	}
142 	setproctitle("%s %s: %s", e->e_id, CurHostName, mci->mci_phase);
143 	r = reply(m, mci, e, TimeOuts.to_helo, helo_options);
144 	if (r < 0)
145 		goto tempfail1;
146 	else if (REPLYTYPE(r) == 5)
147 	{
148 		if (bitset(MCIF_ESMTP, mci->mci_flags))
149 		{
150 			/* try old SMTP instead */
151 			mci->mci_flags &= ~MCIF_ESMTP;
152 			goto tryhelo;
153 		}
154 		goto unavailable;
155 	}
156 	else if (REPLYTYPE(r) != 2)
157 		goto tempfail1;
158 
159 	/*
160 	**  Check to see if we actually ended up talking to ourself.
161 	**  This means we didn't know about an alias or MX, or we managed
162 	**  to connect to an echo server.
163 	*/
164 
165 	p = strchr(&SmtpReplyBuffer[4], ' ');
166 	if (p != NULL)
167 		*p = '\0';
168 	if (!bitnset(M_NOLOOPCHECK, m->m_flags) &&
169 	    strcasecmp(&SmtpReplyBuffer[4], MyHostName) == 0)
170 	{
171 		syserr("553 %s config error: mail loops back to myself",
172 			MyHostName);
173 		mci->mci_exitstat = EX_CONFIG;
174 		mci->mci_errno = 0;
175 		smtpquit(m, mci, e);
176 		return;
177 	}
178 
179 	/*
180 	**  If this is expected to be another sendmail, send some internal
181 	**  commands.
182 	*/
183 
184 	if (bitnset(M_INTERNAL, m->m_flags))
185 	{
186 		/* tell it to be verbose */
187 		smtpmessage("VERB", m, mci);
188 		r = reply(m, mci, e, TimeOuts.to_miscshort, NULL);
189 		if (r < 0)
190 			goto tempfail2;
191 	}
192 
193 	if (mci->mci_state != MCIS_CLOSED)
194 	{
195 		mci->mci_state = MCIS_OPEN;
196 		return;
197 	}
198 
199 	/* got a 421 error code during startup */
200 
201   tempfail1:
202   tempfail2:
203 	mci->mci_exitstat = EX_TEMPFAIL;
204 	if (mci->mci_errno == 0)
205 		mci->mci_errno = errno;
206 	if (mci->mci_state != MCIS_CLOSED)
207 		smtpquit(m, mci, e);
208 	return;
209 
210   unavailable:
211 	mci->mci_exitstat = EX_UNAVAILABLE;
212 	mci->mci_errno = errno;
213 	smtpquit(m, mci, e);
214 	return;
215 }
216 /*
217 **  ESMTP_CHECK -- check to see if this implementation likes ESMTP protocol
218 **
219 **
220 **	Parameters:
221 **		line -- the response line.
222 **		firstline -- set if this is the first line of the reply.
223 **		m -- the mailer.
224 **		mci -- the mailer connection info.
225 **		e -- the envelope.
226 **
227 **	Returns:
228 **		none.
229 */
230 
231 void
232 esmtp_check(line, firstline, m, mci, e)
233 	char *line;
234 	bool firstline;
235 	MAILER *m;
236 	register MCI *mci;
237 	ENVELOPE *e;
238 {
239 	while ((line = strchr(++line, 'E')) != NULL)
240 	{
241 		if (strncmp(line, "ESMTP ", 6) == 0)
242 		{
243 			mci->mci_flags |= MCIF_ESMTP;
244 			break;
245 		}
246 	}
247 }
248 /*
249 **  HELO_OPTIONS -- process the options on a HELO line.
250 **
251 **	Parameters:
252 **		line -- the response line.
253 **		firstline -- set if this is the first line of the reply.
254 **		m -- the mailer.
255 **		mci -- the mailer connection info.
256 **		e -- the envelope.
257 **
258 **	Returns:
259 **		none.
260 */
261 
262 void
263 helo_options(line, firstline, m, mci, e)
264 	char *line;
265 	bool firstline;
266 	MAILER *m;
267 	register MCI *mci;
268 	ENVELOPE *e;
269 {
270 	register char *p;
271 
272 	if (firstline)
273 		return;
274 
275 	if (strlen(line) < 5)
276 		return;
277 	line += 4;
278 	p = strchr(line, ' ');
279 	if (p != NULL)
280 		*p++ = '\0';
281 	if (strcasecmp(line, "size") == 0)
282 	{
283 		mci->mci_flags |= MCIF_SIZE;
284 		if (p != NULL)
285 			mci->mci_maxsize = atol(p);
286 	}
287 	else if (strcasecmp(line, "8bitmime") == 0)
288 	{
289 		mci->mci_flags |= MCIF_8BITMIME;
290 		mci->mci_flags &= ~MCIF_7BIT;
291 	}
292 	else if (strcasecmp(line, "expn") == 0)
293 		mci->mci_flags |= MCIF_EXPN;
294 	else if (strcasecmp(line, "x-dsn-1") == 0)
295 		mci->mci_flags |= MCIF_DSN;
296 }
297 /*
298 **  SMTPMAILFROM -- send MAIL command
299 **
300 **	Parameters:
301 **		m -- the mailer.
302 **		mci -- the mailer connection structure.
303 **		e -- the envelope (including the sender to specify).
304 */
305 
306 smtpmailfrom(m, mci, e)
307 	struct mailer *m;
308 	MCI *mci;
309 	ENVELOPE *e;
310 {
311 	int r;
312 	char *bufp;
313 	char *bodytype;
314 	char buf[MAXNAME];
315 	char optbuf[MAXLINE];
316 
317 	if (tTd(18, 2))
318 		printf("smtpmailfrom: CurHost=%s\n", CurHostName);
319 
320 	/* set up appropriate options to include */
321 	if (bitset(MCIF_SIZE, mci->mci_flags) && e->e_msgsize > 0)
322 		sprintf(optbuf, " SIZE=%ld", e->e_msgsize);
323 	else
324 		strcpy(optbuf, "");
325 
326 	bodytype = e->e_bodytype;
327 	if (bitset(MCIF_8BITMIME, mci->mci_flags))
328 	{
329 		if (bodytype == NULL &&
330 		    bitset(MM_MIME8BIT, MimeMode) &&
331 		    bitset(EF_HAS8BIT, e->e_flags) &&
332 		    !bitnset(M_8BITS, m->m_flags))
333 			bodytype = "8BITMIME";
334 		if (bodytype != NULL)
335 		{
336 			strcat(optbuf, " BODY=");
337 			strcat(optbuf, bodytype);
338 		}
339 	}
340 	else if (bitnset(M_8BITS, m->m_flags) ||
341 		 !bitset(EF_HAS8BIT, e->e_flags) ||
342 		 (e->e_bodytype != NULL &&
343 		  strcasecmp(e->e_bodytype, "7bit") == 0))
344 	{
345 		/* just pass it through */
346 	}
347 	else if (bitset(MM_CVTMIME, MimeMode) &&
348 		 (e->e_bodytype != NULL || !bitset(MM_PASS8BIT, MimeMode)))
349 	{
350 		/* must convert from 8bit MIME format to 7bit encoded */
351 		mci->mci_flags |= MCIF_CVT8TO7;
352 	}
353 	else if (!bitset(MM_PASS8BIT, MimeMode))
354 	{
355 		/* cannot just send a 8-bit version */
356 		usrerr("%s does not support 8BITMIME", mci->mci_host);
357 		return EX_DATAERR;
358 	}
359 
360 	if (bitset(MCIF_DSN, mci->mci_flags))
361 	{
362 		if (e->e_envid != NULL)
363 		{
364 			strcat(optbuf, " ENVID=");
365 			strcat(optbuf, e->e_envid);
366 		}
367 		if (e->e_omts != NULL)
368 		{
369 			strcat(optbuf, " OMTS=");
370 			strcat(optbuf, e->e_omts);
371 		}
372 	}
373 
374 	/*
375 	**  Send the MAIL command.
376 	**	Designates the sender.
377 	*/
378 
379 	mci->mci_state = MCIS_ACTIVE;
380 
381 	if (bitset(EF_RESPONSE, e->e_flags) &&
382 	    !bitnset(M_NO_NULL_FROM, m->m_flags))
383 		(void) strcpy(buf, "");
384 	else
385 		expand("\201g", buf, &buf[sizeof buf - 1], e);
386 	if (buf[0] == '<')
387 	{
388 		/* strip off <angle brackets> (put back on below) */
389 		bufp = &buf[strlen(buf) - 1];
390 		if (*bufp == '>')
391 			*bufp = '\0';
392 		bufp = &buf[1];
393 	}
394 	else
395 		bufp = buf;
396 	if (bitnset(M_LOCALMAILER, e->e_from.q_mailer->m_flags) ||
397 	    !bitnset(M_FROMPATH, m->m_flags))
398 	{
399 		smtpmessage("MAIL From:<%s>%s", m, mci, bufp, optbuf);
400 	}
401 	else
402 	{
403 		smtpmessage("MAIL From:<@%s%c%s>%s", m, mci, MyHostName,
404 			*bufp == '@' ? ',' : ':', bufp, optbuf);
405 	}
406 	SmtpPhase = mci->mci_phase = "client MAIL";
407 	setproctitle("%s %s: %s", e->e_id, CurHostName, mci->mci_phase);
408 	r = reply(m, mci, e, TimeOuts.to_mail, NULL);
409 	if (r < 0 || REPLYTYPE(r) == 4)
410 	{
411 		mci->mci_exitstat = EX_TEMPFAIL;
412 		mci->mci_errno = errno;
413 		smtpquit(m, mci, e);
414 		return EX_TEMPFAIL;
415 	}
416 	else if (r == 250)
417 	{
418 		mci->mci_exitstat = EX_OK;
419 		return EX_OK;
420 	}
421 	else if (r == 552)
422 	{
423 		/* signal service unavailable */
424 		mci->mci_exitstat = EX_UNAVAILABLE;
425 		smtpquit(m, mci, e);
426 		return EX_UNAVAILABLE;
427 	}
428 
429 #ifdef LOG
430 	if (LogLevel > 1)
431 	{
432 		syslog(LOG_CRIT, "%s: %s: SMTP MAIL protocol error: %s",
433 			e->e_id, mci->mci_host, SmtpReplyBuffer);
434 	}
435 #endif
436 
437 	/* protocol error -- close up */
438 	smtpquit(m, mci, e);
439 	mci->mci_exitstat = EX_PROTOCOL;
440 	return EX_PROTOCOL;
441 }
442 /*
443 **  SMTPRCPT -- designate recipient.
444 **
445 **	Parameters:
446 **		to -- address of recipient.
447 **		m -- the mailer we are sending to.
448 **		mci -- the connection info for this transaction.
449 **		e -- the envelope for this transaction.
450 **
451 **	Returns:
452 **		exit status corresponding to recipient status.
453 **
454 **	Side Effects:
455 **		Sends the mail via SMTP.
456 */
457 
458 smtprcpt(to, m, mci, e)
459 	ADDRESS *to;
460 	register MAILER *m;
461 	MCI *mci;
462 	ENVELOPE *e;
463 {
464 	register int r;
465 	char optbuf[MAXLINE];
466 
467 	strcpy(optbuf, "");
468 	if (bitset(MCIF_DSN, mci->mci_flags))
469 	{
470 		bool firstone = TRUE;
471 
472 		/* NOTIFY= parameter */
473 		strcat(optbuf, " NOTIFY=");
474 		if (bitset(QPINGONSUCCESS, to->q_flags))
475 		{
476 			strcat(optbuf, "SUCCESS");
477 			firstone = FALSE;
478 		}
479 		if (bitset(QPINGONFAILURE, to->q_flags))
480 		{
481 			if (!firstone)
482 				strcat(optbuf, ",");
483 			strcat(optbuf, "FAILURE");
484 			firstone = FALSE;
485 		}
486 		if (bitset(QPINGONDELAY, to->q_flags))
487 		{
488 			if (!firstone)
489 				strcat(optbuf, ",");
490 			strcat(optbuf, "DELAY");
491 			firstone = FALSE;
492 		}
493 		if (firstone)
494 			strcat(optbuf, "NEVER");
495 
496 		/* RET= parameter */
497 		if (bitset(QHAS_RET_PARAM, to->q_flags))
498 		{
499 			strcat(optbuf, " RET=");
500 			if (bitset(QRET_HDRS, to->q_flags))
501 				strcat(optbuf, "HDRS");
502 			else
503 				strcat(optbuf, "FULL");
504 		}
505 
506 		/* ORCPT= parameter */
507 		if (to->q_orcpt != NULL)
508 		{
509 			strcat(optbuf, " ORCPT=");
510 			strcat(optbuf, to->q_orcpt);
511 		}
512 	}
513 	else if (bitset(QPINGONSUCCESS, to->q_flags))
514 	{
515 		to->q_flags |= QRELAYED;
516 		fprintf(e->e_xfp, "%s... relayed; expect no further notifications\n",
517 			to->q_paddr);
518 	}
519 
520 	smtpmessage("RCPT To:<%s>%s", m, mci, to->q_user, optbuf);
521 
522 	SmtpPhase = mci->mci_phase = "client RCPT";
523 	setproctitle("%s %s: %s", e->e_id, CurHostName, mci->mci_phase);
524 	r = reply(m, mci, e, TimeOuts.to_rcpt, NULL);
525 	setstatus(to, SmtpReplyBuffer);
526 	if (r < 0 || REPLYTYPE(r) == 4)
527 		return (EX_TEMPFAIL);
528 	else if (REPLYTYPE(r) == 2)
529 		return (EX_OK);
530 	else if (r == 550 || r == 551 || r == 553)
531 		return (EX_NOUSER);
532 	else if (r == 552 || r == 554)
533 		return (EX_UNAVAILABLE);
534 
535 #ifdef LOG
536 	if (LogLevel > 1)
537 	{
538 		syslog(LOG_CRIT, "%s: %s: SMTP RCPT protocol error: %s",
539 			e->e_id, mci->mci_host, SmtpReplyBuffer);
540 	}
541 #endif
542 
543 	return (EX_PROTOCOL);
544 }
545 /*
546 **  SMTPDATA -- send the data and clean up the transaction.
547 **
548 **	Parameters:
549 **		m -- mailer being sent to.
550 **		e -- the envelope for this message.
551 **
552 **	Returns:
553 **		exit status corresponding to DATA command.
554 **
555 **	Side Effects:
556 **		none.
557 */
558 
559 static jmp_buf	CtxDataTimeout;
560 static int	datatimeout();
561 
562 smtpdata(m, mci, e)
563 	struct mailer *m;
564 	register MCI *mci;
565 	register ENVELOPE *e;
566 {
567 	register int r;
568 	register EVENT *ev;
569 	time_t timeout;
570 
571 	/*
572 	**  Send the data.
573 	**	First send the command and check that it is ok.
574 	**	Then send the data.
575 	**	Follow it up with a dot to terminate.
576 	**	Finally get the results of the transaction.
577 	*/
578 
579 	/* send the command and check ok to proceed */
580 	smtpmessage("DATA", m, mci);
581 	SmtpPhase = mci->mci_phase = "client DATA 354";
582 	setproctitle("%s %s: %s", e->e_id, CurHostName, mci->mci_phase);
583 	r = reply(m, mci, e, TimeOuts.to_datainit, NULL);
584 	if (r < 0 || REPLYTYPE(r) == 4)
585 	{
586 		smtpquit(m, mci, e);
587 		return (EX_TEMPFAIL);
588 	}
589 	else if (r == 554)
590 	{
591 		smtprset(m, mci, e);
592 		return (EX_UNAVAILABLE);
593 	}
594 	else if (r != 354)
595 	{
596 #ifdef LOG
597 		if (LogLevel > 1)
598 		{
599 			syslog(LOG_CRIT, "%s: %s: SMTP DATA-1 protocol error: %s",
600 				e->e_id, mci->mci_host, SmtpReplyBuffer);
601 		}
602 #endif
603 		smtprset(m, mci, e);
604 		return (EX_PROTOCOL);
605 	}
606 
607 	/*
608 	**  Set timeout around data writes.  Make it at least large
609 	**  enough for DNS timeouts on all recipients plus some fudge
610 	**  factor.  The main thing is that it should not be infinite.
611 	*/
612 
613 	if (setjmp(CtxDataTimeout) != 0)
614 	{
615 		mci->mci_errno = errno;
616 		mci->mci_exitstat = EX_TEMPFAIL;
617 		mci->mci_state = MCIS_ERROR;
618 		syserr("451 timeout writing message to %s", mci->mci_host);
619 		smtpquit(m, mci, e);
620 		return EX_TEMPFAIL;
621 	}
622 
623 	timeout = e->e_msgsize / 16;
624 	if (timeout < (time_t) 60)
625 		timeout = (time_t) 60;
626 	timeout += e->e_nrcpts * 90;
627 	ev = setevent(timeout, datatimeout, 0);
628 
629 	/*
630 	**  Output the actual message.
631 	*/
632 
633 	(*e->e_puthdr)(mci, e->e_header, e, 0);
634 	(*e->e_putbody)(mci, e, NULL, 0);
635 
636 	/*
637 	**  Cleanup after sending message.
638 	*/
639 
640 	clrevent(ev);
641 
642 	if (ferror(mci->mci_out))
643 	{
644 		/* error during processing -- don't send the dot */
645 		mci->mci_errno = EIO;
646 		mci->mci_exitstat = EX_IOERR;
647 		mci->mci_state = MCIS_ERROR;
648 		smtpquit(m, mci, e);
649 		return EX_IOERR;
650 	}
651 
652 	/* terminate the message */
653 	fprintf(mci->mci_out, ".%s", m->m_eol);
654 	if (TrafficLogFile != NULL)
655 		fprintf(TrafficLogFile, "%05d >>> .\n", getpid());
656 	if (Verbose)
657 		nmessage(">>> .");
658 
659 	/* check for the results of the transaction */
660 	SmtpPhase = mci->mci_phase = "client DATA 250";
661 	setproctitle("%s %s: %s", e->e_id, CurHostName, mci->mci_phase);
662 	r = reply(m, mci, e, TimeOuts.to_datafinal, NULL);
663 	if (r < 0)
664 	{
665 		smtpquit(m, mci, e);
666 		return (EX_TEMPFAIL);
667 	}
668 	mci->mci_state = MCIS_OPEN;
669 	e->e_statmsg = newstr(&SmtpReplyBuffer[4]);
670 	if (REPLYTYPE(r) == 4)
671 		return (EX_TEMPFAIL);
672 	else if (r == 250)
673 		return (EX_OK);
674 	else if (r == 552 || r == 554)
675 		return (EX_UNAVAILABLE);
676 #ifdef LOG
677 	if (LogLevel > 1)
678 	{
679 		syslog(LOG_CRIT, "%s: %s: SMTP DATA-2 protocol error: %s",
680 			e->e_id, mci->mci_host, SmtpReplyBuffer);
681 	}
682 #endif
683 	return (EX_PROTOCOL);
684 }
685 
686 
687 static int
688 datatimeout()
689 {
690 	longjmp(CtxDataTimeout, 1);
691 }
692 /*
693 **  SMTPQUIT -- close the SMTP connection.
694 **
695 **	Parameters:
696 **		m -- a pointer to the mailer.
697 **
698 **	Returns:
699 **		none.
700 **
701 **	Side Effects:
702 **		sends the final protocol and closes the connection.
703 */
704 
705 smtpquit(m, mci, e)
706 	register MAILER *m;
707 	register MCI *mci;
708 	ENVELOPE *e;
709 {
710 	bool oldSuprErrs = SuprErrs;
711 
712 	/*
713 	**	Suppress errors here -- we may be processing a different
714 	**	job when we do the quit connection, and we don't want the
715 	**	new job to be penalized for something that isn't it's
716 	**	problem.
717 	*/
718 
719 	SuprErrs = TRUE;
720 
721 	/* send the quit message if we haven't gotten I/O error */
722 	if (mci->mci_state != MCIS_ERROR)
723 	{
724 		SmtpPhase = "client QUIT";
725 		smtpmessage("QUIT", m, mci);
726 		(void) reply(m, mci, e, TimeOuts.to_quit, NULL);
727 		SuprErrs = oldSuprErrs;
728 		if (mci->mci_state == MCIS_CLOSED)
729 		{
730 			SuprErrs = oldSuprErrs;
731 			return;
732 		}
733 	}
734 
735 	/* now actually close the connection and pick up the zombie */
736 	(void) endmailer(mci, e, NULL);
737 
738 	SuprErrs = oldSuprErrs;
739 }
740 /*
741 **  SMTPRSET -- send a RSET (reset) command
742 */
743 
744 smtprset(m, mci, e)
745 	register MAILER *m;
746 	register MCI *mci;
747 	ENVELOPE *e;
748 {
749 	int r;
750 
751 	SmtpPhase = "client RSET";
752 	smtpmessage("RSET", m, mci);
753 	r = reply(m, mci, e, TimeOuts.to_rset, NULL);
754 	if (r < 0)
755 		mci->mci_state = MCIS_ERROR;
756 	else if (REPLYTYPE(r) == 2)
757 	{
758 		mci->mci_state = MCIS_OPEN;
759 		return;
760 	}
761 	smtpquit(m, mci, e);
762 }
763 /*
764 **  SMTPPROBE -- check the connection state
765 */
766 
767 smtpprobe(mci)
768 	register MCI *mci;
769 {
770 	int r;
771 	MAILER *m = mci->mci_mailer;
772 	extern ENVELOPE BlankEnvelope;
773 	ENVELOPE *e = &BlankEnvelope;
774 
775 	SmtpPhase = "client probe";
776 	smtpmessage("RSET", m, mci);
777 	r = reply(m, mci, e, TimeOuts.to_miscshort, NULL);
778 	if (r < 0 || REPLYTYPE(r) != 2)
779 		smtpquit(m, mci, e);
780 	return r;
781 }
782 /*
783 **  REPLY -- read arpanet reply
784 **
785 **	Parameters:
786 **		m -- the mailer we are reading the reply from.
787 **		mci -- the mailer connection info structure.
788 **		e -- the current envelope.
789 **		timeout -- the timeout for reads.
790 **		pfunc -- processing function for second and subsequent
791 **			lines of response -- if null, no special
792 **			processing is done.
793 **
794 **	Returns:
795 **		reply code it reads.
796 **
797 **	Side Effects:
798 **		flushes the mail file.
799 */
800 
801 reply(m, mci, e, timeout, pfunc)
802 	MAILER *m;
803 	MCI *mci;
804 	ENVELOPE *e;
805 	time_t timeout;
806 	void (*pfunc)();
807 {
808 	register char *bufp;
809 	register int r;
810 	bool firstline = TRUE;
811 	char junkbuf[MAXLINE];
812 
813 	if (mci->mci_out != NULL)
814 		(void) fflush(mci->mci_out);
815 
816 	if (tTd(18, 1))
817 		printf("reply\n");
818 
819 	/*
820 	**  Read the input line, being careful not to hang.
821 	*/
822 
823 	for (bufp = SmtpReplyBuffer;; bufp = junkbuf)
824 	{
825 		register char *p;
826 		extern time_t curtime();
827 
828 		/* actually do the read */
829 		if (e->e_xfp != NULL)
830 			(void) fflush(e->e_xfp);	/* for debugging */
831 
832 		/* if we are in the process of closing just give the code */
833 		if (mci->mci_state == MCIS_CLOSED)
834 			return (SMTPCLOSING);
835 
836 		if (mci->mci_out != NULL)
837 			fflush(mci->mci_out);
838 
839 		/* get the line from the other side */
840 		p = sfgets(bufp, MAXLINE, mci->mci_in, timeout, SmtpPhase);
841 		mci->mci_lastuse = curtime();
842 
843 		if (p == NULL)
844 		{
845 			bool oldholderrs;
846 			extern char MsgBuf[];		/* err.c */
847 
848 			/* if the remote end closed early, fake an error */
849 			if (errno == 0)
850 # ifdef ECONNRESET
851 				errno = ECONNRESET;
852 # else /* ECONNRESET */
853 				errno = EPIPE;
854 # endif /* ECONNRESET */
855 
856 			mci->mci_errno = errno;
857 			mci->mci_exitstat = EX_TEMPFAIL;
858 			oldholderrs = HoldErrs;
859 			HoldErrs = TRUE;
860 			usrerr("451 reply: read error from %s", mci->mci_host);
861 
862 			/* if debugging, pause so we can see state */
863 			if (tTd(18, 100))
864 				pause();
865 			mci->mci_state = MCIS_ERROR;
866 			smtpquit(m, mci, e);
867 #ifdef XDEBUG
868 			{
869 				char wbuf[MAXLINE];
870 				char *p = wbuf;
871 				if (e->e_to != NULL)
872 				{
873 					sprintf(p, "%s... ", e->e_to);
874 					p += strlen(p);
875 				}
876 				sprintf(p, "reply(%s) during %s",
877 					mci->mci_host, SmtpPhase);
878 				checkfd012(wbuf);
879 			}
880 #endif
881 			HoldErrs = oldholderrs;
882 			return (-1);
883 		}
884 		fixcrlf(bufp, TRUE);
885 
886 		/* EHLO failure is not a real error */
887 		if (e->e_xfp != NULL && (bufp[0] == '4' ||
888 		    (bufp[0] == '5' && strncmp(SmtpMsgBuffer, "EHLO", 4) != 0)))
889 		{
890 			/* serious error -- log the previous command */
891 			if (SmtpNeedIntro)
892 			{
893 				/* inform user who we are chatting with */
894 				fprintf(CurEnv->e_xfp,
895 					"... while talking to %s:\n",
896 					CurHostName);
897 				SmtpNeedIntro = FALSE;
898 			}
899 			if (SmtpMsgBuffer[0] != '\0')
900 				fprintf(e->e_xfp, ">>> %s\n", SmtpMsgBuffer);
901 			SmtpMsgBuffer[0] = '\0';
902 
903 			/* now log the message as from the other side */
904 			fprintf(e->e_xfp, "<<< %s\n", bufp);
905 		}
906 
907 		/* display the input for verbose mode */
908 		if (Verbose)
909 			nmessage("050 %s", bufp);
910 
911 		/* process the line */
912 		if (pfunc != NULL)
913 			(*pfunc)(bufp, firstline, m, mci, e);
914 
915 		firstline = FALSE;
916 
917 		/* if continuation is required, we can go on */
918 		if (bufp[3] == '-')
919 			continue;
920 
921 		/* ignore improperly formated input */
922 		if (!(isascii(bufp[0]) && isdigit(bufp[0])))
923 			continue;
924 
925 		/* decode the reply code */
926 		r = atoi(bufp);
927 
928 		/* extra semantics: 0xx codes are "informational" */
929 		if (r >= 100)
930 			break;
931 	}
932 
933 	/*
934 	**  Now look at SmtpReplyBuffer -- only care about the first
935 	**  line of the response from here on out.
936 	*/
937 
938 	/* save temporary failure messages for posterity */
939 	if (SmtpReplyBuffer[0] == '4' && SmtpError[0] == '\0')
940 		(void) strcpy(SmtpError, SmtpReplyBuffer);
941 
942 	/* reply code 421 is "Service Shutting Down" */
943 	if (r == SMTPCLOSING && mci->mci_state != MCIS_SSD)
944 	{
945 		/* send the quit protocol */
946 		mci->mci_state = MCIS_SSD;
947 		smtpquit(m, mci, e);
948 	}
949 
950 	return (r);
951 }
952 /*
953 **  SMTPMESSAGE -- send message to server
954 **
955 **	Parameters:
956 **		f -- format
957 **		m -- the mailer to control formatting.
958 **		a, b, c -- parameters
959 **
960 **	Returns:
961 **		none.
962 **
963 **	Side Effects:
964 **		writes message to mci->mci_out.
965 */
966 
967 /*VARARGS1*/
968 #ifdef __STDC__
969 smtpmessage(char *f, MAILER *m, MCI *mci, ...)
970 #else
971 smtpmessage(f, m, mci, va_alist)
972 	char *f;
973 	MAILER *m;
974 	MCI *mci;
975 	va_dcl
976 #endif
977 {
978 	VA_LOCAL_DECL
979 
980 	VA_START(mci);
981 	(void) vsprintf(SmtpMsgBuffer, f, ap);
982 	VA_END;
983 
984 	if (tTd(18, 1) || Verbose)
985 		nmessage(">>> %s", SmtpMsgBuffer);
986 	if (TrafficLogFile != NULL)
987 		fprintf(TrafficLogFile, "%05d >>> %s\n", getpid(), SmtpMsgBuffer);
988 	if (mci->mci_out != NULL)
989 	{
990 		fprintf(mci->mci_out, "%s%s", SmtpMsgBuffer,
991 			m == NULL ? "\r\n" : m->m_eol);
992 	}
993 	else if (tTd(18, 1))
994 	{
995 		printf("smtpmessage: NULL mci_out\n");
996 	}
997 }
998 
999 # endif /* SMTP */
1000