xref: /titanic_41/usr/src/cmd/sendmail/src/util.c (revision e9af4bc0b1cc30cea75d6ad4aa2fde97d985e9be)
1 /*
2  * Copyright (c) 1998-2007, 2009 Sendmail, Inc. and its suppliers.
3  *	All rights reserved.
4  * Copyright (c) 1983, 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: util.c,v 8.416 2009/12/18 17:05:26 ca Exp $")
17 
18 #include <sm/sendmail.h>
19 #include <sysexits.h>
20 #include <sm/xtrap.h>
21 
22 /*
23 **  NEWSTR -- Create a copy of a C string
24 **
25 **	Parameters:
26 **		s -- the string to copy.
27 **
28 **	Returns:
29 **		pointer to newly allocated string.
30 */
31 
32 char *
33 newstr(s)
34 	const char *s;
35 {
36 	size_t l;
37 	char *n;
38 
39 	l = strlen(s);
40 	SM_ASSERT(l + 1 > l);
41 	n = xalloc(l + 1);
42 	sm_strlcpy(n, s, l + 1);
43 	return n;
44 }
45 
46 /*
47 **  ADDQUOTES -- Adds quotes & quote bits to a string.
48 **
49 **	Runs through a string and adds backslashes and quote bits.
50 **
51 **	Parameters:
52 **		s -- the string to modify.
53 **		rpool -- resource pool from which to allocate result
54 **
55 **	Returns:
56 **		pointer to quoted string.
57 */
58 
59 char *
addquotes(s,rpool)60 addquotes(s, rpool)
61 	char *s;
62 	SM_RPOOL_T *rpool;
63 {
64 	int len = 0;
65 	char c;
66 	char *p = s, *q, *r;
67 
68 	if (s == NULL)
69 		return NULL;
70 
71 	/* Find length of quoted string */
72 	while ((c = *p++) != '\0')
73 	{
74 		len++;
75 		if (c == '\\' || c == '"')
76 			len++;
77 	}
78 
79 	q = r = sm_rpool_malloc_x(rpool, len + 3);
80 	p = s;
81 
82 	/* add leading quote */
83 	*q++ = '"';
84 	while ((c = *p++) != '\0')
85 	{
86 		/* quote \ or " */
87 		if (c == '\\' || c == '"')
88 			*q++ = '\\';
89 		*q++ = c;
90 	}
91 	*q++ = '"';
92 	*q = '\0';
93 	return r;
94 }
95 
96 /*
97 **  STRIPBACKSLASH -- Strip all leading backslashes from a string, provided
98 **	the following character is alpha-numerical.
99 **
100 **	This is done in place.
101 **
102 **	Parameters:
103 **		s -- the string to strip.
104 **
105 **	Returns:
106 **		none.
107 */
108 
109 void
stripbackslash(s)110 stripbackslash(s)
111 	char *s;
112 {
113 	char *p, *q, c;
114 
115 	if (s == NULL || *s == '\0')
116 		return;
117 	p = q = s;
118 	while (*p == '\\' && (p[1] == '\\' || (isascii(p[1]) && isalnum(p[1]))))
119 		p++;
120 	do
121 	{
122 		c = *q++ = *p++;
123 	} while (c != '\0');
124 }
125 
126 /*
127 **  RFC822_STRING -- Checks string for proper RFC822 string quoting.
128 **
129 **	Runs through a string and verifies RFC822 special characters
130 **	are only found inside comments, quoted strings, or backslash
131 **	escaped.  Also verified balanced quotes and parenthesis.
132 **
133 **	Parameters:
134 **		s -- the string to modify.
135 **
136 **	Returns:
137 **		true iff the string is RFC822 compliant, false otherwise.
138 */
139 
140 bool
rfc822_string(s)141 rfc822_string(s)
142 	char *s;
143 {
144 	bool quoted = false;
145 	int commentlev = 0;
146 	char *c = s;
147 
148 	if (s == NULL)
149 		return false;
150 
151 	while (*c != '\0')
152 	{
153 		/* escaped character */
154 		if (*c == '\\')
155 		{
156 			c++;
157 			if (*c == '\0')
158 				return false;
159 		}
160 		else if (commentlev == 0 && *c == '"')
161 			quoted = !quoted;
162 		else if (!quoted)
163 		{
164 			if (*c == ')')
165 			{
166 				/* unbalanced ')' */
167 				if (commentlev == 0)
168 					return false;
169 				else
170 					commentlev--;
171 			}
172 			else if (*c == '(')
173 				commentlev++;
174 			else if (commentlev == 0 &&
175 				 strchr(MustQuoteChars, *c) != NULL)
176 				return false;
177 		}
178 		c++;
179 	}
180 
181 	/* unbalanced '"' or '(' */
182 	return !quoted && commentlev == 0;
183 }
184 
185 /*
186 **  SHORTEN_RFC822_STRING -- Truncate and rebalance an RFC822 string
187 **
188 **	Arbitrarily shorten (in place) an RFC822 string and rebalance
189 **	comments and quotes.
190 **
191 **	Parameters:
192 **		string -- the string to shorten
193 **		length -- the maximum size, 0 if no maximum
194 **
195 **	Returns:
196 **		true if string is changed, false otherwise
197 **
198 **	Side Effects:
199 **		Changes string in place, possibly resulting
200 **		in a shorter string.
201 */
202 
203 bool
shorten_rfc822_string(string,length)204 shorten_rfc822_string(string, length)
205 	char *string;
206 	size_t length;
207 {
208 	bool backslash = false;
209 	bool modified = false;
210 	bool quoted = false;
211 	size_t slen;
212 	int parencount = 0;
213 	char *ptr = string;
214 
215 	/*
216 	**  If have to rebalance an already short enough string,
217 	**  need to do it within allocated space.
218 	*/
219 
220 	slen = strlen(string);
221 	if (length == 0 || slen < length)
222 		length = slen;
223 
224 	while (*ptr != '\0')
225 	{
226 		if (backslash)
227 		{
228 			backslash = false;
229 			goto increment;
230 		}
231 
232 		if (*ptr == '\\')
233 			backslash = true;
234 		else if (*ptr == '(')
235 		{
236 			if (!quoted)
237 				parencount++;
238 		}
239 		else if (*ptr == ')')
240 		{
241 			if (--parencount < 0)
242 				parencount = 0;
243 		}
244 
245 		/* Inside a comment, quotes don't matter */
246 		if (parencount <= 0 && *ptr == '"')
247 			quoted = !quoted;
248 
249 increment:
250 		/* Check for sufficient space for next character */
251 		if (length - (ptr - string) <= (size_t) ((backslash ? 1 : 0) +
252 						parencount +
253 						(quoted ? 1 : 0)))
254 		{
255 			/* Not enough, backtrack */
256 			if (*ptr == '\\')
257 				backslash = false;
258 			else if (*ptr == '(' && !quoted)
259 				parencount--;
260 			else if (*ptr == '"' && parencount == 0)
261 				quoted = false;
262 			break;
263 		}
264 		ptr++;
265 	}
266 
267 	/* Rebalance */
268 	while (parencount-- > 0)
269 	{
270 		if (*ptr != ')')
271 		{
272 			modified = true;
273 			*ptr = ')';
274 		}
275 		ptr++;
276 	}
277 	if (quoted)
278 	{
279 		if (*ptr != '"')
280 		{
281 			modified = true;
282 			*ptr = '"';
283 		}
284 		ptr++;
285 	}
286 	if (*ptr != '\0')
287 	{
288 		modified = true;
289 		*ptr = '\0';
290 	}
291 	return modified;
292 }
293 
294 /*
295 **  FIND_CHARACTER -- find an unquoted character in an RFC822 string
296 **
297 **	Find an unquoted, non-commented character in an RFC822
298 **	string and return a pointer to its location in the
299 **	string.
300 **
301 **	Parameters:
302 **		string -- the string to search
303 **		character -- the character to find
304 **
305 **	Returns:
306 **		pointer to the character, or
307 **		a pointer to the end of the line if character is not found
308 */
309 
310 char *
find_character(string,character)311 find_character(string, character)
312 	char *string;
313 	int character;
314 {
315 	bool backslash = false;
316 	bool quoted = false;
317 	int parencount = 0;
318 
319 	while (string != NULL && *string != '\0')
320 	{
321 		if (backslash)
322 		{
323 			backslash = false;
324 			if (!quoted && character == '\\' && *string == '\\')
325 				break;
326 			string++;
327 			continue;
328 		}
329 		switch (*string)
330 		{
331 		  case '\\':
332 			backslash = true;
333 			break;
334 
335 		  case '(':
336 			if (!quoted)
337 				parencount++;
338 			break;
339 
340 		  case ')':
341 			if (--parencount < 0)
342 				parencount = 0;
343 			break;
344 		}
345 
346 		/* Inside a comment, nothing matters */
347 		if (parencount > 0)
348 		{
349 			string++;
350 			continue;
351 		}
352 
353 		if (*string == '"')
354 			quoted = !quoted;
355 		else if (*string == character && !quoted)
356 			break;
357 		string++;
358 	}
359 
360 	/* Return pointer to the character */
361 	return string;
362 }
363 
364 /*
365 **  CHECK_BODYTYPE -- check bodytype parameter
366 **
367 **	Parameters:
368 **		bodytype -- bodytype parameter
369 **
370 **	Returns:
371 **		BODYTYPE_* according to parameter
372 **
373 */
374 
375 int
check_bodytype(bodytype)376 check_bodytype(bodytype)
377 	char *bodytype;
378 {
379 	/* check body type for legality */
380 	if (bodytype == NULL)
381 		return BODYTYPE_NONE;
382 	if (sm_strcasecmp(bodytype, "7BIT") == 0)
383 		return BODYTYPE_7BIT;
384 	if (sm_strcasecmp(bodytype, "8BITMIME") == 0)
385 		return BODYTYPE_8BITMIME;
386 	return BODYTYPE_ILLEGAL;
387 }
388 
389 /*
390 **  TRUNCATE_AT_DELIM -- truncate string at a delimiter and append "..."
391 **
392 **	Parameters:
393 **		str -- string to truncate
394 **		len -- maximum length (including '\0') (0 for unlimited)
395 **		delim -- delimiter character
396 **
397 **	Returns:
398 **		None.
399 */
400 
401 void
truncate_at_delim(str,len,delim)402 truncate_at_delim(str, len, delim)
403 	char *str;
404 	size_t len;
405 	int delim;
406 {
407 	char *p;
408 
409 	if (str == NULL || len == 0 || strlen(str) < len)
410 		return;
411 
412 	*(str + len - 1) = '\0';
413 	while ((p = strrchr(str, delim)) != NULL)
414 	{
415 		*p = '\0';
416 		if (p - str + 4 < len)
417 		{
418 			*p++ = (char) delim;
419 			*p = '\0';
420 			(void) sm_strlcat(str, "...", len);
421 			return;
422 		}
423 	}
424 
425 	/* Couldn't find a place to append "..." */
426 	if (len > 3)
427 		(void) sm_strlcpy(str, "...", len);
428 	else
429 		str[0] = '\0';
430 }
431 
432 /*
433 **  XALLOC -- Allocate memory, raise an exception on error
434 **
435 **	Parameters:
436 **		sz -- size of area to allocate.
437 **
438 **	Returns:
439 **		pointer to data region.
440 **
441 **	Exceptions:
442 **		SmHeapOutOfMemory (F:sm.heap) -- cannot allocate memory
443 **
444 **	Side Effects:
445 **		Memory is allocated.
446 */
447 
448 char *
449 #if SM_HEAP_CHECK
xalloc_tagged(sz,file,line)450 xalloc_tagged(sz, file, line)
451 	register int sz;
452 	char *file;
453 	int line;
454 #else /* SM_HEAP_CHECK */
455 xalloc(sz)
456 	register int sz;
457 #endif /* SM_HEAP_CHECK */
458 {
459 	register char *p;
460 
461 	SM_REQUIRE(sz >= 0);
462 
463 	/* some systems can't handle size zero mallocs */
464 	if (sz <= 0)
465 		sz = 1;
466 
467 	/* scaffolding for testing error handling code */
468 	sm_xtrap_raise_x(&SmHeapOutOfMemory);
469 
470 	p = sm_malloc_tagged((unsigned) sz, file, line, sm_heap_group());
471 	if (p == NULL)
472 	{
473 		sm_exc_raise_x(&SmHeapOutOfMemory);
474 	}
475 	return p;
476 }
477 
478 /*
479 **  COPYPLIST -- copy list of pointers.
480 **
481 **	This routine is the equivalent of strdup for lists of
482 **	pointers.
483 **
484 **	Parameters:
485 **		list -- list of pointers to copy.
486 **			Must be NULL terminated.
487 **		copycont -- if true, copy the contents of the vector
488 **			(which must be a string) also.
489 **		rpool -- resource pool from which to allocate storage,
490 **			or NULL
491 **
492 **	Returns:
493 **		a copy of 'list'.
494 */
495 
496 char **
copyplist(list,copycont,rpool)497 copyplist(list, copycont, rpool)
498 	char **list;
499 	bool copycont;
500 	SM_RPOOL_T *rpool;
501 {
502 	register char **vp;
503 	register char **newvp;
504 
505 	for (vp = list; *vp != NULL; vp++)
506 		continue;
507 
508 	vp++;
509 
510 	newvp = (char **) sm_rpool_malloc_x(rpool, (vp - list) * sizeof(*vp));
511 	memmove((char *) newvp, (char *) list, (int) (vp - list) * sizeof(*vp));
512 
513 	if (copycont)
514 	{
515 		for (vp = newvp; *vp != NULL; vp++)
516 			*vp = sm_rpool_strdup_x(rpool, *vp);
517 	}
518 
519 	return newvp;
520 }
521 
522 /*
523 **  COPYQUEUE -- copy address queue.
524 **
525 **	This routine is the equivalent of strdup for address queues;
526 **	addresses marked as QS_IS_DEAD() aren't copied
527 **
528 **	Parameters:
529 **		addr -- list of address structures to copy.
530 **		rpool -- resource pool from which to allocate storage
531 **
532 **	Returns:
533 **		a copy of 'addr'.
534 */
535 
536 ADDRESS *
copyqueue(addr,rpool)537 copyqueue(addr, rpool)
538 	ADDRESS *addr;
539 	SM_RPOOL_T *rpool;
540 {
541 	register ADDRESS *newaddr;
542 	ADDRESS *ret;
543 	register ADDRESS **tail = &ret;
544 
545 	while (addr != NULL)
546 	{
547 		if (!QS_IS_DEAD(addr->q_state))
548 		{
549 			newaddr = (ADDRESS *) sm_rpool_malloc_x(rpool,
550 							sizeof(*newaddr));
551 			STRUCTCOPY(*addr, *newaddr);
552 			*tail = newaddr;
553 			tail = &newaddr->q_next;
554 		}
555 		addr = addr->q_next;
556 	}
557 	*tail = NULL;
558 
559 	return ret;
560 }
561 
562 /*
563 **  LOG_SENDMAIL_PID -- record sendmail pid and command line.
564 **
565 **	Parameters:
566 **		e -- the current envelope.
567 **
568 **	Returns:
569 **		none.
570 **
571 **	Side Effects:
572 **		writes pidfile, logs command line.
573 **		keeps file open and locked to prevent overwrite of active file
574 */
575 
576 static SM_FILE_T	*Pidf = NULL;
577 
578 void
log_sendmail_pid(e)579 log_sendmail_pid(e)
580 	ENVELOPE *e;
581 {
582 	long sff;
583 	char pidpath[MAXPATHLEN];
584 	extern char *CommandLineArgs;
585 
586 	/* write the pid to the log file for posterity */
587 	sff = SFF_NOLINK|SFF_ROOTOK|SFF_REGONLY|SFF_CREAT|SFF_NBLOCK;
588 	if (TrustedUid != 0 && RealUid == TrustedUid)
589 		sff |= SFF_OPENASROOT;
590 	expand(PidFile, pidpath, sizeof(pidpath), e);
591 	Pidf = safefopen(pidpath, O_WRONLY|O_TRUNC, FileMode, sff);
592 	if (Pidf == NULL)
593 	{
594 		if (errno == EWOULDBLOCK)
595 			sm_syslog(LOG_ERR, NOQID,
596 				  "unable to write pid to %s: file in use by another process",
597 				  pidpath);
598 		else
599 			sm_syslog(LOG_ERR, NOQID,
600 				  "unable to write pid to %s: %s",
601 				  pidpath, sm_errstring(errno));
602 	}
603 	else
604 	{
605 		PidFilePid = getpid();
606 
607 		/* write the process id on line 1 */
608 		(void) sm_io_fprintf(Pidf, SM_TIME_DEFAULT, "%ld\n",
609 				     (long) PidFilePid);
610 
611 		/* line 2 contains all command line flags */
612 		(void) sm_io_fprintf(Pidf, SM_TIME_DEFAULT, "%s\n",
613 				     CommandLineArgs);
614 
615 		/* flush */
616 		(void) sm_io_flush(Pidf, SM_TIME_DEFAULT);
617 
618 		/*
619 		**  Leave pid file open until process ends
620 		**  so it's not overwritten by another
621 		**  process.
622 		*/
623 	}
624 	if (LogLevel > 9)
625 		sm_syslog(LOG_INFO, NOQID, "started as: %s", CommandLineArgs);
626 }
627 
628 /*
629 **  CLOSE_SENDMAIL_PID -- close sendmail pid file
630 **
631 **	Parameters:
632 **		none.
633 **
634 **	Returns:
635 **		none.
636 */
637 
638 void
close_sendmail_pid()639 close_sendmail_pid()
640 {
641 	if (Pidf == NULL)
642 		return;
643 
644 	(void) sm_io_close(Pidf, SM_TIME_DEFAULT);
645 	Pidf = NULL;
646 }
647 
648 /*
649 **  SET_DELIVERY_MODE -- set and record the delivery mode
650 **
651 **	Parameters:
652 **		mode -- delivery mode
653 **		e -- the current envelope.
654 **
655 **	Returns:
656 **		none.
657 **
658 **	Side Effects:
659 **		sets {deliveryMode} macro
660 */
661 
662 void
set_delivery_mode(mode,e)663 set_delivery_mode(mode, e)
664 	int mode;
665 	ENVELOPE *e;
666 {
667 	char buf[2];
668 
669 	e->e_sendmode = (char) mode;
670 	buf[0] = (char) mode;
671 	buf[1] = '\0';
672 	macdefine(&e->e_macro, A_TEMP, macid("{deliveryMode}"), buf);
673 }
674 
675 /*
676 **  SET_OP_MODE -- set and record the op mode
677 **
678 **	Parameters:
679 **		mode -- op mode
680 **		e -- the current envelope.
681 **
682 **	Returns:
683 **		none.
684 **
685 **	Side Effects:
686 **		sets {opMode} macro
687 */
688 
689 void
set_op_mode(mode)690 set_op_mode(mode)
691 	int mode;
692 {
693 	char buf[2];
694 	extern ENVELOPE BlankEnvelope;
695 
696 	OpMode = (char) mode;
697 	buf[0] = (char) mode;
698 	buf[1] = '\0';
699 	macdefine(&BlankEnvelope.e_macro, A_TEMP, MID_OPMODE, buf);
700 }
701 
702 /*
703 **  PRINTAV -- print argument vector.
704 **
705 **	Parameters:
706 **		fp -- output file pointer.
707 **		av -- argument vector.
708 **
709 **	Returns:
710 **		none.
711 **
712 **	Side Effects:
713 **		prints av.
714 */
715 
716 void
printav(fp,av)717 printav(fp, av)
718 	SM_FILE_T *fp;
719 	char **av;
720 {
721 	while (*av != NULL)
722 	{
723 		if (tTd(0, 44))
724 			sm_dprintf("\n\t%08lx=", (unsigned long) *av);
725 		else
726 			(void) sm_io_putc(fp, SM_TIME_DEFAULT, ' ');
727 		if (tTd(0, 99))
728 			sm_dprintf("%s", str2prt(*av++));
729 		else
730 			xputs(fp, *av++);
731 	}
732 	(void) sm_io_putc(fp, SM_TIME_DEFAULT, '\n');
733 }
734 
735 /*
736 **  XPUTS -- put string doing control escapes.
737 **
738 **	Parameters:
739 **		fp -- output file pointer.
740 **		s -- string to put.
741 **
742 **	Returns:
743 **		none.
744 **
745 **	Side Effects:
746 **		output to stdout
747 */
748 
749 void
xputs(fp,s)750 xputs(fp, s)
751 	SM_FILE_T *fp;
752 	const char *s;
753 {
754 	int c;
755 	struct metamac *mp;
756 	bool shiftout = false;
757 	extern struct metamac MetaMacros[];
758 	static SM_DEBUG_T DebugANSI = SM_DEBUG_INITIALIZER("ANSI",
759 		"@(#)$Debug: ANSI - enable reverse video in debug output $");
760 
761 	/*
762 	**  TermEscape is set here, rather than in main(),
763 	**  because ANSI mode can be turned on or off at any time
764 	**  if we are in -bt rule testing mode.
765 	*/
766 
767 	if (sm_debug_unknown(&DebugANSI))
768 	{
769 		if (sm_debug_active(&DebugANSI, 1))
770 		{
771 			TermEscape.te_rv_on = "\033[7m";
772 			TermEscape.te_normal = "\033[0m";
773 		}
774 		else
775 		{
776 			TermEscape.te_rv_on = "";
777 			TermEscape.te_normal = "";
778 		}
779 	}
780 
781 	if (s == NULL)
782 	{
783 		(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s<null>%s",
784 				     TermEscape.te_rv_on, TermEscape.te_normal);
785 		return;
786 	}
787 	while ((c = (*s++ & 0377)) != '\0')
788 	{
789 		if (shiftout)
790 		{
791 			(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s",
792 					     TermEscape.te_normal);
793 			shiftout = false;
794 		}
795 		if (!isascii(c) && !tTd(84, 1))
796 		{
797 			if (c == MATCHREPL)
798 			{
799 				(void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
800 						     "%s$",
801 						     TermEscape.te_rv_on);
802 				shiftout = true;
803 				if (*s == '\0')
804 					continue;
805 				c = *s++ & 0377;
806 				goto printchar;
807 			}
808 			if (c == MACROEXPAND || c == MACRODEXPAND)
809 			{
810 				(void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
811 						     "%s$",
812 						     TermEscape.te_rv_on);
813 				if (c == MACRODEXPAND)
814 					(void) sm_io_putc(fp,
815 							  SM_TIME_DEFAULT, '&');
816 				shiftout = true;
817 				if (*s == '\0')
818 					continue;
819 				if (strchr("=~&?", *s) != NULL)
820 					(void) sm_io_putc(fp,
821 							  SM_TIME_DEFAULT,
822 							  *s++);
823 				if (bitset(0200, *s))
824 					(void) sm_io_fprintf(fp,
825 							     SM_TIME_DEFAULT,
826 							     "{%s}",
827 							     macname(bitidx(*s++)));
828 				else
829 					(void) sm_io_fprintf(fp,
830 							     SM_TIME_DEFAULT,
831 							     "%c",
832 							     *s++);
833 				continue;
834 			}
835 			for (mp = MetaMacros; mp->metaname != '\0'; mp++)
836 			{
837 				if (bitidx(mp->metaval) == c)
838 				{
839 					(void) sm_io_fprintf(fp,
840 							     SM_TIME_DEFAULT,
841 							     "%s$%c",
842 							     TermEscape.te_rv_on,
843 							     mp->metaname);
844 					shiftout = true;
845 					break;
846 				}
847 			}
848 			if (c == MATCHCLASS || c == MATCHNCLASS)
849 			{
850 				if (bitset(0200, *s))
851 					(void) sm_io_fprintf(fp,
852 							     SM_TIME_DEFAULT,
853 							     "{%s}",
854 							     macname(bitidx(*s++)));
855 				else if (*s != '\0')
856 					(void) sm_io_fprintf(fp,
857 							     SM_TIME_DEFAULT,
858 							     "%c",
859 							     *s++);
860 			}
861 			if (mp->metaname != '\0')
862 				continue;
863 
864 			/* unrecognized meta character */
865 			(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%sM-",
866 					     TermEscape.te_rv_on);
867 			shiftout = true;
868 			c &= 0177;
869 		}
870   printchar:
871 		if (isascii(c) && isprint(c))
872 		{
873 			(void) sm_io_putc(fp, SM_TIME_DEFAULT, c);
874 			continue;
875 		}
876 
877 		/* wasn't a meta-macro -- find another way to print it */
878 		switch (c)
879 		{
880 		  case '\n':
881 			c = 'n';
882 			break;
883 
884 		  case '\r':
885 			c = 'r';
886 			break;
887 
888 		  case '\t':
889 			c = 't';
890 			break;
891 		}
892 		if (!shiftout)
893 		{
894 			(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s",
895 					     TermEscape.te_rv_on);
896 			shiftout = true;
897 		}
898 		if (isascii(c) && isprint(c))
899 		{
900 			(void) sm_io_putc(fp, SM_TIME_DEFAULT, '\\');
901 			(void) sm_io_putc(fp, SM_TIME_DEFAULT, c);
902 		}
903 		else if (tTd(84, 2))
904 			(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, " %o ", c);
905 		else if (tTd(84, 1))
906 			(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, " %#x ", c);
907 		else if (!isascii(c) && !tTd(84, 1))
908 		{
909 			(void) sm_io_putc(fp, SM_TIME_DEFAULT, '^');
910 			(void) sm_io_putc(fp, SM_TIME_DEFAULT, c ^ 0100);
911 		}
912 	}
913 	if (shiftout)
914 		(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s",
915 				     TermEscape.te_normal);
916 	(void) sm_io_flush(fp, SM_TIME_DEFAULT);
917 }
918 
919 /*
920 **  MAKELOWER -- Translate a line into lower case
921 **
922 **	Parameters:
923 **		p -- the string to translate.  If NULL, return is
924 **			immediate.
925 **
926 **	Returns:
927 **		none.
928 **
929 **	Side Effects:
930 **		String pointed to by p is translated to lower case.
931 */
932 
933 void
makelower(p)934 makelower(p)
935 	register char *p;
936 {
937 	register char c;
938 
939 	if (p == NULL)
940 		return;
941 	for (; (c = *p) != '\0'; p++)
942 		if (isascii(c) && isupper(c))
943 			*p = tolower(c);
944 }
945 
946 /*
947 **  FIXCRLF -- fix <CR><LF> in line.
948 **
949 **	Looks for the <CR><LF> combination and turns it into the
950 **	UNIX canonical <NL> character.  It only takes one line,
951 **	i.e., it is assumed that the first <NL> found is the end
952 **	of the line.
953 **
954 **	Parameters:
955 **		line -- the line to fix.
956 **		stripnl -- if true, strip the newline also.
957 **
958 **	Returns:
959 **		none.
960 **
961 **	Side Effects:
962 **		line is changed in place.
963 */
964 
965 void
fixcrlf(line,stripnl)966 fixcrlf(line, stripnl)
967 	char *line;
968 	bool stripnl;
969 {
970 	register char *p;
971 
972 	p = strchr(line, '\n');
973 	if (p == NULL)
974 		return;
975 	if (p > line && p[-1] == '\r')
976 		p--;
977 	if (!stripnl)
978 		*p++ = '\n';
979 	*p = '\0';
980 }
981 
982 /*
983 **  PUTLINE -- put a line like fputs obeying SMTP conventions
984 **
985 **	This routine always guarantees outputing a newline (or CRLF,
986 **	as appropriate) at the end of the string.
987 **
988 **	Parameters:
989 **		l -- line to put.
990 **		mci -- the mailer connection information.
991 **
992 **	Returns:
993 **		true iff line was written successfully
994 **
995 **	Side Effects:
996 **		output of l to mci->mci_out.
997 */
998 
999 bool
putline(l,mci)1000 putline(l, mci)
1001 	register char *l;
1002 	register MCI *mci;
1003 {
1004 	return putxline(l, strlen(l), mci, PXLF_MAPFROM);
1005 }
1006 
1007 /*
1008 **  PUTXLINE -- putline with flags bits.
1009 **
1010 **	This routine always guarantees outputing a newline (or CRLF,
1011 **	as appropriate) at the end of the string.
1012 **
1013 **	Parameters:
1014 **		l -- line to put.
1015 **		len -- the length of the line.
1016 **		mci -- the mailer connection information.
1017 **		pxflags -- flag bits:
1018 **		    PXLF_MAPFROM -- map From_ to >From_.
1019 **		    PXLF_STRIP8BIT -- strip 8th bit.
1020 **		    PXLF_HEADER -- map bare newline in header to newline space.
1021 **		    PXLF_NOADDEOL -- don't add an EOL if one wasn't present.
1022 **		    PXLF_STRIPMQUOTE -- strip METAQUOTE bytes.
1023 **
1024 **	Returns:
1025 **		true iff line was written successfully
1026 **
1027 **	Side Effects:
1028 **		output of l to mci->mci_out.
1029 */
1030 
1031 
1032 #define PUTX(limit)							\
1033 	do								\
1034 	{								\
1035 		quotenext = false;					\
1036 		while (l < limit)					\
1037 		{							\
1038 			unsigned char c = (unsigned char) *l++;		\
1039 									\
1040 			if (bitset(PXLF_STRIPMQUOTE, pxflags) &&	\
1041 			    !quotenext && c == METAQUOTE)		\
1042 			{						\
1043 				quotenext = true;			\
1044 				continue;				\
1045 			}						\
1046 			quotenext = false;				\
1047 			if (strip8bit)					\
1048 				c &= 0177;				\
1049 			if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,	\
1050 				       c) == SM_IO_EOF)			\
1051 			{						\
1052 				dead = true;				\
1053 				break;					\
1054 			}						\
1055 			if (TrafficLogFile != NULL)			\
1056 				(void) sm_io_putc(TrafficLogFile,	\
1057 						  SM_TIME_DEFAULT,	\
1058 						  c);			\
1059 		}							\
1060 	} while (0)
1061 
1062 bool
putxline(l,len,mci,pxflags)1063 putxline(l, len, mci, pxflags)
1064 	register char *l;
1065 	size_t len;
1066 	register MCI *mci;
1067 	int pxflags;
1068 {
1069 	register char *p, *end;
1070 	int slop;
1071 	bool dead, quotenext, strip8bit;
1072 
1073 	/* strip out 0200 bits -- these can look like TELNET protocol */
1074 	strip8bit = bitset(MCIF_7BIT, mci->mci_flags) ||
1075 		    bitset(PXLF_STRIP8BIT, pxflags);
1076 	dead = false;
1077 	slop = 0;
1078 
1079 	end = l + len;
1080 	do
1081 	{
1082 		bool noeol = false;
1083 
1084 		/* find the end of the line */
1085 		p = memchr(l, '\n', end - l);
1086 		if (p == NULL)
1087 		{
1088 			p = end;
1089 			noeol = true;
1090 		}
1091 
1092 		if (TrafficLogFile != NULL)
1093 			(void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT,
1094 					     "%05d >>> ", (int) CurrentPid);
1095 
1096 		/* check for line overflow */
1097 		while (mci->mci_mailer->m_linelimit > 0 &&
1098 		       (p - l + slop) > mci->mci_mailer->m_linelimit)
1099 		{
1100 			register char *q = &l[mci->mci_mailer->m_linelimit - slop - 1];
1101 
1102 			if (l[0] == '.' && slop == 0 &&
1103 			    bitnset(M_XDOT, mci->mci_mailer->m_flags))
1104 			{
1105 				if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
1106 					       '.') == SM_IO_EOF)
1107 					dead = true;
1108 				if (TrafficLogFile != NULL)
1109 					(void) sm_io_putc(TrafficLogFile,
1110 							  SM_TIME_DEFAULT, '.');
1111 			}
1112 			else if (l[0] == 'F' && slop == 0 &&
1113 				 bitset(PXLF_MAPFROM, pxflags) &&
1114 				 strncmp(l, "From ", 5) == 0 &&
1115 				 bitnset(M_ESCFROM, mci->mci_mailer->m_flags))
1116 			{
1117 				if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
1118 					       '>') == SM_IO_EOF)
1119 					dead = true;
1120 				if (TrafficLogFile != NULL)
1121 					(void) sm_io_putc(TrafficLogFile,
1122 							  SM_TIME_DEFAULT,
1123 							  '>');
1124 			}
1125 			if (dead)
1126 				break;
1127 
1128 			PUTX(q);
1129 			if (dead)
1130 				break;
1131 
1132 			if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
1133 					'!') == SM_IO_EOF ||
1134 			    sm_io_fputs(mci->mci_out, SM_TIME_DEFAULT,
1135 					mci->mci_mailer->m_eol) == SM_IO_EOF ||
1136 			    sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
1137 					' ') == SM_IO_EOF)
1138 			{
1139 				dead = true;
1140 				break;
1141 			}
1142 			if (TrafficLogFile != NULL)
1143 			{
1144 				(void) sm_io_fprintf(TrafficLogFile,
1145 						     SM_TIME_DEFAULT,
1146 						     "!\n%05d >>>  ",
1147 						     (int) CurrentPid);
1148 			}
1149 			slop = 1;
1150 		}
1151 
1152 		if (dead)
1153 			break;
1154 
1155 		/* output last part */
1156 		if (l[0] == '.' && slop == 0 &&
1157 		    bitnset(M_XDOT, mci->mci_mailer->m_flags) &&
1158 		    !bitset(MCIF_INLONGLINE, mci->mci_flags))
1159 		{
1160 			if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, '.') ==
1161 			    SM_IO_EOF)
1162 			{
1163 				dead = true;
1164 				break;
1165 			}
1166 			if (TrafficLogFile != NULL)
1167 				(void) sm_io_putc(TrafficLogFile,
1168 						  SM_TIME_DEFAULT, '.');
1169 		}
1170 		else if (l[0] == 'F' && slop == 0 &&
1171 			 bitset(PXLF_MAPFROM, pxflags) &&
1172 			 strncmp(l, "From ", 5) == 0 &&
1173 			 bitnset(M_ESCFROM, mci->mci_mailer->m_flags) &&
1174 			 !bitset(MCIF_INLONGLINE, mci->mci_flags))
1175 		{
1176 			if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, '>') ==
1177 			    SM_IO_EOF)
1178 			{
1179 				dead = true;
1180 				break;
1181 			}
1182 			if (TrafficLogFile != NULL)
1183 				(void) sm_io_putc(TrafficLogFile,
1184 						  SM_TIME_DEFAULT, '>');
1185 		}
1186 		PUTX(p);
1187 		if (dead)
1188 			break;
1189 
1190 		if (TrafficLogFile != NULL)
1191 			(void) sm_io_putc(TrafficLogFile, SM_TIME_DEFAULT,
1192 					  '\n');
1193 		if ((!bitset(PXLF_NOADDEOL, pxflags) || !noeol))
1194 		{
1195 			mci->mci_flags &= ~MCIF_INLONGLINE;
1196 			if (sm_io_fputs(mci->mci_out, SM_TIME_DEFAULT,
1197 					mci->mci_mailer->m_eol) == SM_IO_EOF)
1198 			{
1199 				dead = true;
1200 				break;
1201 			}
1202 		}
1203 		else
1204 			mci->mci_flags |= MCIF_INLONGLINE;
1205 
1206 		if (l < end && *l == '\n')
1207 		{
1208 			if (*++l != ' ' && *l != '\t' && *l != '\0' &&
1209 			    bitset(PXLF_HEADER, pxflags))
1210 			{
1211 				if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
1212 					       ' ') == SM_IO_EOF)
1213 				{
1214 					dead = true;
1215 					break;
1216 				}
1217 
1218 				if (TrafficLogFile != NULL)
1219 					(void) sm_io_putc(TrafficLogFile,
1220 							  SM_TIME_DEFAULT, ' ');
1221 			}
1222 		}
1223 
1224 	} while (l < end);
1225 	return !dead;
1226 }
1227 
1228 /*
1229 **  XUNLINK -- unlink a file, doing logging as appropriate.
1230 **
1231 **	Parameters:
1232 **		f -- name of file to unlink.
1233 **
1234 **	Returns:
1235 **		return value of unlink()
1236 **
1237 **	Side Effects:
1238 **		f is unlinked.
1239 */
1240 
1241 int
xunlink(f)1242 xunlink(f)
1243 	char *f;
1244 {
1245 	register int i;
1246 	int save_errno;
1247 
1248 	if (LogLevel > 98)
1249 		sm_syslog(LOG_DEBUG, CurEnv->e_id, "unlink %s", f);
1250 
1251 	i = unlink(f);
1252 	save_errno = errno;
1253 	if (i < 0 && LogLevel > 97)
1254 		sm_syslog(LOG_DEBUG, CurEnv->e_id, "%s: unlink-fail %d",
1255 			  f, errno);
1256 	if (i >= 0)
1257 		SYNC_DIR(f, false);
1258 	errno = save_errno;
1259 	return i;
1260 }
1261 
1262 /*
1263 **  SFGETS -- "safe" fgets -- times out and ignores random interrupts.
1264 **
1265 **	Parameters:
1266 **		buf -- place to put the input line.
1267 **		siz -- size of buf.
1268 **		fp -- file to read from.
1269 **		timeout -- the timeout before error occurs.
1270 **		during -- what we are trying to read (for error messages).
1271 **
1272 **	Returns:
1273 **		NULL on error (including timeout).  This may also leave
1274 **			buf containing a null string.
1275 **		buf otherwise.
1276 */
1277 
1278 
1279 char *
sfgets(buf,siz,fp,timeout,during)1280 sfgets(buf, siz, fp, timeout, during)
1281 	char *buf;
1282 	int siz;
1283 	SM_FILE_T *fp;
1284 	time_t timeout;
1285 	char *during;
1286 {
1287 	register char *p;
1288 	int save_errno;
1289 	int io_timeout;
1290 
1291 	SM_REQUIRE(siz > 0);
1292 	SM_REQUIRE(buf != NULL);
1293 
1294 	if (fp == NULL)
1295 	{
1296 		buf[0] = '\0';
1297 		errno = EBADF;
1298 		return NULL;
1299 	}
1300 
1301 	/* try to read */
1302 	p = NULL;
1303 	errno = 0;
1304 
1305 	/* convert the timeout to sm_io notation */
1306 	io_timeout = (timeout <= 0) ? SM_TIME_DEFAULT : timeout * 1000;
1307 	while (!sm_io_eof(fp) && !sm_io_error(fp))
1308 	{
1309 		errno = 0;
1310 		p = sm_io_fgets(fp, io_timeout, buf, siz);
1311 		if (p == NULL && errno == EAGAIN)
1312 		{
1313 			/* The sm_io_fgets() call timedout */
1314 			if (LogLevel > 1)
1315 				sm_syslog(LOG_NOTICE, CurEnv->e_id,
1316 					  "timeout waiting for input from %.100s during %s",
1317 					  CURHOSTNAME,
1318 					  during);
1319 			buf[0] = '\0';
1320 #if XDEBUG
1321 			checkfd012(during);
1322 #endif /* XDEBUG */
1323 			if (TrafficLogFile != NULL)
1324 				(void) sm_io_fprintf(TrafficLogFile,
1325 						     SM_TIME_DEFAULT,
1326 						     "%05d <<< [TIMEOUT]\n",
1327 						     (int) CurrentPid);
1328 			errno = ETIMEDOUT;
1329 			return NULL;
1330 		}
1331 		if (p != NULL || errno != EINTR)
1332 			break;
1333 		(void) sm_io_clearerr(fp);
1334 	}
1335 	save_errno = errno;
1336 
1337 	/* clean up the books and exit */
1338 	LineNumber++;
1339 	if (p == NULL)
1340 	{
1341 		buf[0] = '\0';
1342 		if (TrafficLogFile != NULL)
1343 			(void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT,
1344 					     "%05d <<< [EOF]\n",
1345 					     (int) CurrentPid);
1346 		errno = save_errno;
1347 		return NULL;
1348 	}
1349 	if (TrafficLogFile != NULL)
1350 		(void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT,
1351 				     "%05d <<< %s", (int) CurrentPid, buf);
1352 	if (SevenBitInput)
1353 	{
1354 		for (p = buf; *p != '\0'; p++)
1355 			*p &= ~0200;
1356 	}
1357 	else if (!HasEightBits)
1358 	{
1359 		for (p = buf; *p != '\0'; p++)
1360 		{
1361 			if (bitset(0200, *p))
1362 			{
1363 				HasEightBits = true;
1364 				break;
1365 			}
1366 		}
1367 	}
1368 	return buf;
1369 }
1370 
1371 /*
1372 **  FGETFOLDED -- like fgets, but knows about folded lines.
1373 **
1374 **	Parameters:
1375 **		buf -- place to put result.
1376 **		np -- pointer to bytes available; will be updated with
1377 **			the actual buffer size (not number of bytes filled)
1378 **			on return.
1379 **		f -- file to read from.
1380 **
1381 **	Returns:
1382 **		input line(s) on success, NULL on error or SM_IO_EOF.
1383 **		This will normally be buf -- unless the line is too
1384 **			long, when it will be sm_malloc_x()ed.
1385 **
1386 **	Side Effects:
1387 **		buf gets lines from f, with continuation lines (lines
1388 **		with leading white space) appended.  CRLF's are mapped
1389 **		into single newlines.  Any trailing NL is stripped.
1390 */
1391 
1392 char *
fgetfolded(buf,np,f)1393 fgetfolded(buf, np, f)
1394 	char *buf;
1395 	int *np;
1396 	SM_FILE_T *f;
1397 {
1398 	register char *p = buf;
1399 	char *bp = buf;
1400 	register int i;
1401 	int n;
1402 
1403 	SM_REQUIRE(np != NULL);
1404 	n = *np;
1405 	SM_REQUIRE(n > 0);
1406 	SM_REQUIRE(buf != NULL);
1407 	if (f == NULL)
1408 	{
1409 		buf[0] = '\0';
1410 		errno = EBADF;
1411 		return NULL;
1412 	}
1413 
1414 	n--;
1415 	while ((i = sm_io_getc(f, SM_TIME_DEFAULT)) != SM_IO_EOF)
1416 	{
1417 		if (i == '\r')
1418 		{
1419 			i = sm_io_getc(f, SM_TIME_DEFAULT);
1420 			if (i != '\n')
1421 			{
1422 				if (i != SM_IO_EOF)
1423 					(void) sm_io_ungetc(f, SM_TIME_DEFAULT,
1424 							    i);
1425 				i = '\r';
1426 			}
1427 		}
1428 		if (--n <= 0)
1429 		{
1430 			/* allocate new space */
1431 			char *nbp;
1432 			int nn;
1433 
1434 			nn = (p - bp);
1435 			if (nn < MEMCHUNKSIZE)
1436 				nn *= 2;
1437 			else
1438 				nn += MEMCHUNKSIZE;
1439 			nbp = sm_malloc_x(nn);
1440 			memmove(nbp, bp, p - bp);
1441 			p = &nbp[p - bp];
1442 			if (bp != buf)
1443 				sm_free(bp);
1444 			bp = nbp;
1445 			n = nn - (p - bp);
1446 			*np = nn;
1447 		}
1448 		*p++ = i;
1449 		if (i == '\n')
1450 		{
1451 			LineNumber++;
1452 			i = sm_io_getc(f, SM_TIME_DEFAULT);
1453 			if (i != SM_IO_EOF)
1454 				(void) sm_io_ungetc(f, SM_TIME_DEFAULT, i);
1455 			if (i != ' ' && i != '\t')
1456 				break;
1457 		}
1458 	}
1459 	if (p == bp)
1460 		return NULL;
1461 	if (p[-1] == '\n')
1462 		p--;
1463 	*p = '\0';
1464 	return bp;
1465 }
1466 
1467 /*
1468 **  CURTIME -- return current time.
1469 **
1470 **	Parameters:
1471 **		none.
1472 **
1473 **	Returns:
1474 **		the current time.
1475 */
1476 
1477 time_t
curtime()1478 curtime()
1479 {
1480 	auto time_t t;
1481 
1482 	(void) time(&t);
1483 	return t;
1484 }
1485 
1486 /*
1487 **  ATOBOOL -- convert a string representation to boolean.
1488 **
1489 **	Defaults to false
1490 **
1491 **	Parameters:
1492 **		s -- string to convert.  Takes "tTyY", empty, and NULL as true,
1493 **			others as false.
1494 **
1495 **	Returns:
1496 **		A boolean representation of the string.
1497 */
1498 
1499 bool
atobool(s)1500 atobool(s)
1501 	register char *s;
1502 {
1503 	if (s == NULL || *s == '\0' || strchr("tTyY", *s) != NULL)
1504 		return true;
1505 	return false;
1506 }
1507 
1508 /*
1509 **  ATOOCT -- convert a string representation to octal.
1510 **
1511 **	Parameters:
1512 **		s -- string to convert.
1513 **
1514 **	Returns:
1515 **		An integer representing the string interpreted as an
1516 **		octal number.
1517 */
1518 
1519 int
atooct(s)1520 atooct(s)
1521 	register char *s;
1522 {
1523 	register int i = 0;
1524 
1525 	while (*s >= '0' && *s <= '7')
1526 		i = (i << 3) | (*s++ - '0');
1527 	return i;
1528 }
1529 
1530 /*
1531 **  BITINTERSECT -- tell if two bitmaps intersect
1532 **
1533 **	Parameters:
1534 **		a, b -- the bitmaps in question
1535 **
1536 **	Returns:
1537 **		true if they have a non-null intersection
1538 **		false otherwise
1539 */
1540 
1541 bool
bitintersect(a,b)1542 bitintersect(a, b)
1543 	BITMAP256 a;
1544 	BITMAP256 b;
1545 {
1546 	int i;
1547 
1548 	for (i = BITMAPBYTES / sizeof(int); --i >= 0; )
1549 	{
1550 		if ((a[i] & b[i]) != 0)
1551 			return true;
1552 	}
1553 	return false;
1554 }
1555 
1556 /*
1557 **  BITZEROP -- tell if a bitmap is all zero
1558 **
1559 **	Parameters:
1560 **		map -- the bit map to check
1561 **
1562 **	Returns:
1563 **		true if map is all zero.
1564 **		false if there are any bits set in map.
1565 */
1566 
1567 bool
bitzerop(map)1568 bitzerop(map)
1569 	BITMAP256 map;
1570 {
1571 	int i;
1572 
1573 	for (i = BITMAPBYTES / sizeof(int); --i >= 0; )
1574 	{
1575 		if (map[i] != 0)
1576 			return false;
1577 	}
1578 	return true;
1579 }
1580 
1581 /*
1582 **  STRCONTAINEDIN -- tell if one string is contained in another
1583 **
1584 **	Parameters:
1585 **		icase -- ignore case?
1586 **		a -- possible substring.
1587 **		b -- possible superstring.
1588 **
1589 **	Returns:
1590 **		true if a is contained in b (case insensitive).
1591 **		false otherwise.
1592 */
1593 
1594 bool
strcontainedin(icase,a,b)1595 strcontainedin(icase, a, b)
1596 	bool icase;
1597 	register char *a;
1598 	register char *b;
1599 {
1600 	int la;
1601 	int lb;
1602 	int c;
1603 
1604 	la = strlen(a);
1605 	lb = strlen(b);
1606 	c = *a;
1607 	if (icase && isascii(c) && isupper(c))
1608 		c = tolower(c);
1609 	for (; lb-- >= la; b++)
1610 	{
1611 		if (icase)
1612 		{
1613 			if (*b != c &&
1614 			    isascii(*b) && isupper(*b) && tolower(*b) != c)
1615 				continue;
1616 			if (sm_strncasecmp(a, b, la) == 0)
1617 				return true;
1618 		}
1619 		else
1620 		{
1621 			if (*b != c)
1622 				continue;
1623 			if (strncmp(a, b, la) == 0)
1624 				return true;
1625 		}
1626 	}
1627 	return false;
1628 }
1629 
1630 /*
1631 **  CHECKFD012 -- check low numbered file descriptors
1632 **
1633 **	File descriptors 0, 1, and 2 should be open at all times.
1634 **	This routine verifies that, and fixes it if not true.
1635 **
1636 **	Parameters:
1637 **		where -- a tag printed if the assertion failed
1638 **
1639 **	Returns:
1640 **		none
1641 */
1642 
1643 void
checkfd012(where)1644 checkfd012(where)
1645 	char *where;
1646 {
1647 #if XDEBUG
1648 	register int i;
1649 
1650 	for (i = 0; i < 3; i++)
1651 		fill_fd(i, where);
1652 #endif /* XDEBUG */
1653 }
1654 
1655 /*
1656 **  CHECKFDOPEN -- make sure file descriptor is open -- for extended debugging
1657 **
1658 **	Parameters:
1659 **		fd -- file descriptor to check.
1660 **		where -- tag to print on failure.
1661 **
1662 **	Returns:
1663 **		none.
1664 */
1665 
1666 void
checkfdopen(fd,where)1667 checkfdopen(fd, where)
1668 	int fd;
1669 	char *where;
1670 {
1671 #if XDEBUG
1672 	struct stat st;
1673 
1674 	if (fstat(fd, &st) < 0 && errno == EBADF)
1675 	{
1676 		syserr("checkfdopen(%d): %s not open as expected!", fd, where);
1677 		printopenfds(true);
1678 	}
1679 #endif /* XDEBUG */
1680 }
1681 
1682 /*
1683 **  CHECKFDS -- check for new or missing file descriptors
1684 **
1685 **	Parameters:
1686 **		where -- tag for printing.  If null, take a base line.
1687 **
1688 **	Returns:
1689 **		none
1690 **
1691 **	Side Effects:
1692 **		If where is set, shows changes since the last call.
1693 */
1694 
1695 void
checkfds(where)1696 checkfds(where)
1697 	char *where;
1698 {
1699 	int maxfd;
1700 	register int fd;
1701 	bool printhdr = true;
1702 	int save_errno = errno;
1703 	static BITMAP256 baseline;
1704 	extern int DtableSize;
1705 
1706 	if (DtableSize > BITMAPBITS)
1707 		maxfd = BITMAPBITS;
1708 	else
1709 		maxfd = DtableSize;
1710 	if (where == NULL)
1711 		clrbitmap(baseline);
1712 
1713 	for (fd = 0; fd < maxfd; fd++)
1714 	{
1715 		struct stat stbuf;
1716 
1717 		if (fstat(fd, &stbuf) < 0 && errno != EOPNOTSUPP)
1718 		{
1719 			if (!bitnset(fd, baseline))
1720 				continue;
1721 			clrbitn(fd, baseline);
1722 		}
1723 		else if (!bitnset(fd, baseline))
1724 			setbitn(fd, baseline);
1725 		else
1726 			continue;
1727 
1728 		/* file state has changed */
1729 		if (where == NULL)
1730 			continue;
1731 		if (printhdr)
1732 		{
1733 			sm_syslog(LOG_DEBUG, CurEnv->e_id,
1734 				  "%s: changed fds:",
1735 				  where);
1736 			printhdr = false;
1737 		}
1738 		dumpfd(fd, true, true);
1739 	}
1740 	errno = save_errno;
1741 }
1742 
1743 /*
1744 **  PRINTOPENFDS -- print the open file descriptors (for debugging)
1745 **
1746 **	Parameters:
1747 **		logit -- if set, send output to syslog; otherwise
1748 **			print for debugging.
1749 **
1750 **	Returns:
1751 **		none.
1752 */
1753 
1754 #if NETINET || NETINET6
1755 # include <arpa/inet.h>
1756 #endif /* NETINET || NETINET6 */
1757 
1758 void
printopenfds(logit)1759 printopenfds(logit)
1760 	bool logit;
1761 {
1762 	register int fd;
1763 	extern int DtableSize;
1764 
1765 	for (fd = 0; fd < DtableSize; fd++)
1766 		dumpfd(fd, false, logit);
1767 }
1768 
1769 /*
1770 **  DUMPFD -- dump a file descriptor
1771 **
1772 **	Parameters:
1773 **		fd -- the file descriptor to dump.
1774 **		printclosed -- if set, print a notification even if
1775 **			it is closed; otherwise print nothing.
1776 **		logit -- if set, use sm_syslog instead of sm_dprintf()
1777 **
1778 **	Returns:
1779 **		none.
1780 */
1781 
1782 void
dumpfd(fd,printclosed,logit)1783 dumpfd(fd, printclosed, logit)
1784 	int fd;
1785 	bool printclosed;
1786 	bool logit;
1787 {
1788 	register char *p;
1789 	char *hp;
1790 #ifdef S_IFSOCK
1791 	SOCKADDR sa;
1792 #endif /* S_IFSOCK */
1793 	auto SOCKADDR_LEN_T slen;
1794 	int i;
1795 #if STAT64 > 0
1796 	struct stat64 st;
1797 #else /* STAT64 > 0 */
1798 	struct stat st;
1799 #endif /* STAT64 > 0 */
1800 	char buf[200];
1801 
1802 	p = buf;
1803 	(void) sm_snprintf(p, SPACELEFT(buf, p), "%3d: ", fd);
1804 	p += strlen(p);
1805 
1806 	if (
1807 #if STAT64 > 0
1808 	    fstat64(fd, &st)
1809 #else /* STAT64 > 0 */
1810 	    fstat(fd, &st)
1811 #endif /* STAT64 > 0 */
1812 	    < 0)
1813 	{
1814 		if (errno != EBADF)
1815 		{
1816 			(void) sm_snprintf(p, SPACELEFT(buf, p),
1817 				"CANNOT STAT (%s)",
1818 				sm_errstring(errno));
1819 			goto printit;
1820 		}
1821 		else if (printclosed)
1822 		{
1823 			(void) sm_snprintf(p, SPACELEFT(buf, p), "CLOSED");
1824 			goto printit;
1825 		}
1826 		return;
1827 	}
1828 
1829 	i = fcntl(fd, F_GETFL, 0);
1830 	if (i != -1)
1831 	{
1832 		(void) sm_snprintf(p, SPACELEFT(buf, p), "fl=0x%x, ", i);
1833 		p += strlen(p);
1834 	}
1835 
1836 	(void) sm_snprintf(p, SPACELEFT(buf, p), "mode=%o: ",
1837 			(int) st.st_mode);
1838 	p += strlen(p);
1839 	switch (st.st_mode & S_IFMT)
1840 	{
1841 #ifdef S_IFSOCK
1842 	  case S_IFSOCK:
1843 		(void) sm_snprintf(p, SPACELEFT(buf, p), "SOCK ");
1844 		p += strlen(p);
1845 		memset(&sa, '\0', sizeof(sa));
1846 		slen = sizeof(sa);
1847 		if (getsockname(fd, &sa.sa, &slen) < 0)
1848 			(void) sm_snprintf(p, SPACELEFT(buf, p), "(%s)",
1849 				 sm_errstring(errno));
1850 		else
1851 		{
1852 			hp = hostnamebyanyaddr(&sa);
1853 			if (hp == NULL)
1854 			{
1855 				/* EMPTY */
1856 				/* do nothing */
1857 			}
1858 # if NETINET
1859 			else if (sa.sa.sa_family == AF_INET)
1860 				(void) sm_snprintf(p, SPACELEFT(buf, p),
1861 					"%s/%d", hp, ntohs(sa.sin.sin_port));
1862 # endif /* NETINET */
1863 # if NETINET6
1864 			else if (sa.sa.sa_family == AF_INET6)
1865 				(void) sm_snprintf(p, SPACELEFT(buf, p),
1866 					"%s/%d", hp, ntohs(sa.sin6.sin6_port));
1867 # endif /* NETINET6 */
1868 			else
1869 				(void) sm_snprintf(p, SPACELEFT(buf, p),
1870 					"%s", hp);
1871 		}
1872 		p += strlen(p);
1873 		(void) sm_snprintf(p, SPACELEFT(buf, p), "->");
1874 		p += strlen(p);
1875 		slen = sizeof(sa);
1876 		if (getpeername(fd, &sa.sa, &slen) < 0)
1877 			(void) sm_snprintf(p, SPACELEFT(buf, p), "(%s)",
1878 					sm_errstring(errno));
1879 		else
1880 		{
1881 			hp = hostnamebyanyaddr(&sa);
1882 			if (hp == NULL)
1883 			{
1884 				/* EMPTY */
1885 				/* do nothing */
1886 			}
1887 # if NETINET
1888 			else if (sa.sa.sa_family == AF_INET)
1889 				(void) sm_snprintf(p, SPACELEFT(buf, p),
1890 					"%s/%d", hp, ntohs(sa.sin.sin_port));
1891 # endif /* NETINET */
1892 # if NETINET6
1893 			else if (sa.sa.sa_family == AF_INET6)
1894 				(void) sm_snprintf(p, SPACELEFT(buf, p),
1895 					"%s/%d", hp, ntohs(sa.sin6.sin6_port));
1896 # endif /* NETINET6 */
1897 			else
1898 				(void) sm_snprintf(p, SPACELEFT(buf, p),
1899 					"%s", hp);
1900 		}
1901 		break;
1902 #endif /* S_IFSOCK */
1903 
1904 	  case S_IFCHR:
1905 		(void) sm_snprintf(p, SPACELEFT(buf, p), "CHR: ");
1906 		p += strlen(p);
1907 		goto defprint;
1908 
1909 #ifdef S_IFBLK
1910 	  case S_IFBLK:
1911 		(void) sm_snprintf(p, SPACELEFT(buf, p), "BLK: ");
1912 		p += strlen(p);
1913 		goto defprint;
1914 #endif /* S_IFBLK */
1915 
1916 #if defined(S_IFIFO) && (!defined(S_IFSOCK) || S_IFIFO != S_IFSOCK)
1917 	  case S_IFIFO:
1918 		(void) sm_snprintf(p, SPACELEFT(buf, p), "FIFO: ");
1919 		p += strlen(p);
1920 		goto defprint;
1921 #endif /* defined(S_IFIFO) && (!defined(S_IFSOCK) || S_IFIFO != S_IFSOCK) */
1922 
1923 #ifdef S_IFDIR
1924 	  case S_IFDIR:
1925 		(void) sm_snprintf(p, SPACELEFT(buf, p), "DIR: ");
1926 		p += strlen(p);
1927 		goto defprint;
1928 #endif /* S_IFDIR */
1929 
1930 #ifdef S_IFLNK
1931 	  case S_IFLNK:
1932 		(void) sm_snprintf(p, SPACELEFT(buf, p), "LNK: ");
1933 		p += strlen(p);
1934 		goto defprint;
1935 #endif /* S_IFLNK */
1936 
1937 	  default:
1938 defprint:
1939 		(void) sm_snprintf(p, SPACELEFT(buf, p),
1940 			 "dev=%d/%d, ino=%llu, nlink=%d, u/gid=%d/%d, ",
1941 			 major(st.st_dev), minor(st.st_dev),
1942 			 (ULONGLONG_T) st.st_ino,
1943 			 (int) st.st_nlink, (int) st.st_uid,
1944 			 (int) st.st_gid);
1945 		p += strlen(p);
1946 		(void) sm_snprintf(p, SPACELEFT(buf, p), "size=%llu",
1947 			 (ULONGLONG_T) st.st_size);
1948 		break;
1949 	}
1950 
1951 printit:
1952 	if (logit)
1953 		sm_syslog(LOG_DEBUG, CurEnv ? CurEnv->e_id : NULL,
1954 			  "%.800s", buf);
1955 	else
1956 		sm_dprintf("%s\n", buf);
1957 }
1958 
1959 /*
1960 **  SHORTEN_HOSTNAME -- strip local domain information off of hostname.
1961 **
1962 **	Parameters:
1963 **		host -- the host to shorten (stripped in place).
1964 **
1965 **	Returns:
1966 **		place where string was truncated, NULL if not truncated.
1967 */
1968 
1969 char *
shorten_hostname(host)1970 shorten_hostname(host)
1971 	char host[];
1972 {
1973 	register char *p;
1974 	char *mydom;
1975 	int i;
1976 	bool canon = false;
1977 
1978 	/* strip off final dot */
1979 	i = strlen(host);
1980 	p = &host[(i == 0) ? 0 : i - 1];
1981 	if (*p == '.')
1982 	{
1983 		*p = '\0';
1984 		canon = true;
1985 	}
1986 
1987 	/* see if there is any domain at all -- if not, we are done */
1988 	p = strchr(host, '.');
1989 	if (p == NULL)
1990 		return NULL;
1991 
1992 	/* yes, we have a domain -- see if it looks like us */
1993 	mydom = macvalue('m', CurEnv);
1994 	if (mydom == NULL)
1995 		mydom = "";
1996 	i = strlen(++p);
1997 	if ((canon ? sm_strcasecmp(p, mydom)
1998 		   : sm_strncasecmp(p, mydom, i)) == 0 &&
1999 			(mydom[i] == '.' || mydom[i] == '\0'))
2000 	{
2001 		*--p = '\0';
2002 		return p;
2003 	}
2004 	return NULL;
2005 }
2006 
2007 /*
2008 **  PROG_OPEN -- open a program for reading
2009 **
2010 **	Parameters:
2011 **		argv -- the argument list.
2012 **		pfd -- pointer to a place to store the file descriptor.
2013 **		e -- the current envelope.
2014 **
2015 **	Returns:
2016 **		pid of the process -- -1 if it failed.
2017 */
2018 
2019 pid_t
prog_open(argv,pfd,e)2020 prog_open(argv, pfd, e)
2021 	char **argv;
2022 	int *pfd;
2023 	ENVELOPE *e;
2024 {
2025 	pid_t pid;
2026 	int save_errno;
2027 	int sff;
2028 	int ret;
2029 	int fdv[2];
2030 	char *p, *q;
2031 	char buf[MAXPATHLEN];
2032 	extern int DtableSize;
2033 
2034 	if (pipe(fdv) < 0)
2035 	{
2036 		syserr("%s: cannot create pipe for stdout", argv[0]);
2037 		return -1;
2038 	}
2039 	pid = fork();
2040 	if (pid < 0)
2041 	{
2042 		syserr("%s: cannot fork", argv[0]);
2043 		(void) close(fdv[0]);
2044 		(void) close(fdv[1]);
2045 		return -1;
2046 	}
2047 	if (pid > 0)
2048 	{
2049 		/* parent */
2050 		(void) close(fdv[1]);
2051 		*pfd = fdv[0];
2052 		return pid;
2053 	}
2054 
2055 	/* Reset global flags */
2056 	RestartRequest = NULL;
2057 	RestartWorkGroup = false;
2058 	ShutdownRequest = NULL;
2059 	PendingSignal = 0;
2060 	CurrentPid = getpid();
2061 
2062 	/*
2063 	**  Initialize exception stack and default exception
2064 	**  handler for child process.
2065 	*/
2066 
2067 	sm_exc_newthread(fatal_error);
2068 
2069 	/* child -- close stdin */
2070 	(void) close(0);
2071 
2072 	/* stdout goes back to parent */
2073 	(void) close(fdv[0]);
2074 	if (dup2(fdv[1], 1) < 0)
2075 	{
2076 		syserr("%s: cannot dup2 for stdout", argv[0]);
2077 		_exit(EX_OSERR);
2078 	}
2079 	(void) close(fdv[1]);
2080 
2081 	/* stderr goes to transcript if available */
2082 	if (e->e_xfp != NULL)
2083 	{
2084 		int xfd;
2085 
2086 		xfd = sm_io_getinfo(e->e_xfp, SM_IO_WHAT_FD, NULL);
2087 		if (xfd >= 0 && dup2(xfd, 2) < 0)
2088 		{
2089 			syserr("%s: cannot dup2 for stderr", argv[0]);
2090 			_exit(EX_OSERR);
2091 		}
2092 	}
2093 
2094 	/* this process has no right to the queue file */
2095 	if (e->e_lockfp != NULL)
2096 	{
2097 		int fd;
2098 
2099 		fd = sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD, NULL);
2100 		if (fd >= 0)
2101 			(void) close(fd);
2102 		else
2103 			syserr("%s: lockfp does not have a fd", argv[0]);
2104 	}
2105 
2106 	/* chroot to the program mailer directory, if defined */
2107 	if (ProgMailer != NULL && ProgMailer->m_rootdir != NULL)
2108 	{
2109 		expand(ProgMailer->m_rootdir, buf, sizeof(buf), e);
2110 		if (chroot(buf) < 0)
2111 		{
2112 			syserr("prog_open: cannot chroot(%s)", buf);
2113 			exit(EX_TEMPFAIL);
2114 		}
2115 		if (chdir("/") < 0)
2116 		{
2117 			syserr("prog_open: cannot chdir(/)");
2118 			exit(EX_TEMPFAIL);
2119 		}
2120 	}
2121 
2122 	/* run as default user */
2123 	endpwent();
2124 	sm_mbdb_terminate();
2125 #if _FFR_MEMSTAT
2126 	(void) sm_memstat_close();
2127 #endif /* _FFR_MEMSTAT */
2128 	if (setgid(DefGid) < 0 && geteuid() == 0)
2129 	{
2130 		syserr("prog_open: setgid(%ld) failed", (long) DefGid);
2131 		exit(EX_TEMPFAIL);
2132 	}
2133 	if (setuid(DefUid) < 0 && geteuid() == 0)
2134 	{
2135 		syserr("prog_open: setuid(%ld) failed", (long) DefUid);
2136 		exit(EX_TEMPFAIL);
2137 	}
2138 
2139 	/* run in some directory */
2140 	if (ProgMailer != NULL)
2141 		p = ProgMailer->m_execdir;
2142 	else
2143 		p = NULL;
2144 	for (; p != NULL; p = q)
2145 	{
2146 		q = strchr(p, ':');
2147 		if (q != NULL)
2148 			*q = '\0';
2149 		expand(p, buf, sizeof(buf), e);
2150 		if (q != NULL)
2151 			*q++ = ':';
2152 		if (buf[0] != '\0' && chdir(buf) >= 0)
2153 			break;
2154 	}
2155 	if (p == NULL)
2156 	{
2157 		/* backup directories */
2158 		if (chdir("/tmp") < 0)
2159 			(void) chdir("/");
2160 	}
2161 
2162 	/* Check safety of program to be run */
2163 	sff = SFF_ROOTOK|SFF_EXECOK;
2164 	if (!bitnset(DBS_RUNWRITABLEPROGRAM, DontBlameSendmail))
2165 		sff |= SFF_NOGWFILES|SFF_NOWWFILES;
2166 	if (bitnset(DBS_RUNPROGRAMINUNSAFEDIRPATH, DontBlameSendmail))
2167 		sff |= SFF_NOPATHCHECK;
2168 	else
2169 		sff |= SFF_SAFEDIRPATH;
2170 	ret = safefile(argv[0], DefUid, DefGid, DefUser, sff, 0, NULL);
2171 	if (ret != 0)
2172 		sm_syslog(LOG_INFO, e->e_id,
2173 			  "Warning: prog_open: program %s unsafe: %s",
2174 			  argv[0], sm_errstring(ret));
2175 
2176 	/* arrange for all the files to be closed */
2177 	sm_close_on_exec(STDERR_FILENO + 1, DtableSize);
2178 
2179 	/* now exec the process */
2180 	(void) execve(argv[0], (ARGV_T) argv, (ARGV_T) UserEnviron);
2181 
2182 	/* woops!  failed */
2183 	save_errno = errno;
2184 	syserr("%s: cannot exec", argv[0]);
2185 	if (transienterror(save_errno))
2186 		_exit(EX_OSERR);
2187 	_exit(EX_CONFIG);
2188 	return -1;	/* avoid compiler warning on IRIX */
2189 }
2190 
2191 /*
2192 **  GET_COLUMN -- look up a Column in a line buffer
2193 **
2194 **	Parameters:
2195 **		line -- the raw text line to search.
2196 **		col -- the column number to fetch.
2197 **		delim -- the delimiter between columns.  If null,
2198 **			use white space.
2199 **		buf -- the output buffer.
2200 **		buflen -- the length of buf.
2201 **
2202 **	Returns:
2203 **		buf if successful.
2204 **		NULL otherwise.
2205 */
2206 
2207 char *
get_column(line,col,delim,buf,buflen)2208 get_column(line, col, delim, buf, buflen)
2209 	char line[];
2210 	int col;
2211 	int delim;
2212 	char buf[];
2213 	int buflen;
2214 {
2215 	char *p;
2216 	char *begin, *end;
2217 	int i;
2218 	char delimbuf[4];
2219 
2220 	if ((char) delim == '\0')
2221 		(void) sm_strlcpy(delimbuf, "\n\t ", sizeof(delimbuf));
2222 	else
2223 	{
2224 		delimbuf[0] = (char) delim;
2225 		delimbuf[1] = '\0';
2226 	}
2227 
2228 	p = line;
2229 	if (*p == '\0')
2230 		return NULL;			/* line empty */
2231 	if (*p == (char) delim && col == 0)
2232 		return NULL;			/* first column empty */
2233 
2234 	begin = line;
2235 
2236 	if (col == 0 && (char) delim == '\0')
2237 	{
2238 		while (*begin != '\0' && isascii(*begin) && isspace(*begin))
2239 			begin++;
2240 	}
2241 
2242 	for (i = 0; i < col; i++)
2243 	{
2244 		if ((begin = strpbrk(begin, delimbuf)) == NULL)
2245 			return NULL;		/* no such column */
2246 		begin++;
2247 		if ((char) delim == '\0')
2248 		{
2249 			while (*begin != '\0' && isascii(*begin) && isspace(*begin))
2250 				begin++;
2251 		}
2252 	}
2253 
2254 	end = strpbrk(begin, delimbuf);
2255 	if (end == NULL)
2256 		i = strlen(begin);
2257 	else
2258 		i = end - begin;
2259 	if (i >= buflen)
2260 		i = buflen - 1;
2261 	(void) sm_strlcpy(buf, begin, i + 1);
2262 	return buf;
2263 }
2264 
2265 /*
2266 **  CLEANSTRCPY -- copy string keeping out bogus characters
2267 **
2268 **	Parameters:
2269 **		t -- "to" string.
2270 **		f -- "from" string.
2271 **		l -- length of space available in "to" string.
2272 **
2273 **	Returns:
2274 **		none.
2275 */
2276 
2277 void
cleanstrcpy(t,f,l)2278 cleanstrcpy(t, f, l)
2279 	register char *t;
2280 	register char *f;
2281 	int l;
2282 {
2283 	/* check for newlines and log if necessary */
2284 	(void) denlstring(f, true, true);
2285 
2286 	if (l <= 0)
2287 		syserr("!cleanstrcpy: length == 0");
2288 
2289 	l--;
2290 	while (l > 0 && *f != '\0')
2291 	{
2292 		if (isascii(*f) &&
2293 		    (isalnum(*f) || strchr("!#$%&'*+-./^_`{|}~", *f) != NULL))
2294 		{
2295 			l--;
2296 			*t++ = *f;
2297 		}
2298 		f++;
2299 	}
2300 	*t = '\0';
2301 }
2302 
2303 /*
2304 **  DENLSTRING -- convert newlines in a string to spaces
2305 **
2306 **	Parameters:
2307 **		s -- the input string
2308 **		strict -- if set, don't permit continuation lines.
2309 **		logattacks -- if set, log attempted attacks.
2310 **
2311 **	Returns:
2312 **		A pointer to a version of the string with newlines
2313 **		mapped to spaces.  This should be copied.
2314 */
2315 
2316 char *
denlstring(s,strict,logattacks)2317 denlstring(s, strict, logattacks)
2318 	char *s;
2319 	bool strict;
2320 	bool logattacks;
2321 {
2322 	register char *p;
2323 	int l;
2324 	static char *bp = NULL;
2325 	static int bl = 0;
2326 
2327 	p = s;
2328 	while ((p = strchr(p, '\n')) != NULL)
2329 		if (strict || (*++p != ' ' && *p != '\t'))
2330 			break;
2331 	if (p == NULL)
2332 		return s;
2333 
2334 	l = strlen(s) + 1;
2335 	if (bl < l)
2336 	{
2337 		/* allocate more space */
2338 		char *nbp = sm_pmalloc_x(l);
2339 
2340 		if (bp != NULL)
2341 			sm_free(bp);
2342 		bp = nbp;
2343 		bl = l;
2344 	}
2345 	(void) sm_strlcpy(bp, s, l);
2346 	for (p = bp; (p = strchr(p, '\n')) != NULL; )
2347 		*p++ = ' ';
2348 
2349 	if (logattacks)
2350 	{
2351 		sm_syslog(LOG_NOTICE, CurEnv ? CurEnv->e_id : NULL,
2352 			  "POSSIBLE ATTACK from %.100s: newline in string \"%s\"",
2353 			  RealHostName == NULL ? "[UNKNOWN]" : RealHostName,
2354 			  shortenstring(bp, MAXSHORTSTR));
2355 	}
2356 
2357 	return bp;
2358 }
2359 
2360 /*
2361 **  STRREPLNONPRT -- replace "unprintable" characters in a string with subst
2362 **
2363 **	Parameters:
2364 **		s -- string to manipulate (in place)
2365 **		subst -- character to use as replacement
2366 **
2367 **	Returns:
2368 **		true iff string did not contain "unprintable" characters
2369 */
2370 
2371 bool
strreplnonprt(s,c)2372 strreplnonprt(s, c)
2373 	char *s;
2374 	int c;
2375 {
2376 	bool ok;
2377 
2378 	ok = true;
2379 	if (s == NULL)
2380 		return ok;
2381 	while (*s != '\0')
2382 	{
2383 		if (!(isascii(*s) && isprint(*s)))
2384 		{
2385 			*s = c;
2386 			ok = false;
2387 		}
2388 		++s;
2389 	}
2390 	return ok;
2391 }
2392 
2393 /*
2394 **  PATH_IS_DIR -- check to see if file exists and is a directory.
2395 **
2396 **	There are some additional checks for security violations in
2397 **	here.  This routine is intended to be used for the host status
2398 **	support.
2399 **
2400 **	Parameters:
2401 **		pathname -- pathname to check for directory-ness.
2402 **		createflag -- if set, create directory if needed.
2403 **
2404 **	Returns:
2405 **		true -- if the indicated pathname is a directory
2406 **		false -- otherwise
2407 */
2408 
2409 bool
path_is_dir(pathname,createflag)2410 path_is_dir(pathname, createflag)
2411 	char *pathname;
2412 	bool createflag;
2413 {
2414 	struct stat statbuf;
2415 
2416 #if HASLSTAT
2417 	if (lstat(pathname, &statbuf) < 0)
2418 #else /* HASLSTAT */
2419 	if (stat(pathname, &statbuf) < 0)
2420 #endif /* HASLSTAT */
2421 	{
2422 		if (errno != ENOENT || !createflag)
2423 			return false;
2424 		if (mkdir(pathname, 0755) < 0)
2425 			return false;
2426 		return true;
2427 	}
2428 	if (!S_ISDIR(statbuf.st_mode))
2429 	{
2430 		errno = ENOTDIR;
2431 		return false;
2432 	}
2433 
2434 	/* security: don't allow writable directories */
2435 	if (bitset(S_IWGRP|S_IWOTH, statbuf.st_mode))
2436 	{
2437 		errno = EACCES;
2438 		return false;
2439 	}
2440 	return true;
2441 }
2442 
2443 /*
2444 **  PROC_LIST_ADD -- add process id to list of our children
2445 **
2446 **	Parameters:
2447 **		pid -- pid to add to list.
2448 **		task -- task of pid.
2449 **		type -- type of process.
2450 **		count -- number of processes.
2451 **		other -- other information for this type.
2452 **
2453 **	Returns:
2454 **		none
2455 **
2456 **	Side Effects:
2457 **		May increase CurChildren. May grow ProcList.
2458 */
2459 
2460 typedef struct procs	PROCS_T;
2461 
2462 struct procs
2463 {
2464 	pid_t		proc_pid;
2465 	char		*proc_task;
2466 	int		proc_type;
2467 	int		proc_count;
2468 	int		proc_other;
2469 	SOCKADDR	proc_hostaddr;
2470 };
2471 
2472 static PROCS_T	*volatile ProcListVec = NULL;
2473 static int	ProcListSize = 0;
2474 
2475 void
proc_list_add(pid,task,type,count,other,hostaddr)2476 proc_list_add(pid, task, type, count, other, hostaddr)
2477 	pid_t pid;
2478 	char *task;
2479 	int type;
2480 	int count;
2481 	int other;
2482 	SOCKADDR *hostaddr;
2483 {
2484 	int i;
2485 
2486 	for (i = 0; i < ProcListSize; i++)
2487 	{
2488 		if (ProcListVec[i].proc_pid == NO_PID)
2489 			break;
2490 	}
2491 	if (i >= ProcListSize)
2492 	{
2493 		/* probe the existing vector to avoid growing infinitely */
2494 		proc_list_probe();
2495 
2496 		/* now scan again */
2497 		for (i = 0; i < ProcListSize; i++)
2498 		{
2499 			if (ProcListVec[i].proc_pid == NO_PID)
2500 				break;
2501 		}
2502 	}
2503 	if (i >= ProcListSize)
2504 	{
2505 		/* grow process list */
2506 		int chldwasblocked;
2507 		PROCS_T *npv;
2508 
2509 		SM_ASSERT(ProcListSize < INT_MAX - PROC_LIST_SEG);
2510 		npv = (PROCS_T *) sm_pmalloc_x((sizeof(*npv)) *
2511 					       (ProcListSize + PROC_LIST_SEG));
2512 
2513 		/* Block SIGCHLD so reapchild() doesn't mess with us */
2514 		chldwasblocked = sm_blocksignal(SIGCHLD);
2515 		if (ProcListSize > 0)
2516 		{
2517 			memmove(npv, ProcListVec,
2518 				ProcListSize * sizeof(PROCS_T));
2519 			sm_free(ProcListVec);
2520 		}
2521 
2522 		/* XXX just use memset() to initialize this part? */
2523 		for (i = ProcListSize; i < ProcListSize + PROC_LIST_SEG; i++)
2524 		{
2525 			npv[i].proc_pid = NO_PID;
2526 			npv[i].proc_task = NULL;
2527 			npv[i].proc_type = PROC_NONE;
2528 		}
2529 		i = ProcListSize;
2530 		ProcListSize += PROC_LIST_SEG;
2531 		ProcListVec = npv;
2532 		if (chldwasblocked == 0)
2533 			(void) sm_releasesignal(SIGCHLD);
2534 	}
2535 	ProcListVec[i].proc_pid = pid;
2536 	PSTRSET(ProcListVec[i].proc_task, task);
2537 	ProcListVec[i].proc_type = type;
2538 	ProcListVec[i].proc_count = count;
2539 	ProcListVec[i].proc_other = other;
2540 	if (hostaddr != NULL)
2541 		ProcListVec[i].proc_hostaddr = *hostaddr;
2542 	else
2543 		memset(&ProcListVec[i].proc_hostaddr, 0,
2544 			sizeof(ProcListVec[i].proc_hostaddr));
2545 
2546 	/* if process adding itself, it's not a child */
2547 	if (pid != CurrentPid)
2548 	{
2549 		SM_ASSERT(CurChildren < INT_MAX);
2550 		CurChildren++;
2551 	}
2552 }
2553 
2554 /*
2555 **  PROC_LIST_SET -- set pid task in process list
2556 **
2557 **	Parameters:
2558 **		pid -- pid to set
2559 **		task -- task of pid
2560 **
2561 **	Returns:
2562 **		none.
2563 */
2564 
2565 void
proc_list_set(pid,task)2566 proc_list_set(pid, task)
2567 	pid_t pid;
2568 	char *task;
2569 {
2570 	int i;
2571 
2572 	for (i = 0; i < ProcListSize; i++)
2573 	{
2574 		if (ProcListVec[i].proc_pid == pid)
2575 		{
2576 			PSTRSET(ProcListVec[i].proc_task, task);
2577 			break;
2578 		}
2579 	}
2580 }
2581 
2582 /*
2583 **  PROC_LIST_DROP -- drop pid from process list
2584 **
2585 **	Parameters:
2586 **		pid -- pid to drop
2587 **		st -- process status
2588 **		other -- storage for proc_other (return).
2589 **
2590 **	Returns:
2591 **		none.
2592 **
2593 **	Side Effects:
2594 **		May decrease CurChildren, CurRunners, or
2595 **		set RestartRequest or ShutdownRequest.
2596 **
2597 **	NOTE:	THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
2598 **		ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
2599 **		DOING.
2600 */
2601 
2602 void
proc_list_drop(pid,st,other)2603 proc_list_drop(pid, st, other)
2604 	pid_t pid;
2605 	int st;
2606 	int *other;
2607 {
2608 	int i;
2609 	int type = PROC_NONE;
2610 
2611 	for (i = 0; i < ProcListSize; i++)
2612 	{
2613 		if (ProcListVec[i].proc_pid == pid)
2614 		{
2615 			ProcListVec[i].proc_pid = NO_PID;
2616 			type = ProcListVec[i].proc_type;
2617 			if (other != NULL)
2618 				*other = ProcListVec[i].proc_other;
2619 			if (CurChildren > 0)
2620 				CurChildren--;
2621 			break;
2622 		}
2623 	}
2624 
2625 
2626 	if (type == PROC_CONTROL && WIFEXITED(st))
2627 	{
2628 		/* if so, see if we need to restart or shutdown */
2629 		if (WEXITSTATUS(st) == EX_RESTART)
2630 			RestartRequest = "control socket";
2631 		else if (WEXITSTATUS(st) == EX_SHUTDOWN)
2632 			ShutdownRequest = "control socket";
2633 	}
2634 	else if (type == PROC_QUEUE_CHILD && !WIFSTOPPED(st) &&
2635 		 ProcListVec[i].proc_other > -1)
2636 	{
2637 		/* restart this persistent runner */
2638 		mark_work_group_restart(ProcListVec[i].proc_other, st);
2639 	}
2640 	else if (type == PROC_QUEUE)
2641 		CurRunners -= ProcListVec[i].proc_count;
2642 }
2643 
2644 /*
2645 **  PROC_LIST_CLEAR -- clear the process list
2646 **
2647 **	Parameters:
2648 **		none.
2649 **
2650 **	Returns:
2651 **		none.
2652 **
2653 **	Side Effects:
2654 **		Sets CurChildren to zero.
2655 */
2656 
2657 void
proc_list_clear()2658 proc_list_clear()
2659 {
2660 	int i;
2661 
2662 	/* start from 1 since 0 is the daemon itself */
2663 	for (i = 1; i < ProcListSize; i++)
2664 		ProcListVec[i].proc_pid = NO_PID;
2665 	CurChildren = 0;
2666 }
2667 
2668 /*
2669 **  PROC_LIST_PROBE -- probe processes in the list to see if they still exist
2670 **
2671 **	Parameters:
2672 **		none
2673 **
2674 **	Returns:
2675 **		none
2676 **
2677 **	Side Effects:
2678 **		May decrease CurChildren.
2679 */
2680 
2681 void
proc_list_probe()2682 proc_list_probe()
2683 {
2684 	int i, children;
2685 	int chldwasblocked;
2686 	pid_t pid;
2687 
2688 	children = 0;
2689 	chldwasblocked = sm_blocksignal(SIGCHLD);
2690 
2691 	/* start from 1 since 0 is the daemon itself */
2692 	for (i = 1; i < ProcListSize; i++)
2693 	{
2694 		pid = ProcListVec[i].proc_pid;
2695 		if (pid == NO_PID || pid == CurrentPid)
2696 			continue;
2697 		if (kill(pid, 0) < 0)
2698 		{
2699 			if (LogLevel > 3)
2700 				sm_syslog(LOG_DEBUG, CurEnv->e_id,
2701 					  "proc_list_probe: lost pid %d",
2702 					  (int) ProcListVec[i].proc_pid);
2703 			ProcListVec[i].proc_pid = NO_PID;
2704 			SM_FREE_CLR(ProcListVec[i].proc_task);
2705 			CurChildren--;
2706 		}
2707 		else
2708 		{
2709 			++children;
2710 		}
2711 	}
2712 	if (CurChildren < 0)
2713 		CurChildren = 0;
2714 	if (chldwasblocked == 0)
2715 		(void) sm_releasesignal(SIGCHLD);
2716 	if (LogLevel > 10 && children != CurChildren && CurrentPid == DaemonPid)
2717 	{
2718 		sm_syslog(LOG_ERR, NOQID,
2719 			  "proc_list_probe: found %d children, expected %d",
2720 			  children, CurChildren);
2721 	}
2722 }
2723 
2724 /*
2725 **  PROC_LIST_DISPLAY -- display the process list
2726 **
2727 **	Parameters:
2728 **		out -- output file pointer
2729 **		prefix -- string to output in front of each line.
2730 **
2731 **	Returns:
2732 **		none.
2733 */
2734 
2735 void
proc_list_display(out,prefix)2736 proc_list_display(out, prefix)
2737 	SM_FILE_T *out;
2738 	char *prefix;
2739 {
2740 	int i;
2741 
2742 	for (i = 0; i < ProcListSize; i++)
2743 	{
2744 		if (ProcListVec[i].proc_pid == NO_PID)
2745 			continue;
2746 
2747 		(void) sm_io_fprintf(out, SM_TIME_DEFAULT, "%s%d %s%s\n",
2748 				     prefix,
2749 				     (int) ProcListVec[i].proc_pid,
2750 				     ProcListVec[i].proc_task != NULL ?
2751 				     ProcListVec[i].proc_task : "(unknown)",
2752 				     (OpMode == MD_SMTP ||
2753 				      OpMode == MD_DAEMON ||
2754 				      OpMode == MD_ARPAFTP) ? "\r" : "");
2755 	}
2756 }
2757 
2758 /*
2759 **  PROC_LIST_SIGNAL -- send a signal to a type of process in the list
2760 **
2761 **	Parameters:
2762 **		type -- type of process to signal
2763 **		signal -- the type of signal to send
2764 **
2765 **	Results:
2766 **		none.
2767 **
2768 **	NOTE:	THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
2769 **		ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
2770 **		DOING.
2771 */
2772 
2773 void
proc_list_signal(type,signal)2774 proc_list_signal(type, signal)
2775 	int type;
2776 	int signal;
2777 {
2778 	int chldwasblocked;
2779 	int alrmwasblocked;
2780 	int i;
2781 	pid_t mypid = getpid();
2782 
2783 	/* block these signals so that we may signal cleanly */
2784 	chldwasblocked = sm_blocksignal(SIGCHLD);
2785 	alrmwasblocked = sm_blocksignal(SIGALRM);
2786 
2787 	/* Find all processes of type and send signal */
2788 	for (i = 0; i < ProcListSize; i++)
2789 	{
2790 		if (ProcListVec[i].proc_pid == NO_PID ||
2791 		    ProcListVec[i].proc_pid == mypid)
2792 			continue;
2793 		if (ProcListVec[i].proc_type != type)
2794 			continue;
2795 		(void) kill(ProcListVec[i].proc_pid, signal);
2796 	}
2797 
2798 	/* restore the signals */
2799 	if (alrmwasblocked == 0)
2800 		(void) sm_releasesignal(SIGALRM);
2801 	if (chldwasblocked == 0)
2802 		(void) sm_releasesignal(SIGCHLD);
2803 }
2804 
2805 /*
2806 **  COUNT_OPEN_CONNECTIONS
2807 **
2808 **	Parameters:
2809 **		hostaddr - ClientAddress
2810 **
2811 **	Returns:
2812 **		the number of open connections for this client
2813 **
2814 */
2815 
2816 int
count_open_connections(hostaddr)2817 count_open_connections(hostaddr)
2818 	SOCKADDR *hostaddr;
2819 {
2820 	int i, n;
2821 
2822 	if (hostaddr == NULL)
2823 		return 0;
2824 
2825 	/*
2826 	**  This code gets called before proc_list_add() gets called,
2827 	**  so we (the daemon child for this connection) have not yet
2828 	**  counted ourselves.  Hence initialize the counter to 1
2829 	**  instead of 0 to compensate.
2830 	*/
2831 
2832 	n = 1;
2833 	for (i = 0; i < ProcListSize; i++)
2834 	{
2835 		if (ProcListVec[i].proc_pid == NO_PID)
2836 			continue;
2837 		if (hostaddr->sa.sa_family !=
2838 		    ProcListVec[i].proc_hostaddr.sa.sa_family)
2839 			continue;
2840 #if NETINET
2841 		if (hostaddr->sa.sa_family == AF_INET &&
2842 		    (hostaddr->sin.sin_addr.s_addr ==
2843 		     ProcListVec[i].proc_hostaddr.sin.sin_addr.s_addr))
2844 			n++;
2845 #endif /* NETINET */
2846 #if NETINET6
2847 		if (hostaddr->sa.sa_family == AF_INET6 &&
2848 		    IN6_ARE_ADDR_EQUAL(&(hostaddr->sin6.sin6_addr),
2849 				       &(ProcListVec[i].proc_hostaddr.sin6.sin6_addr)))
2850 			n++;
2851 #endif /* NETINET6 */
2852 	}
2853 	return n;
2854 }
2855