xref: /freebsd/contrib/sendmail/src/mci.c (revision bb15ca603fa442c72dde3f3cb8b46db6970e3950)
1 /*
2  * Copyright (c) 1998-2005, 2010 Sendmail, Inc. and its suppliers.
3  *	All rights reserved.
4  * Copyright (c) 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  */
13 
14 #include <sendmail.h>
15 
16 SM_RCSID("@(#)$Id: mci.c,v 8.223 2010/03/10 04:35:28 ca Exp $")
17 
18 #if NETINET || NETINET6
19 # include <arpa/inet.h>
20 #endif /* NETINET || NETINET6 */
21 
22 #include <dirent.h>
23 
24 static int	mci_generate_persistent_path __P((const char *, char *,
25 						  int, bool));
26 static bool	mci_load_persistent __P((MCI *));
27 static void	mci_uncache __P((MCI **, bool));
28 static int	mci_lock_host_statfile __P((MCI *));
29 static int	mci_read_persistent __P((SM_FILE_T *, MCI *));
30 
31 /*
32 **  Mail Connection Information (MCI) Caching Module.
33 **
34 **	There are actually two separate things cached.  The first is
35 **	the set of all open connections -- these are stored in a
36 **	(small) list.  The second is stored in the symbol table; it
37 **	has the overall status for all hosts, whether or not there
38 **	is a connection open currently.
39 **
40 **	There should never be too many connections open (since this
41 **	could flood the socket table), nor should a connection be
42 **	allowed to sit idly for too long.
43 **
44 **	MaxMciCache is the maximum number of open connections that
45 **	will be supported.
46 **
47 **	MciCacheTimeout is the time (in seconds) that a connection
48 **	is permitted to survive without activity.
49 **
50 **	We actually try any cached connections by sending a RSET
51 **	before we use them; if the RSET fails we close down the
52 **	connection and reopen it (see smtpprobe()).
53 **
54 **	The persistent MCI code is donated by Mark Lovell and Paul
55 **	Vixie.  It is based on the long term host status code in KJS
56 **	written by Paul but has been adapted by Mark to fit into the
57 **	MCI structure.
58 */
59 
60 static MCI	**MciCache;		/* the open connection cache */
61 
62 /*
63 **  MCI_CACHE -- enter a connection structure into the open connection cache
64 **
65 **	This may cause something else to be flushed.
66 **
67 **	Parameters:
68 **		mci -- the connection to cache.
69 **
70 **	Returns:
71 **		none.
72 */
73 
74 void
75 mci_cache(mci)
76 	register MCI *mci;
77 {
78 	register MCI **mcislot;
79 
80 	/*
81 	**  Find the best slot.  This may cause expired connections
82 	**  to be closed.
83 	*/
84 
85 	mcislot = mci_scan(mci);
86 	if (mcislot == NULL)
87 	{
88 		/* we don't support caching */
89 		return;
90 	}
91 
92 	if (mci->mci_host == NULL)
93 		return;
94 
95 	/* if this is already cached, we are done */
96 	if (bitset(MCIF_CACHED, mci->mci_flags))
97 		return;
98 
99 	/* otherwise we may have to clear the slot */
100 	if (*mcislot != NULL)
101 		mci_uncache(mcislot, true);
102 
103 	if (tTd(42, 5))
104 		sm_dprintf("mci_cache: caching %p (%s) in slot %d\n",
105 			   mci, mci->mci_host, (int) (mcislot - MciCache));
106 	if (tTd(91, 100))
107 		sm_syslog(LOG_DEBUG, CurEnv->e_id,
108 			  "mci_cache: caching %lx (%.100s) in slot %d",
109 			  (unsigned long) mci, mci->mci_host,
110 			  (int) (mcislot - MciCache));
111 
112 	*mcislot = mci;
113 	mci->mci_flags |= MCIF_CACHED;
114 }
115 /*
116 **  MCI_SCAN -- scan the cache, flush junk, and return best slot
117 **
118 **	Parameters:
119 **		savemci -- never flush this one.  Can be null.
120 **
121 **	Returns:
122 **		The LRU (or empty) slot.
123 */
124 
125 MCI **
126 mci_scan(savemci)
127 	MCI *savemci;
128 {
129 	time_t now;
130 	register MCI **bestmci;
131 	register MCI *mci;
132 	register int i;
133 
134 	if (MaxMciCache <= 0)
135 	{
136 		/* we don't support caching */
137 		return NULL;
138 	}
139 
140 	if (MciCache == NULL)
141 	{
142 		/* first call */
143 		MciCache = (MCI **) sm_pmalloc_x(MaxMciCache * sizeof(*MciCache));
144 		memset((char *) MciCache, '\0', MaxMciCache * sizeof(*MciCache));
145 		return &MciCache[0];
146 	}
147 
148 	now = curtime();
149 	bestmci = &MciCache[0];
150 	for (i = 0; i < MaxMciCache; i++)
151 	{
152 		mci = MciCache[i];
153 		if (mci == NULL || mci->mci_state == MCIS_CLOSED)
154 		{
155 			bestmci = &MciCache[i];
156 			continue;
157 		}
158 		if ((mci->mci_lastuse + MciCacheTimeout <= now ||
159 		     (mci->mci_mailer != NULL &&
160 		      mci->mci_mailer->m_maxdeliveries > 0 &&
161 		      mci->mci_deliveries + 1 >= mci->mci_mailer->m_maxdeliveries))&&
162 		    mci != savemci)
163 		{
164 			/* connection idle too long or too many deliveries */
165 			bestmci = &MciCache[i];
166 
167 			/* close it */
168 			mci_uncache(bestmci, true);
169 			continue;
170 		}
171 		if (*bestmci == NULL)
172 			continue;
173 		if (mci->mci_lastuse < (*bestmci)->mci_lastuse)
174 			bestmci = &MciCache[i];
175 	}
176 	return bestmci;
177 }
178 /*
179 **  MCI_UNCACHE -- remove a connection from a slot.
180 **
181 **	May close a connection.
182 **
183 **	Parameters:
184 **		mcislot -- the slot to empty.
185 **		doquit -- if true, send QUIT protocol on this connection.
186 **			  if false, we are assumed to be in a forked child;
187 **				all we want to do is close the file(s).
188 **
189 **	Returns:
190 **		none.
191 */
192 
193 static void
194 mci_uncache(mcislot, doquit)
195 	register MCI **mcislot;
196 	bool doquit;
197 {
198 	register MCI *mci;
199 	extern ENVELOPE BlankEnvelope;
200 
201 	mci = *mcislot;
202 	if (mci == NULL)
203 		return;
204 	*mcislot = NULL;
205 	if (mci->mci_host == NULL)
206 		return;
207 
208 	mci_unlock_host(mci);
209 
210 	if (tTd(42, 5))
211 		sm_dprintf("mci_uncache: uncaching %p (%s) from slot %d (%d)\n",
212 			   mci, mci->mci_host, (int) (mcislot - MciCache),
213 			   doquit);
214 	if (tTd(91, 100))
215 		sm_syslog(LOG_DEBUG, CurEnv->e_id,
216 			  "mci_uncache: uncaching %lx (%.100s) from slot %d (%d)",
217 			  (unsigned long) mci, mci->mci_host,
218 			  (int) (mcislot - MciCache), doquit);
219 
220 	mci->mci_deliveries = 0;
221 	if (doquit)
222 	{
223 		message("Closing connection to %s", mci->mci_host);
224 
225 		mci->mci_flags &= ~MCIF_CACHED;
226 
227 		/* only uses the envelope to flush the transcript file */
228 		if (mci->mci_state != MCIS_CLOSED)
229 			smtpquit(mci->mci_mailer, mci, &BlankEnvelope);
230 #if XLA
231 		xla_host_end(mci->mci_host);
232 #endif /* XLA */
233 	}
234 	else
235 	{
236 		if (mci->mci_in != NULL)
237 			(void) sm_io_close(mci->mci_in, SM_TIME_DEFAULT);
238 		if (mci->mci_out != NULL)
239 			(void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT);
240 		mci->mci_in = mci->mci_out = NULL;
241 		mci->mci_state = MCIS_CLOSED;
242 		mci->mci_exitstat = EX_OK;
243 		mci->mci_errno = 0;
244 		mci->mci_flags = 0;
245 
246 		mci->mci_retryrcpt = false;
247 		mci->mci_tolist = NULL;
248 #if PIPELINING
249 		mci->mci_okrcpts = 0;
250 #endif /* PIPELINING */
251 	}
252 
253 	SM_FREE_CLR(mci->mci_status);
254 	SM_FREE_CLR(mci->mci_rstatus);
255 	SM_FREE_CLR(mci->mci_heloname);
256 	if (mci->mci_rpool != NULL)
257 	{
258 		sm_rpool_free(mci->mci_rpool);
259 		mci->mci_macro.mac_rpool = NULL;
260 		mci->mci_rpool = NULL;
261 	}
262 }
263 /*
264 **  MCI_FLUSH -- flush the entire cache
265 **
266 **	Parameters:
267 **		doquit -- if true, send QUIT protocol.
268 **			  if false, just close the connection.
269 **		allbut -- but leave this one open.
270 **
271 **	Returns:
272 **		none.
273 */
274 
275 void
276 mci_flush(doquit, allbut)
277 	bool doquit;
278 	MCI *allbut;
279 {
280 	register int i;
281 
282 	if (MciCache == NULL)
283 		return;
284 
285 	for (i = 0; i < MaxMciCache; i++)
286 	{
287 		if (allbut != MciCache[i])
288 			mci_uncache(&MciCache[i], doquit);
289 	}
290 }
291 
292 /*
293 **  MCI_CLR_EXTENSIONS -- clear knowledge about SMTP extensions
294 **
295 **	Parameters:
296 **		mci -- the connection to clear.
297 **
298 **	Returns:
299 **		none.
300 */
301 
302 void
303 mci_clr_extensions(mci)
304 	MCI *mci;
305 {
306 	if (mci == NULL)
307 		return;
308 
309 	mci->mci_flags &= ~MCIF_EXTENS;
310 	mci->mci_maxsize = 0;
311 	mci->mci_min_by = 0;
312 #if SASL
313 	mci->mci_saslcap = NULL;
314 #endif /* SASL */
315 }
316 
317 /*
318 **  MCI_GET -- get information about a particular host
319 **
320 **	Parameters:
321 **		host -- host to look for.
322 **		m -- mailer.
323 **
324 **	Returns:
325 **		mci for this host (might be new).
326 */
327 
328 MCI *
329 mci_get(host, m)
330 	char *host;
331 	MAILER *m;
332 {
333 	register MCI *mci;
334 	register STAB *s;
335 	extern SOCKADDR CurHostAddr;
336 
337 	/* clear CurHostAddr so we don't get a bogus address with this name */
338 	memset(&CurHostAddr, '\0', sizeof(CurHostAddr));
339 
340 	/* clear out any expired connections */
341 	(void) mci_scan(NULL);
342 
343 	if (m->m_mno < 0)
344 		syserr("!negative mno %d (%s)", m->m_mno, m->m_name);
345 
346 	s = stab(host, ST_MCI + m->m_mno, ST_ENTER);
347 	mci = &s->s_mci;
348 
349 	/* initialize per-message data */
350 	mci->mci_retryrcpt = false;
351 	mci->mci_tolist = NULL;
352 #if PIPELINING
353 	mci->mci_okrcpts = 0;
354 #endif /* PIPELINING */
355 
356 	if (mci->mci_rpool == NULL)
357 		mci->mci_rpool = sm_rpool_new_x(NULL);
358 
359 	if (mci->mci_macro.mac_rpool == NULL)
360 		mci->mci_macro.mac_rpool = mci->mci_rpool;
361 
362 	/*
363 	**  We don't need to load the persistent data if we have data
364 	**  already loaded in the cache.
365 	*/
366 
367 	if (mci->mci_host == NULL &&
368 	    (mci->mci_host = s->s_name) != NULL &&
369 	    !mci_load_persistent(mci))
370 	{
371 		if (tTd(42, 2))
372 			sm_dprintf("mci_get(%s %s): lock failed\n",
373 				host, m->m_name);
374 		mci->mci_exitstat = EX_TEMPFAIL;
375 		mci->mci_state = MCIS_CLOSED;
376 		mci->mci_statfile = NULL;
377 		return mci;
378 	}
379 
380 	if (tTd(42, 2))
381 	{
382 		sm_dprintf("mci_get(%s %s): mci_state=%d, _flags=%lx, _exitstat=%d, _errno=%d\n",
383 			host, m->m_name, mci->mci_state, mci->mci_flags,
384 			mci->mci_exitstat, mci->mci_errno);
385 	}
386 
387 	if (mci->mci_state == MCIS_OPEN)
388 	{
389 		/* poke the connection to see if it's still alive */
390 		(void) smtpprobe(mci);
391 
392 		/* reset the stored state in the event of a timeout */
393 		if (mci->mci_state != MCIS_OPEN)
394 		{
395 			mci->mci_errno = 0;
396 			mci->mci_exitstat = EX_OK;
397 			mci->mci_state = MCIS_CLOSED;
398 		}
399 		else
400 		{
401 			/* get peer host address */
402 			/* (this should really be in the mci struct) */
403 			SOCKADDR_LEN_T socklen = sizeof(CurHostAddr);
404 
405 			(void) getpeername(sm_io_getinfo(mci->mci_in,
406 							 SM_IO_WHAT_FD, NULL),
407 				(struct sockaddr *) &CurHostAddr, &socklen);
408 		}
409 	}
410 	if (mci->mci_state == MCIS_CLOSED)
411 	{
412 		time_t now = curtime();
413 
414 		/* if this info is stale, ignore it */
415 		if (mci->mci_lastuse + MciInfoTimeout <= now)
416 		{
417 			mci->mci_lastuse = now;
418 			mci->mci_errno = 0;
419 			mci->mci_exitstat = EX_OK;
420 		}
421 	}
422 
423 	return mci;
424 }
425 
426 /*
427 **  MCI_CLOSE -- (forcefully) close files used for a connection.
428 **	Note: this is a last resort, usually smtpquit() or endmailer()
429 **		should be used to close a connection.
430 **
431 **	Parameters:
432 **		mci -- the connection to close.
433 **		where -- where has this been called?
434 **
435 **	Returns:
436 **		none.
437 */
438 
439 void
440 mci_close(mci, where)
441 	MCI *mci;
442 	char *where;
443 {
444 	bool dumped;
445 
446 	if (mci == NULL)
447 		return;
448 	dumped = false;
449 	if (mci->mci_out != NULL)
450 	{
451 		if (tTd(56, 1))
452 		{
453 			sm_dprintf("mci_close: mci_out!=NULL, where=%s\n",
454 				where);
455 			mci_dump(sm_debug_file(), mci, false);
456 			dumped = true;
457 		}
458 		(void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT);
459 		mci->mci_out = NULL;
460 	}
461 	if (mci->mci_in != NULL)
462 	{
463 		if (tTd(56, 1))
464 		{
465 			sm_dprintf("mci_close: mci_in!=NULL, where=%s\n",
466 				where);
467 			if (!dumped)
468 				mci_dump(sm_debug_file(), mci, false);
469 		}
470 		(void) sm_io_close(mci->mci_in, SM_TIME_DEFAULT);
471 		mci->mci_in = NULL;
472 	}
473 	mci->mci_state = MCIS_CLOSED;
474 }
475 
476 /*
477 **  MCI_NEW -- allocate new MCI structure
478 **
479 **	Parameters:
480 **		rpool -- if non-NULL: allocate from that rpool.
481 **
482 **	Returns:
483 **		mci (new).
484 */
485 
486 MCI *
487 mci_new(rpool)
488 	SM_RPOOL_T *rpool;
489 {
490 	register MCI *mci;
491 
492 	if (rpool == NULL)
493 		mci = (MCI *) sm_malloc_x(sizeof(*mci));
494 	else
495 		mci = (MCI *) sm_rpool_malloc_x(rpool, sizeof(*mci));
496 	memset((char *) mci, '\0', sizeof(*mci));
497 	mci->mci_rpool = sm_rpool_new_x(NULL);
498 	mci->mci_macro.mac_rpool = mci->mci_rpool;
499 	return mci;
500 }
501 /*
502 **  MCI_MATCH -- check connection cache for a particular host
503 **
504 **	Parameters:
505 **		host -- host to look for.
506 **		m -- mailer.
507 **
508 **	Returns:
509 **		true iff open connection exists.
510 */
511 
512 bool
513 mci_match(host, m)
514 	char *host;
515 	MAILER *m;
516 {
517 	register MCI *mci;
518 	register STAB *s;
519 
520 	if (m->m_mno < 0 || m->m_mno > MAXMAILERS)
521 		return false;
522 	s = stab(host, ST_MCI + m->m_mno, ST_FIND);
523 	if (s == NULL)
524 		return false;
525 
526 	mci = &s->s_mci;
527 	return mci->mci_state == MCIS_OPEN;
528 }
529 /*
530 **  MCI_SETSTAT -- set status codes in MCI structure.
531 **
532 **	Parameters:
533 **		mci -- the MCI structure to set.
534 **		xstat -- the exit status code.
535 **		dstat -- the DSN status code.
536 **		rstat -- the SMTP status code.
537 **
538 **	Returns:
539 **		none.
540 */
541 
542 void
543 mci_setstat(mci, xstat, dstat, rstat)
544 	MCI *mci;
545 	int xstat;
546 	char *dstat;
547 	char *rstat;
548 {
549 	/* protocol errors should never be interpreted as sticky */
550 	if (xstat != EX_NOTSTICKY && xstat != EX_PROTOCOL)
551 		mci->mci_exitstat = xstat;
552 
553 	SM_FREE_CLR(mci->mci_status);
554 	if (dstat != NULL)
555 		mci->mci_status = sm_strdup_x(dstat);
556 
557 	SM_FREE_CLR(mci->mci_rstatus);
558 	if (rstat != NULL)
559 		mci->mci_rstatus = sm_strdup_x(rstat);
560 }
561 /*
562 **  MCI_DUMP -- dump the contents of an MCI structure.
563 **
564 **	Parameters:
565 **		fp -- output file pointer
566 **		mci -- the MCI structure to dump.
567 **
568 **	Returns:
569 **		none.
570 **
571 **	Side Effects:
572 **		none.
573 */
574 
575 struct mcifbits
576 {
577 	int	mcif_bit;	/* flag bit */
578 	char	*mcif_name;	/* flag name */
579 };
580 static struct mcifbits	MciFlags[] =
581 {
582 	{ MCIF_VALID,		"VALID"		},
583 	{ MCIF_CACHED,		"CACHED"	},
584 	{ MCIF_ESMTP,		"ESMTP"		},
585 	{ MCIF_EXPN,		"EXPN"		},
586 	{ MCIF_SIZE,		"SIZE"		},
587 	{ MCIF_8BITMIME,	"8BITMIME"	},
588 	{ MCIF_7BIT,		"7BIT"		},
589 	{ MCIF_INHEADER,	"INHEADER"	},
590 	{ MCIF_CVT8TO7,		"CVT8TO7"	},
591 	{ MCIF_DSN,		"DSN"		},
592 	{ MCIF_8BITOK,		"8BITOK"	},
593 	{ MCIF_CVT7TO8,		"CVT7TO8"	},
594 	{ MCIF_INMIME,		"INMIME"	},
595 	{ MCIF_AUTH,		"AUTH"		},
596 	{ MCIF_AUTH2,		"AUTH2"		},
597 	{ MCIF_AUTHACT,		"AUTHACT"	},
598 	{ MCIF_ENHSTAT,		"ENHSTAT"	},
599 	{ MCIF_PIPELINED,	"PIPELINED"	},
600 #if STARTTLS
601 	{ MCIF_TLS,		"TLS"		},
602 	{ MCIF_TLSACT,		"TLSACT"	},
603 #endif /* STARTTLS */
604 	{ MCIF_DLVR_BY,		"DLVR_BY"	},
605 	{ 0,			NULL		}
606 };
607 
608 void
609 mci_dump(fp, mci, logit)
610 	SM_FILE_T *fp;
611 	register MCI *mci;
612 	bool logit;
613 {
614 	register char *p;
615 	char *sep;
616 	char buf[4000];
617 
618 	sep = logit ? " " : "\n\t";
619 	p = buf;
620 	(void) sm_snprintf(p, SPACELEFT(buf, p), "MCI@%p: ", mci);
621 	p += strlen(p);
622 	if (mci == NULL)
623 	{
624 		(void) sm_snprintf(p, SPACELEFT(buf, p), "NULL");
625 		goto printit;
626 	}
627 	(void) sm_snprintf(p, SPACELEFT(buf, p), "flags=%lx", mci->mci_flags);
628 	p += strlen(p);
629 
630 	/*
631 	**  The following check is just for paranoia.  It protects the
632 	**  assignment in the if() clause. If there's not some minimum
633 	**  amount of space we can stop right now. The check will not
634 	**  trigger as long as sizeof(buf)=4000.
635 	*/
636 
637 	if (p >= buf + sizeof(buf) - 4)
638 		goto printit;
639 	if (mci->mci_flags != 0)
640 	{
641 		struct mcifbits *f;
642 
643 		*p++ = '<';	/* protected above */
644 		for (f = MciFlags; f->mcif_bit != 0; f++)
645 		{
646 			if (!bitset(f->mcif_bit, mci->mci_flags))
647 				continue;
648 			(void) sm_strlcpyn(p, SPACELEFT(buf, p), 2,
649 					   f->mcif_name, ",");
650 			p += strlen(p);
651 		}
652 		p[-1] = '>';
653 	}
654 
655 	/* Note: sm_snprintf() takes care of NULL arguments for %s */
656 	(void) sm_snprintf(p, SPACELEFT(buf, p),
657 		",%serrno=%d, herrno=%d, exitstat=%d, state=%d, pid=%d,%s",
658 		sep, mci->mci_errno, mci->mci_herrno,
659 		mci->mci_exitstat, mci->mci_state, (int) mci->mci_pid, sep);
660 	p += strlen(p);
661 	(void) sm_snprintf(p, SPACELEFT(buf, p),
662 		"maxsize=%ld, phase=%s, mailer=%s,%s",
663 		mci->mci_maxsize, mci->mci_phase,
664 		mci->mci_mailer == NULL ? "NULL" : mci->mci_mailer->m_name,
665 		sep);
666 	p += strlen(p);
667 	(void) sm_snprintf(p, SPACELEFT(buf, p),
668 		"status=%s, rstatus=%s,%s",
669 		mci->mci_status, mci->mci_rstatus, sep);
670 	p += strlen(p);
671 	(void) sm_snprintf(p, SPACELEFT(buf, p),
672 		"host=%s, lastuse=%s",
673 		mci->mci_host, ctime(&mci->mci_lastuse));
674 printit:
675 	if (logit)
676 		sm_syslog(LOG_DEBUG, CurEnv->e_id, "%.1000s", buf);
677 	else
678 		(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s\n", buf);
679 }
680 /*
681 **  MCI_DUMP_ALL -- print the entire MCI cache
682 **
683 **	Parameters:
684 **		fp -- output file pointer
685 **		logit -- if set, log the result instead of printing
686 **			to stdout.
687 **
688 **	Returns:
689 **		none.
690 */
691 
692 void
693 mci_dump_all(fp, logit)
694 	SM_FILE_T *fp;
695 	bool logit;
696 {
697 	register int i;
698 
699 	if (MciCache == NULL)
700 		return;
701 
702 	for (i = 0; i < MaxMciCache; i++)
703 		mci_dump(fp, MciCache[i], logit);
704 }
705 /*
706 **  MCI_LOCK_HOST -- Lock host while sending.
707 **
708 **	If we are contacting a host, we'll need to
709 **	update the status information in the host status
710 **	file, and if we want to do that, we ought to have
711 **	locked it. This has the (according to some)
712 **	desirable effect of serializing connectivity with
713 **	remote hosts -- i.e.: one connection to a given
714 **	host at a time.
715 **
716 **	Parameters:
717 **		mci -- containing the host we want to lock.
718 **
719 **	Returns:
720 **		EX_OK	    -- got the lock.
721 **		EX_TEMPFAIL -- didn't get the lock.
722 */
723 
724 int
725 mci_lock_host(mci)
726 	MCI *mci;
727 {
728 	if (mci == NULL)
729 	{
730 		if (tTd(56, 1))
731 			sm_dprintf("mci_lock_host: NULL mci\n");
732 		return EX_OK;
733 	}
734 
735 	if (!SingleThreadDelivery)
736 		return EX_OK;
737 
738 	return mci_lock_host_statfile(mci);
739 }
740 
741 static int
742 mci_lock_host_statfile(mci)
743 	MCI *mci;
744 {
745 	int save_errno = errno;
746 	int retVal = EX_OK;
747 	char fname[MAXPATHLEN];
748 
749 	if (HostStatDir == NULL || mci->mci_host == NULL)
750 		return EX_OK;
751 
752 	if (tTd(56, 2))
753 		sm_dprintf("mci_lock_host: attempting to lock %s\n",
754 			   mci->mci_host);
755 
756 	if (mci_generate_persistent_path(mci->mci_host, fname, sizeof(fname),
757 					 true) < 0)
758 	{
759 		/* of course this should never happen */
760 		if (tTd(56, 2))
761 			sm_dprintf("mci_lock_host: Failed to generate host path for %s\n",
762 				   mci->mci_host);
763 
764 		retVal = EX_TEMPFAIL;
765 		goto cleanup;
766 	}
767 
768 	mci->mci_statfile = safefopen(fname, O_RDWR, FileMode,
769 				      SFF_NOLOCK|SFF_NOLINK|SFF_OPENASROOT|SFF_REGONLY|SFF_SAFEDIRPATH|SFF_CREAT);
770 
771 	if (mci->mci_statfile == NULL)
772 	{
773 		syserr("mci_lock_host: cannot create host lock file %s", fname);
774 		goto cleanup;
775 	}
776 
777 	if (!lockfile(sm_io_getinfo(mci->mci_statfile, SM_IO_WHAT_FD, NULL),
778 		      fname, "", LOCK_EX|LOCK_NB))
779 	{
780 		if (tTd(56, 2))
781 			sm_dprintf("mci_lock_host: couldn't get lock on %s\n",
782 				fname);
783 		(void) sm_io_close(mci->mci_statfile, SM_TIME_DEFAULT);
784 		mci->mci_statfile = NULL;
785 		retVal = EX_TEMPFAIL;
786 		goto cleanup;
787 	}
788 
789 	if (tTd(56, 12) && mci->mci_statfile != NULL)
790 		sm_dprintf("mci_lock_host: Sanity check -- lock is good\n");
791 
792 cleanup:
793 	errno = save_errno;
794 	return retVal;
795 }
796 /*
797 **  MCI_UNLOCK_HOST -- unlock host
798 **
799 **	Clean up the lock on a host, close the file, let
800 **	someone else use it.
801 **
802 **	Parameters:
803 **		mci -- us.
804 **
805 **	Returns:
806 **		nothing.
807 */
808 
809 void
810 mci_unlock_host(mci)
811 	MCI *mci;
812 {
813 	int save_errno = errno;
814 
815 	if (mci == NULL)
816 	{
817 		if (tTd(56, 1))
818 			sm_dprintf("mci_unlock_host: NULL mci\n");
819 		return;
820 	}
821 
822 	if (HostStatDir == NULL || mci->mci_host == NULL)
823 		return;
824 
825 	if (!SingleThreadDelivery && mci_lock_host_statfile(mci) == EX_TEMPFAIL)
826 	{
827 		if (tTd(56, 1))
828 			sm_dprintf("mci_unlock_host: stat file already locked\n");
829 	}
830 	else
831 	{
832 		if (tTd(56, 2))
833 			sm_dprintf("mci_unlock_host: store prior to unlock\n");
834 		mci_store_persistent(mci);
835 	}
836 
837 	if (mci->mci_statfile != NULL)
838 	{
839 		(void) sm_io_close(mci->mci_statfile, SM_TIME_DEFAULT);
840 		mci->mci_statfile = NULL;
841 	}
842 
843 	errno = save_errno;
844 }
845 /*
846 **  MCI_LOAD_PERSISTENT -- load persistent host info
847 **
848 **	Load information about host that is kept
849 **	in common for all running sendmails.
850 **
851 **	Parameters:
852 **		mci -- the host/connection to load persistent info for.
853 **
854 **	Returns:
855 **		true -- lock was successful
856 **		false -- lock failed
857 */
858 
859 static bool
860 mci_load_persistent(mci)
861 	MCI *mci;
862 {
863 	int save_errno = errno;
864 	bool locked = true;
865 	SM_FILE_T *fp;
866 	char fname[MAXPATHLEN];
867 
868 	if (mci == NULL)
869 	{
870 		if (tTd(56, 1))
871 			sm_dprintf("mci_load_persistent: NULL mci\n");
872 		return true;
873 	}
874 
875 	if (IgnoreHostStatus || HostStatDir == NULL || mci->mci_host == NULL)
876 		return true;
877 
878 	/* Already have the persistent information in memory */
879 	if (SingleThreadDelivery && mci->mci_statfile != NULL)
880 		return true;
881 
882 	if (tTd(56, 1))
883 		sm_dprintf("mci_load_persistent: Attempting to load persistent information for %s\n",
884 			   mci->mci_host);
885 
886 	if (mci_generate_persistent_path(mci->mci_host, fname, sizeof(fname),
887 					 false) < 0)
888 	{
889 		/* Not much we can do if the file isn't there... */
890 		if (tTd(56, 1))
891 			sm_dprintf("mci_load_persistent: Couldn't generate host path\n");
892 		goto cleanup;
893 	}
894 
895 	fp = safefopen(fname, O_RDONLY, FileMode,
896 		       SFF_NOLOCK|SFF_NOLINK|SFF_OPENASROOT|SFF_REGONLY|SFF_SAFEDIRPATH);
897 	if (fp == NULL)
898 	{
899 		/* I can't think of any reason this should ever happen */
900 		if (tTd(56, 1))
901 			sm_dprintf("mci_load_persistent: open(%s): %s\n",
902 				fname, sm_errstring(errno));
903 		goto cleanup;
904 	}
905 
906 	FileName = fname;
907 	locked = lockfile(sm_io_getinfo(fp, SM_IO_WHAT_FD, NULL), fname, "",
908 			  LOCK_SH|LOCK_NB);
909 	if (locked)
910 	{
911 		(void) mci_read_persistent(fp, mci);
912 		(void) lockfile(sm_io_getinfo(fp, SM_IO_WHAT_FD, NULL), fname,
913 				"", LOCK_UN);
914 	}
915 	FileName = NULL;
916 	(void) sm_io_close(fp, SM_TIME_DEFAULT);
917 
918 cleanup:
919 	errno = save_errno;
920 	return locked;
921 }
922 /*
923 **  MCI_READ_PERSISTENT -- read persistent host status file
924 **
925 **	Parameters:
926 **		fp -- the file pointer to read.
927 **		mci -- the pointer to fill in.
928 **
929 **	Returns:
930 **		-1 -- if the file was corrupt.
931 **		0 -- otherwise.
932 **
933 **	Warning:
934 **		This code makes the assumption that this data
935 **		will be read in an atomic fashion, and that the data
936 **		was written in an atomic fashion.  Any other functioning
937 **		may lead to some form of insanity.  This should be
938 **		perfectly safe due to underlying stdio buffering.
939 */
940 
941 static int
942 mci_read_persistent(fp, mci)
943 	SM_FILE_T *fp;
944 	register MCI *mci;
945 {
946 	int ver;
947 	register char *p;
948 	int saveLineNumber = LineNumber;
949 	char buf[MAXLINE];
950 
951 	if (fp == NULL)
952 	{
953 		syserr("mci_read_persistent: NULL fp");
954 		/* NOTREACHED */
955 		return -1;
956 	}
957 	if (mci == NULL)
958 	{
959 		syserr("mci_read_persistent: NULL mci");
960 		/* NOTREACHED */
961 		return -1;
962 	}
963 	if (tTd(56, 93))
964 	{
965 		sm_dprintf("mci_read_persistent: fp=%lx, mci=",
966 			   (unsigned long) fp);
967 	}
968 
969 	SM_FREE_CLR(mci->mci_status);
970 	SM_FREE_CLR(mci->mci_rstatus);
971 
972 	sm_io_rewind(fp, SM_TIME_DEFAULT);
973 	ver = -1;
974 	LineNumber = 0;
975 	while (sm_io_fgets(fp, SM_TIME_DEFAULT, buf, sizeof(buf)) != NULL)
976 	{
977 		LineNumber++;
978 		p = strchr(buf, '\n');
979 		if (p != NULL)
980 			*p = '\0';
981 		switch (buf[0])
982 		{
983 		  case 'V':		/* version stamp */
984 			ver = atoi(&buf[1]);
985 			if (ver < 0 || ver > 0)
986 				syserr("Unknown host status version %d: %d max",
987 					ver, 0);
988 			break;
989 
990 		  case 'E':		/* UNIX error number */
991 			mci->mci_errno = atoi(&buf[1]);
992 			break;
993 
994 		  case 'H':		/* DNS error number */
995 			mci->mci_herrno = atoi(&buf[1]);
996 			break;
997 
998 		  case 'S':		/* UNIX exit status */
999 			mci->mci_exitstat = atoi(&buf[1]);
1000 			break;
1001 
1002 		  case 'D':		/* DSN status */
1003 			mci->mci_status = newstr(&buf[1]);
1004 			break;
1005 
1006 		  case 'R':		/* SMTP status */
1007 			mci->mci_rstatus = newstr(&buf[1]);
1008 			break;
1009 
1010 		  case 'U':		/* last usage time */
1011 			mci->mci_lastuse = atol(&buf[1]);
1012 			break;
1013 
1014 		  case '.':		/* end of file */
1015 			if (tTd(56, 93))
1016 				mci_dump(sm_debug_file(), mci, false);
1017 			return 0;
1018 
1019 		  default:
1020 			sm_syslog(LOG_CRIT, NOQID,
1021 				  "%s: line %d: Unknown host status line \"%s\"",
1022 				  FileName == NULL ? mci->mci_host : FileName,
1023 				  LineNumber, buf);
1024 			LineNumber = saveLineNumber;
1025 			return -1;
1026 		}
1027 	}
1028 	LineNumber = saveLineNumber;
1029 	if (tTd(56, 93))
1030 		sm_dprintf("incomplete (missing dot for EOF)\n");
1031 	if (ver < 0)
1032 		return -1;
1033 	return 0;
1034 }
1035 /*
1036 **  MCI_STORE_PERSISTENT -- Store persistent MCI information
1037 **
1038 **	Store information about host that is kept
1039 **	in common for all running sendmails.
1040 **
1041 **	Parameters:
1042 **		mci -- the host/connection to store persistent info for.
1043 **
1044 **	Returns:
1045 **		none.
1046 */
1047 
1048 void
1049 mci_store_persistent(mci)
1050 	MCI *mci;
1051 {
1052 	int save_errno = errno;
1053 
1054 	if (mci == NULL)
1055 	{
1056 		if (tTd(56, 1))
1057 			sm_dprintf("mci_store_persistent: NULL mci\n");
1058 		return;
1059 	}
1060 
1061 	if (HostStatDir == NULL || mci->mci_host == NULL)
1062 		return;
1063 
1064 	if (tTd(56, 1))
1065 		sm_dprintf("mci_store_persistent: Storing information for %s\n",
1066 			   mci->mci_host);
1067 
1068 	if (mci->mci_statfile == NULL)
1069 	{
1070 		if (tTd(56, 1))
1071 			sm_dprintf("mci_store_persistent: no statfile\n");
1072 		return;
1073 	}
1074 
1075 	sm_io_rewind(mci->mci_statfile, SM_TIME_DEFAULT);
1076 #if !NOFTRUNCATE
1077 	(void) ftruncate(sm_io_getinfo(mci->mci_statfile, SM_IO_WHAT_FD, NULL),
1078 			 (off_t) 0);
1079 #endif /* !NOFTRUNCATE */
1080 
1081 	(void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, "V0\n");
1082 	(void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, "E%d\n",
1083 			     mci->mci_errno);
1084 	(void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, "H%d\n",
1085 			     mci->mci_herrno);
1086 	(void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, "S%d\n",
1087 			     mci->mci_exitstat);
1088 	if (mci->mci_status != NULL)
1089 		(void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT,
1090 				     "D%.80s\n",
1091 				     denlstring(mci->mci_status, true, false));
1092 	if (mci->mci_rstatus != NULL)
1093 		(void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT,
1094 				     "R%.80s\n",
1095 				     denlstring(mci->mci_rstatus, true, false));
1096 	(void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, "U%ld\n",
1097 			     (long)(mci->mci_lastuse));
1098 	(void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, ".\n");
1099 
1100 	(void) sm_io_flush(mci->mci_statfile, SM_TIME_DEFAULT);
1101 
1102 	errno = save_errno;
1103 	return;
1104 }
1105 /*
1106 **  MCI_TRAVERSE_PERSISTENT -- walk persistent status tree
1107 **
1108 **	Recursively find all the mci host files in `pathname'.  Default to
1109 **		main host status directory if no path is provided.
1110 **	Call (*action)(pathname, host) for each file found.
1111 **
1112 **	Note: all information is collected in a list before it is processed.
1113 **	This may not be the best way to do it, but it seems safest, since
1114 **	the file system would be touched while we are attempting to traverse
1115 **	the directory tree otherwise (during purges).
1116 **
1117 **	Parameters:
1118 **		action -- function to call on each node.  If returns < 0,
1119 **			return immediately.
1120 **		pathname -- root of tree.  If null, use main host status
1121 **			directory.
1122 **
1123 **	Returns:
1124 **		< 0 -- if any action routine returns a negative value, that
1125 **			value is returned.
1126 **		0 -- if we successfully went to completion.
1127 **		> 0 -- return status from action()
1128 */
1129 
1130 int
1131 mci_traverse_persistent(action, pathname)
1132 	int (*action)__P((char *, char *));
1133 	char *pathname;
1134 {
1135 	struct stat statbuf;
1136 	DIR *d;
1137 	int ret;
1138 
1139 	if (pathname == NULL)
1140 		pathname = HostStatDir;
1141 	if (pathname == NULL)
1142 		return -1;
1143 
1144 	if (tTd(56, 1))
1145 		sm_dprintf("mci_traverse: pathname is %s\n", pathname);
1146 
1147 	ret = stat(pathname, &statbuf);
1148 	if (ret < 0)
1149 	{
1150 		if (tTd(56, 2))
1151 			sm_dprintf("mci_traverse: Failed to stat %s: %s\n",
1152 				pathname, sm_errstring(errno));
1153 		return ret;
1154 	}
1155 	if (S_ISDIR(statbuf.st_mode))
1156 	{
1157 		bool leftone, removedone;
1158 		size_t len;
1159 		char *newptr;
1160 		struct dirent *e;
1161 		char newpath[MAXPATHLEN];
1162 #if MAXPATHLEN <= MAXNAMLEN - 3
1163  ERROR "MAXPATHLEN <= MAXNAMLEN - 3"
1164 #endif /* MAXPATHLEN  <= MAXNAMLEN - 3 */
1165 
1166 		if ((d = opendir(pathname)) == NULL)
1167 		{
1168 			if (tTd(56, 2))
1169 				sm_dprintf("mci_traverse: opendir %s: %s\n",
1170 					pathname, sm_errstring(errno));
1171 			return -1;
1172 		}
1173 
1174 		/*
1175 		**  Reserve space for trailing '/', at least one
1176 		**  character, and '\0'
1177 		*/
1178 
1179 		len = sizeof(newpath) - 3;
1180 		if (sm_strlcpy(newpath, pathname, len) >= len)
1181 		{
1182 			int save_errno = errno;
1183 
1184 			if (tTd(56, 2))
1185 				sm_dprintf("mci_traverse: path \"%s\" too long",
1186 					pathname);
1187 			(void) closedir(d);
1188 			errno = save_errno;
1189 			return -1;
1190 		}
1191 		newptr = newpath + strlen(newpath);
1192 		*newptr++ = '/';
1193 		len = sizeof(newpath) - (newptr - newpath);
1194 
1195 		/*
1196 		**  repeat until no file has been removed
1197 		**  this may become ugly when several files "expire"
1198 		**  during these loops, but it's better than doing
1199 		**  a rewinddir() inside the inner loop
1200 		*/
1201 
1202 		do
1203 		{
1204 			leftone = removedone = false;
1205 			while ((e = readdir(d)) != NULL)
1206 			{
1207 				if (e->d_name[0] == '.')
1208 					continue;
1209 
1210 				if (sm_strlcpy(newptr, e->d_name, len) >= len)
1211 				{
1212 					/* Skip truncated copies */
1213 					if (tTd(56, 4))
1214 					{
1215 						*newptr = '\0';
1216 						sm_dprintf("mci_traverse: path \"%s%s\" too long",
1217 							   newpath, e->d_name);
1218 					}
1219 					continue;
1220 				}
1221 
1222 				if (StopRequest)
1223 					stop_sendmail();
1224 				ret = mci_traverse_persistent(action, newpath);
1225 				if (ret < 0)
1226 					break;
1227 				if (ret == 1)
1228 					leftone = true;
1229 				if (!removedone && ret == 0 &&
1230 				    action == mci_purge_persistent)
1231 					removedone = true;
1232 			}
1233 			if (ret < 0)
1234 				break;
1235 
1236 			/*
1237 			**  The following appears to be
1238 			**  necessary during purges, since
1239 			**  we modify the directory structure
1240 			*/
1241 
1242 			if (removedone)
1243 				rewinddir(d);
1244 			if (tTd(56, 40))
1245 				sm_dprintf("mci_traverse: path %s: ret %d removed %d left %d\n",
1246 					pathname, ret, removedone, leftone);
1247 		} while (removedone);
1248 
1249 		/* purge (or whatever) the directory proper */
1250 		if (!leftone)
1251 		{
1252 			*--newptr = '\0';
1253 			ret = (*action)(newpath, NULL);
1254 		}
1255 		(void) closedir(d);
1256 	}
1257 	else if (S_ISREG(statbuf.st_mode))
1258 	{
1259 		char *end = pathname + strlen(pathname) - 1;
1260 		char *start;
1261 		char *scan;
1262 		char host[MAXHOSTNAMELEN];
1263 		char *hostptr = host;
1264 
1265 		/*
1266 		**  Reconstruct the host name from the path to the
1267 		**  persistent information.
1268 		*/
1269 
1270 		do
1271 		{
1272 			if (hostptr != host)
1273 				*(hostptr++) = '.';
1274 			start = end;
1275 			while (start > pathname && *(start - 1) != '/')
1276 				start--;
1277 
1278 			if (*end == '.')
1279 				end--;
1280 
1281 			for (scan = start; scan <= end; scan++)
1282 				*(hostptr++) = *scan;
1283 
1284 			end = start - 2;
1285 		} while (end > pathname && *end == '.');
1286 
1287 		*hostptr = '\0';
1288 
1289 		/*
1290 		**  Do something with the file containing the persistent
1291 		**  information.
1292 		*/
1293 
1294 		ret = (*action)(pathname, host);
1295 	}
1296 
1297 	return ret;
1298 }
1299 /*
1300 **  MCI_PRINT_PERSISTENT -- print persistent info
1301 **
1302 **	Dump the persistent information in the file 'pathname'
1303 **
1304 **	Parameters:
1305 **		pathname -- the pathname to the status file.
1306 **		hostname -- the corresponding host name.
1307 **
1308 **	Returns:
1309 **		0
1310 */
1311 
1312 int
1313 mci_print_persistent(pathname, hostname)
1314 	char *pathname;
1315 	char *hostname;
1316 {
1317 	static bool initflag = false;
1318 	SM_FILE_T *fp;
1319 	int width = Verbose ? 78 : 25;
1320 	bool locked;
1321 	MCI mcib;
1322 
1323 	/* skip directories */
1324 	if (hostname == NULL)
1325 		return 0;
1326 
1327 	if (StopRequest)
1328 		stop_sendmail();
1329 
1330 	if (!initflag)
1331 	{
1332 		initflag = true;
1333 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1334 				     " -------------- Hostname --------------- How long ago ---------Results---------\n");
1335 	}
1336 
1337 	fp = safefopen(pathname, O_RDONLY, FileMode,
1338 		       SFF_NOLOCK|SFF_NOLINK|SFF_OPENASROOT|SFF_REGONLY|SFF_SAFEDIRPATH);
1339 
1340 	if (fp == NULL)
1341 	{
1342 		if (tTd(56, 1))
1343 			sm_dprintf("mci_print_persistent: cannot open %s: %s\n",
1344 				pathname, sm_errstring(errno));
1345 		return 0;
1346 	}
1347 
1348 	FileName = pathname;
1349 	memset(&mcib, '\0', sizeof(mcib));
1350 	if (mci_read_persistent(fp, &mcib) < 0)
1351 	{
1352 		syserr("%s: could not read status file", pathname);
1353 		(void) sm_io_close(fp, SM_TIME_DEFAULT);
1354 		FileName = NULL;
1355 		return 0;
1356 	}
1357 
1358 	locked = !lockfile(sm_io_getinfo(fp, SM_IO_WHAT_FD, NULL), pathname,
1359 			   "", LOCK_SH|LOCK_NB);
1360 	(void) sm_io_close(fp, SM_TIME_DEFAULT);
1361 	FileName = NULL;
1362 
1363 	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%c%-39s %12s ",
1364 			     locked ? '*' : ' ', hostname,
1365 			     pintvl(curtime() - mcib.mci_lastuse, true));
1366 	if (mcib.mci_rstatus != NULL)
1367 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%.*s\n", width,
1368 				     mcib.mci_rstatus);
1369 	else if (mcib.mci_exitstat == EX_TEMPFAIL && mcib.mci_errno != 0)
1370 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1371 				     "Deferred: %.*s\n", width - 10,
1372 				     sm_errstring(mcib.mci_errno));
1373 	else if (mcib.mci_exitstat != 0)
1374 	{
1375 		char *exmsg = sm_sysexmsg(mcib.mci_exitstat);
1376 
1377 		if (exmsg == NULL)
1378 		{
1379 			char buf[80];
1380 
1381 			(void) sm_snprintf(buf, sizeof(buf),
1382 				"Unknown mailer error %d",
1383 				mcib.mci_exitstat);
1384 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%.*s\n",
1385 					     width, buf);
1386 		}
1387 		else
1388 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%.*s\n",
1389 					     width, &exmsg[5]);
1390 	}
1391 	else if (mcib.mci_errno == 0)
1392 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "OK\n");
1393 	else
1394 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "OK: %.*s\n",
1395 				     width - 4, sm_errstring(mcib.mci_errno));
1396 
1397 	return 0;
1398 }
1399 /*
1400 **  MCI_PURGE_PERSISTENT -- Remove a persistence status file.
1401 **
1402 **	Parameters:
1403 **		pathname -- path to the status file.
1404 **		hostname -- name of host corresponding to that file.
1405 **			NULL if this is a directory (domain).
1406 **
1407 **	Returns:
1408 **		0 -- ok
1409 **		1 -- file not deleted (too young, incorrect format)
1410 **		< 0 -- some error occurred
1411 */
1412 
1413 int
1414 mci_purge_persistent(pathname, hostname)
1415 	char *pathname;
1416 	char *hostname;
1417 {
1418 	struct stat statbuf;
1419 	char *end = pathname + strlen(pathname) - 1;
1420 	int ret;
1421 
1422 	if (tTd(56, 1))
1423 		sm_dprintf("mci_purge_persistent: purging %s\n", pathname);
1424 
1425 	ret = stat(pathname, &statbuf);
1426 	if (ret < 0)
1427 	{
1428 		if (tTd(56, 2))
1429 			sm_dprintf("mci_purge_persistent: Failed to stat %s: %s\n",
1430 				pathname, sm_errstring(errno));
1431 		return ret;
1432 	}
1433 	if (curtime() - statbuf.st_mtime <= MciInfoTimeout)
1434 		return 1;
1435 	if (hostname != NULL)
1436 	{
1437 		/* remove the file */
1438 		ret = unlink(pathname);
1439 		if (ret < 0)
1440 		{
1441 			if (LogLevel > 8)
1442 				sm_syslog(LOG_ERR, NOQID,
1443 					  "mci_purge_persistent: failed to unlink %s: %s",
1444 					  pathname, sm_errstring(errno));
1445 			if (tTd(56, 2))
1446 				sm_dprintf("mci_purge_persistent: failed to unlink %s: %s\n",
1447 					pathname, sm_errstring(errno));
1448 			return ret;
1449 		}
1450 	}
1451 	else
1452 	{
1453 		/* remove the directory */
1454 		if (*end != '.')
1455 			return 1;
1456 
1457 		if (tTd(56, 1))
1458 			sm_dprintf("mci_purge_persistent: dpurge %s\n", pathname);
1459 
1460 		ret = rmdir(pathname);
1461 		if (ret < 0)
1462 		{
1463 			if (tTd(56, 2))
1464 				sm_dprintf("mci_purge_persistent: rmdir %s: %s\n",
1465 					pathname, sm_errstring(errno));
1466 			return ret;
1467 		}
1468 	}
1469 
1470 	return 0;
1471 }
1472 /*
1473 **  MCI_GENERATE_PERSISTENT_PATH -- generate path from hostname
1474 **
1475 **	Given `host', convert from a.b.c to $HostStatDir/c./b./a,
1476 **	putting the result into `path'.  if `createflag' is set, intervening
1477 **	directories will be created as needed.
1478 **
1479 **	Parameters:
1480 **		host -- host name to convert from.
1481 **		path -- place to store result.
1482 **		pathlen -- length of path buffer.
1483 **		createflag -- if set, create intervening directories as
1484 **			needed.
1485 **
1486 **	Returns:
1487 **		0 -- success
1488 **		-1 -- failure
1489 */
1490 
1491 static int
1492 mci_generate_persistent_path(host, path, pathlen, createflag)
1493 	const char *host;
1494 	char *path;
1495 	int pathlen;
1496 	bool createflag;
1497 {
1498 	char *elem, *p, *x, ch;
1499 	int ret = 0;
1500 	int len;
1501 	char t_host[MAXHOSTNAMELEN];
1502 #if NETINET6
1503 	struct in6_addr in6_addr;
1504 #endif /* NETINET6 */
1505 
1506 	/*
1507 	**  Rationality check the arguments.
1508 	*/
1509 
1510 	if (host == NULL)
1511 	{
1512 		syserr("mci_generate_persistent_path: null host");
1513 		return -1;
1514 	}
1515 	if (path == NULL)
1516 	{
1517 		syserr("mci_generate_persistent_path: null path");
1518 		return -1;
1519 	}
1520 
1521 	if (tTd(56, 80))
1522 		sm_dprintf("mci_generate_persistent_path(%s): ", host);
1523 
1524 	if (*host == '\0' || *host == '.')
1525 		return -1;
1526 
1527 	/* make certain this is not a bracketed host number */
1528 	if (strlen(host) > sizeof(t_host) - 1)
1529 		return -1;
1530 	if (host[0] == '[')
1531 		(void) sm_strlcpy(t_host, host + 1, sizeof(t_host));
1532 	else
1533 		(void) sm_strlcpy(t_host, host, sizeof(t_host));
1534 
1535 	/*
1536 	**  Delete any trailing dots from the hostname.
1537 	**  Leave 'elem' pointing at the \0.
1538 	*/
1539 
1540 	elem = t_host + strlen(t_host);
1541 	while (elem > t_host &&
1542 	       (elem[-1] == '.' || (host[0] == '[' && elem[-1] == ']')))
1543 		*--elem = '\0';
1544 
1545 	/* check for bogus bracketed address */
1546 	if (host[0] == '[')
1547 	{
1548 		bool good = false;
1549 # if NETINET6
1550 		if (anynet_pton(AF_INET6, t_host, &in6_addr) == 1)
1551 			good = true;
1552 # endif /* NETINET6 */
1553 # if NETINET
1554 		if (inet_addr(t_host) != INADDR_NONE)
1555 			good = true;
1556 # endif /* NETINET */
1557 		if (!good)
1558 			return -1;
1559 	}
1560 
1561 	/* check for what will be the final length of the path */
1562 	len = strlen(HostStatDir) + 2;
1563 	for (p = (char *) t_host; *p != '\0'; p++)
1564 	{
1565 		if (*p == '.')
1566 			len++;
1567 		len++;
1568 		if (p[0] == '.' && p[1] == '.')
1569 			return -1;
1570 	}
1571 	if (len > pathlen || len < 1)
1572 		return -1;
1573 	(void) sm_strlcpy(path, HostStatDir, pathlen);
1574 	p = path + strlen(path);
1575 	while (elem > t_host)
1576 	{
1577 		if (!path_is_dir(path, createflag))
1578 		{
1579 			ret = -1;
1580 			break;
1581 		}
1582 		elem--;
1583 		while (elem >= t_host && *elem != '.')
1584 			elem--;
1585 		*p++ = '/';
1586 		x = elem + 1;
1587 		while ((ch = *x++) != '\0' && ch != '.')
1588 		{
1589 			if (isascii(ch) && isupper(ch))
1590 				ch = tolower(ch);
1591 			if (ch == '/')
1592 				ch = ':';	/* / -> : */
1593 			*p++ = ch;
1594 		}
1595 		if (elem >= t_host)
1596 			*p++ = '.';
1597 		*p = '\0';
1598 	}
1599 	if (tTd(56, 80))
1600 	{
1601 		if (ret < 0)
1602 			sm_dprintf("FAILURE %d\n", ret);
1603 		else
1604 			sm_dprintf("SUCCESS %s\n", path);
1605 	}
1606 	return ret;
1607 }
1608