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