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.32 (Berkeley) 12/10/94 (with SMTP)";
14 #else
15 static char sccsid[] = "@(#)usersmtp.c	8.32 (Berkeley) 12/10/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 		return EX_OK;
419 	}
420 	else if (r == 501 || r == 553)
421 	{
422 		/* syntax error in arguments */
423 		smtpquit(m, mci, e);
424 		return EX_DATAERR;
425 	}
426 	else if (r == 552)
427 	{
428 		/* signal service unavailable */
429 		smtpquit(m, mci, e);
430 		return EX_UNAVAILABLE;
431 	}
432 
433 #ifdef LOG
434 	if (LogLevel > 1)
435 	{
436 		syslog(LOG_CRIT, "%s: %s: SMTP MAIL protocol error: %s",
437 			e->e_id, mci->mci_host, SmtpReplyBuffer);
438 	}
439 #endif
440 
441 	/* protocol error -- close up */
442 	smtpquit(m, mci, e);
443 	return EX_PROTOCOL;
444 }
445 /*
446 **  SMTPRCPT -- designate recipient.
447 **
448 **	Parameters:
449 **		to -- address of recipient.
450 **		m -- the mailer we are sending to.
451 **		mci -- the connection info for this transaction.
452 **		e -- the envelope for this transaction.
453 **
454 **	Returns:
455 **		exit status corresponding to recipient status.
456 **
457 **	Side Effects:
458 **		Sends the mail via SMTP.
459 */
460 
461 smtprcpt(to, m, mci, e)
462 	ADDRESS *to;
463 	register MAILER *m;
464 	MCI *mci;
465 	ENVELOPE *e;
466 {
467 	register int r;
468 	char optbuf[MAXLINE];
469 
470 	strcpy(optbuf, "");
471 	if (bitset(MCIF_DSN, mci->mci_flags))
472 	{
473 		bool firstone = TRUE;
474 
475 		/* NOTIFY= parameter */
476 		strcat(optbuf, " NOTIFY=");
477 		if (bitset(QPINGONSUCCESS, to->q_flags))
478 		{
479 			strcat(optbuf, "SUCCESS");
480 			firstone = FALSE;
481 		}
482 		if (bitset(QPINGONFAILURE, to->q_flags))
483 		{
484 			if (!firstone)
485 				strcat(optbuf, ",");
486 			strcat(optbuf, "FAILURE");
487 			firstone = FALSE;
488 		}
489 		if (bitset(QPINGONDELAY, to->q_flags))
490 		{
491 			if (!firstone)
492 				strcat(optbuf, ",");
493 			strcat(optbuf, "DELAY");
494 			firstone = FALSE;
495 		}
496 		if (firstone)
497 			strcat(optbuf, "NEVER");
498 
499 		/* RET= parameter */
500 		if (bitset(QHAS_RET_PARAM, to->q_flags))
501 		{
502 			strcat(optbuf, " RET=");
503 			if (bitset(QRET_HDRS, to->q_flags))
504 				strcat(optbuf, "HDRS");
505 			else
506 				strcat(optbuf, "FULL");
507 		}
508 
509 		/* ORCPT= parameter */
510 		if (to->q_orcpt != NULL)
511 		{
512 			strcat(optbuf, " ORCPT=");
513 			strcat(optbuf, to->q_orcpt);
514 		}
515 	}
516 	else if (bitset(QPINGONSUCCESS, to->q_flags))
517 	{
518 		to->q_flags |= QRELAYED;
519 		fprintf(e->e_xfp, "%s... relayed; expect no further notifications\n",
520 			to->q_paddr);
521 	}
522 
523 	smtpmessage("RCPT To:<%s>%s", m, mci, to->q_user, optbuf);
524 
525 	SmtpPhase = mci->mci_phase = "client RCPT";
526 	setproctitle("%s %s: %s", e->e_id, CurHostName, mci->mci_phase);
527 	r = reply(m, mci, e, TimeOuts.to_rcpt, NULL);
528 	setstatus(to, SmtpReplyBuffer);
529 	if (r < 0 || REPLYTYPE(r) == 4)
530 		return (EX_TEMPFAIL);
531 	else if (REPLYTYPE(r) == 2)
532 		return (EX_OK);
533 	else if (r == 550 || r == 551 || r == 553)
534 		return (EX_NOUSER);
535 	else if (r == 552 || r == 554)
536 		return (EX_UNAVAILABLE);
537 
538 #ifdef LOG
539 	if (LogLevel > 1)
540 	{
541 		syslog(LOG_CRIT, "%s: %s: SMTP RCPT protocol error: %s",
542 			e->e_id, mci->mci_host, SmtpReplyBuffer);
543 	}
544 #endif
545 
546 	return (EX_PROTOCOL);
547 }
548 /*
549 **  SMTPDATA -- send the data and clean up the transaction.
550 **
551 **	Parameters:
552 **		m -- mailer being sent to.
553 **		e -- the envelope for this message.
554 **
555 **	Returns:
556 **		exit status corresponding to DATA command.
557 **
558 **	Side Effects:
559 **		none.
560 */
561 
562 static jmp_buf	CtxDataTimeout;
563 static int	datatimeout();
564 
565 smtpdata(m, mci, e)
566 	struct mailer *m;
567 	register MCI *mci;
568 	register ENVELOPE *e;
569 {
570 	register int r;
571 	register EVENT *ev;
572 	time_t timeout;
573 
574 	/*
575 	**  Send the data.
576 	**	First send the command and check that it is ok.
577 	**	Then send the data.
578 	**	Follow it up with a dot to terminate.
579 	**	Finally get the results of the transaction.
580 	*/
581 
582 	/* send the command and check ok to proceed */
583 	smtpmessage("DATA", m, mci);
584 	SmtpPhase = mci->mci_phase = "client DATA 354";
585 	setproctitle("%s %s: %s", e->e_id, CurHostName, mci->mci_phase);
586 	r = reply(m, mci, e, TimeOuts.to_datainit, NULL);
587 	if (r < 0 || REPLYTYPE(r) == 4)
588 	{
589 		smtpquit(m, mci, e);
590 		return (EX_TEMPFAIL);
591 	}
592 	else if (r == 554)
593 	{
594 		smtprset(m, mci, e);
595 		return (EX_UNAVAILABLE);
596 	}
597 	else if (r != 354)
598 	{
599 #ifdef LOG
600 		if (LogLevel > 1)
601 		{
602 			syslog(LOG_CRIT, "%s: %s: SMTP DATA-1 protocol error: %s",
603 				e->e_id, mci->mci_host, SmtpReplyBuffer);
604 		}
605 #endif
606 		smtprset(m, mci, e);
607 		return (EX_PROTOCOL);
608 	}
609 
610 	/*
611 	**  Set timeout around data writes.  Make it at least large
612 	**  enough for DNS timeouts on all recipients plus some fudge
613 	**  factor.  The main thing is that it should not be infinite.
614 	*/
615 
616 	if (setjmp(CtxDataTimeout) != 0)
617 	{
618 		mci->mci_errno = errno;
619 		mci->mci_exitstat = EX_TEMPFAIL;
620 		mci->mci_state = MCIS_ERROR;
621 		syserr("451 timeout writing message to %s", mci->mci_host);
622 		smtpquit(m, mci, e);
623 		return EX_TEMPFAIL;
624 	}
625 
626 	timeout = e->e_msgsize / 16;
627 	if (timeout < (time_t) 60)
628 		timeout = (time_t) 60;
629 	timeout += e->e_nrcpts * 90;
630 	ev = setevent(timeout, datatimeout, 0);
631 
632 	/*
633 	**  Output the actual message.
634 	*/
635 
636 	(*e->e_puthdr)(mci, e->e_header, e, 0);
637 	(*e->e_putbody)(mci, e, NULL, 0);
638 
639 	/*
640 	**  Cleanup after sending message.
641 	*/
642 
643 	clrevent(ev);
644 
645 	if (ferror(mci->mci_out))
646 	{
647 		/* error during processing -- don't send the dot */
648 		mci->mci_errno = EIO;
649 		mci->mci_exitstat = EX_IOERR;
650 		mci->mci_state = MCIS_ERROR;
651 		smtpquit(m, mci, e);
652 		return EX_IOERR;
653 	}
654 
655 	/* terminate the message */
656 	fprintf(mci->mci_out, ".%s", m->m_eol);
657 	if (TrafficLogFile != NULL)
658 		fprintf(TrafficLogFile, "%05d >>> .\n", getpid());
659 	if (Verbose)
660 		nmessage(">>> .");
661 
662 	/* check for the results of the transaction */
663 	SmtpPhase = mci->mci_phase = "client DATA 250";
664 	setproctitle("%s %s: %s", e->e_id, CurHostName, mci->mci_phase);
665 	r = reply(m, mci, e, TimeOuts.to_datafinal, NULL);
666 	if (r < 0)
667 	{
668 		smtpquit(m, mci, e);
669 		return (EX_TEMPFAIL);
670 	}
671 	mci->mci_state = MCIS_OPEN;
672 	e->e_statmsg = newstr(&SmtpReplyBuffer[4]);
673 	if (REPLYTYPE(r) == 4)
674 		return (EX_TEMPFAIL);
675 	else if (r == 250)
676 		return (EX_OK);
677 	else if (r == 552 || r == 554)
678 		return (EX_UNAVAILABLE);
679 #ifdef LOG
680 	if (LogLevel > 1)
681 	{
682 		syslog(LOG_CRIT, "%s: %s: SMTP DATA-2 protocol error: %s",
683 			e->e_id, mci->mci_host, SmtpReplyBuffer);
684 	}
685 #endif
686 	return (EX_PROTOCOL);
687 }
688 
689 
690 static int
691 datatimeout()
692 {
693 	longjmp(CtxDataTimeout, 1);
694 }
695 /*
696 **  SMTPQUIT -- close the SMTP connection.
697 **
698 **	Parameters:
699 **		m -- a pointer to the mailer.
700 **
701 **	Returns:
702 **		none.
703 **
704 **	Side Effects:
705 **		sends the final protocol and closes the connection.
706 */
707 
708 smtpquit(m, mci, e)
709 	register MAILER *m;
710 	register MCI *mci;
711 	ENVELOPE *e;
712 {
713 	bool oldSuprErrs = SuprErrs;
714 
715 	/*
716 	**	Suppress errors here -- we may be processing a different
717 	**	job when we do the quit connection, and we don't want the
718 	**	new job to be penalized for something that isn't it's
719 	**	problem.
720 	*/
721 
722 	SuprErrs = TRUE;
723 
724 	/* send the quit message if we haven't gotten I/O error */
725 	if (mci->mci_state != MCIS_ERROR)
726 	{
727 		SmtpPhase = "client QUIT";
728 		smtpmessage("QUIT", m, mci);
729 		(void) reply(m, mci, e, TimeOuts.to_quit, NULL);
730 		SuprErrs = oldSuprErrs;
731 		if (mci->mci_state == MCIS_CLOSED)
732 		{
733 			SuprErrs = oldSuprErrs;
734 			return;
735 		}
736 	}
737 
738 	/* now actually close the connection and pick up the zombie */
739 	(void) endmailer(mci, e, NULL);
740 
741 	SuprErrs = oldSuprErrs;
742 }
743 /*
744 **  SMTPRSET -- send a RSET (reset) command
745 */
746 
747 smtprset(m, mci, e)
748 	register MAILER *m;
749 	register MCI *mci;
750 	ENVELOPE *e;
751 {
752 	int r;
753 
754 	SmtpPhase = "client RSET";
755 	smtpmessage("RSET", m, mci);
756 	r = reply(m, mci, e, TimeOuts.to_rset, NULL);
757 	if (r < 0)
758 		mci->mci_state = MCIS_ERROR;
759 	else if (REPLYTYPE(r) == 2)
760 	{
761 		mci->mci_state = MCIS_OPEN;
762 		return;
763 	}
764 	smtpquit(m, mci, e);
765 }
766 /*
767 **  SMTPPROBE -- check the connection state
768 */
769 
770 smtpprobe(mci)
771 	register MCI *mci;
772 {
773 	int r;
774 	MAILER *m = mci->mci_mailer;
775 	extern ENVELOPE BlankEnvelope;
776 	ENVELOPE *e = &BlankEnvelope;
777 
778 	SmtpPhase = "client probe";
779 	smtpmessage("RSET", m, mci);
780 	r = reply(m, mci, e, TimeOuts.to_miscshort, NULL);
781 	if (r < 0 || REPLYTYPE(r) != 2)
782 		smtpquit(m, mci, e);
783 	return r;
784 }
785 /*
786 **  REPLY -- read arpanet reply
787 **
788 **	Parameters:
789 **		m -- the mailer we are reading the reply from.
790 **		mci -- the mailer connection info structure.
791 **		e -- the current envelope.
792 **		timeout -- the timeout for reads.
793 **		pfunc -- processing function for second and subsequent
794 **			lines of response -- if null, no special
795 **			processing is done.
796 **
797 **	Returns:
798 **		reply code it reads.
799 **
800 **	Side Effects:
801 **		flushes the mail file.
802 */
803 
804 reply(m, mci, e, timeout, pfunc)
805 	MAILER *m;
806 	MCI *mci;
807 	ENVELOPE *e;
808 	time_t timeout;
809 	void (*pfunc)();
810 {
811 	register char *bufp;
812 	register int r;
813 	bool firstline = TRUE;
814 	char junkbuf[MAXLINE];
815 
816 	if (mci->mci_out != NULL)
817 		(void) fflush(mci->mci_out);
818 
819 	if (tTd(18, 1))
820 		printf("reply\n");
821 
822 	/*
823 	**  Read the input line, being careful not to hang.
824 	*/
825 
826 	for (bufp = SmtpReplyBuffer;; bufp = junkbuf)
827 	{
828 		register char *p;
829 		extern time_t curtime();
830 
831 		/* actually do the read */
832 		if (e->e_xfp != NULL)
833 			(void) fflush(e->e_xfp);	/* for debugging */
834 
835 		/* if we are in the process of closing just give the code */
836 		if (mci->mci_state == MCIS_CLOSED)
837 			return (SMTPCLOSING);
838 
839 		if (mci->mci_out != NULL)
840 			fflush(mci->mci_out);
841 
842 		/* get the line from the other side */
843 		p = sfgets(bufp, MAXLINE, mci->mci_in, timeout, SmtpPhase);
844 		mci->mci_lastuse = curtime();
845 
846 		if (p == NULL)
847 		{
848 			bool oldholderrs;
849 			extern char MsgBuf[];		/* err.c */
850 
851 			/* if the remote end closed early, fake an error */
852 			if (errno == 0)
853 # ifdef ECONNRESET
854 				errno = ECONNRESET;
855 # else /* ECONNRESET */
856 				errno = EPIPE;
857 # endif /* ECONNRESET */
858 
859 			mci->mci_errno = errno;
860 			mci->mci_exitstat = EX_TEMPFAIL;
861 			oldholderrs = HoldErrs;
862 			HoldErrs = TRUE;
863 			usrerr("451 reply: read error from %s", mci->mci_host);
864 
865 			/* if debugging, pause so we can see state */
866 			if (tTd(18, 100))
867 				pause();
868 			mci->mci_state = MCIS_ERROR;
869 			smtpquit(m, mci, e);
870 #ifdef XDEBUG
871 			{
872 				char wbuf[MAXLINE];
873 				char *p = wbuf;
874 				if (e->e_to != NULL)
875 				{
876 					sprintf(p, "%s... ", e->e_to);
877 					p += strlen(p);
878 				}
879 				sprintf(p, "reply(%s) during %s",
880 					mci->mci_host, SmtpPhase);
881 				checkfd012(wbuf);
882 			}
883 #endif
884 			HoldErrs = oldholderrs;
885 			return (-1);
886 		}
887 		fixcrlf(bufp, TRUE);
888 
889 		/* EHLO failure is not a real error */
890 		if (e->e_xfp != NULL && (bufp[0] == '4' ||
891 		    (bufp[0] == '5' && strncmp(SmtpMsgBuffer, "EHLO", 4) != 0)))
892 		{
893 			/* serious error -- log the previous command */
894 			if (SmtpNeedIntro)
895 			{
896 				/* inform user who we are chatting with */
897 				fprintf(CurEnv->e_xfp,
898 					"... while talking to %s:\n",
899 					CurHostName);
900 				SmtpNeedIntro = FALSE;
901 			}
902 			if (SmtpMsgBuffer[0] != '\0')
903 				fprintf(e->e_xfp, ">>> %s\n", SmtpMsgBuffer);
904 			SmtpMsgBuffer[0] = '\0';
905 
906 			/* now log the message as from the other side */
907 			fprintf(e->e_xfp, "<<< %s\n", bufp);
908 		}
909 
910 		/* display the input for verbose mode */
911 		if (Verbose)
912 			nmessage("050 %s", bufp);
913 
914 		/* process the line */
915 		if (pfunc != NULL)
916 			(*pfunc)(bufp, firstline, m, mci, e);
917 
918 		firstline = FALSE;
919 
920 		/* if continuation is required, we can go on */
921 		if (bufp[3] == '-')
922 			continue;
923 
924 		/* ignore improperly formated input */
925 		if (!(isascii(bufp[0]) && isdigit(bufp[0])))
926 			continue;
927 
928 		/* decode the reply code */
929 		r = atoi(bufp);
930 
931 		/* extra semantics: 0xx codes are "informational" */
932 		if (r >= 100)
933 			break;
934 	}
935 
936 	/*
937 	**  Now look at SmtpReplyBuffer -- only care about the first
938 	**  line of the response from here on out.
939 	*/
940 
941 	/* save temporary failure messages for posterity */
942 	if (SmtpReplyBuffer[0] == '4' && SmtpError[0] == '\0')
943 		(void) strcpy(SmtpError, SmtpReplyBuffer);
944 
945 	/* reply code 421 is "Service Shutting Down" */
946 	if (r == SMTPCLOSING && mci->mci_state != MCIS_SSD)
947 	{
948 		/* send the quit protocol */
949 		mci->mci_state = MCIS_SSD;
950 		smtpquit(m, mci, e);
951 	}
952 
953 	return (r);
954 }
955 /*
956 **  SMTPMESSAGE -- send message to server
957 **
958 **	Parameters:
959 **		f -- format
960 **		m -- the mailer to control formatting.
961 **		a, b, c -- parameters
962 **
963 **	Returns:
964 **		none.
965 **
966 **	Side Effects:
967 **		writes message to mci->mci_out.
968 */
969 
970 /*VARARGS1*/
971 #ifdef __STDC__
972 smtpmessage(char *f, MAILER *m, MCI *mci, ...)
973 #else
974 smtpmessage(f, m, mci, va_alist)
975 	char *f;
976 	MAILER *m;
977 	MCI *mci;
978 	va_dcl
979 #endif
980 {
981 	VA_LOCAL_DECL
982 
983 	VA_START(mci);
984 	(void) vsprintf(SmtpMsgBuffer, f, ap);
985 	VA_END;
986 
987 	if (tTd(18, 1) || Verbose)
988 		nmessage(">>> %s", SmtpMsgBuffer);
989 	if (TrafficLogFile != NULL)
990 		fprintf(TrafficLogFile, "%05d >>> %s\n", getpid(), SmtpMsgBuffer);
991 	if (mci->mci_out != NULL)
992 	{
993 		fprintf(mci->mci_out, "%s%s", SmtpMsgBuffer,
994 			m == NULL ? "\r\n" : m->m_eol);
995 	}
996 	else if (tTd(18, 1))
997 	{
998 		printf("smtpmessage: NULL mci_out\n");
999 	}
1000 }
1001 
1002 # endif /* SMTP */
1003