xref: /csrg-svn/usr.sbin/sendmail/src/readcf.c (revision 67607)
1 /*
2  * Copyright (c) 1983 Eric P. Allman
3  * Copyright (c) 1988, 1993
4  *	The Regents of the University of California.  All rights reserved.
5  *
6  * %sccs.include.redist.c%
7  */
8 
9 #ifndef lint
10 static char sccsid[] = "@(#)readcf.c	8.29 (Berkeley) 08/07/94";
11 #endif /* not lint */
12 
13 # include "sendmail.h"
14 # include <pwd.h>
15 # include <grp.h>
16 #if NAMED_BIND
17 # include <resolv.h>
18 #endif
19 
20 /*
21 **  READCF -- read control file.
22 **
23 **	This routine reads the control file and builds the internal
24 **	form.
25 **
26 **	The file is formatted as a sequence of lines, each taken
27 **	atomically.  The first character of each line describes how
28 **	the line is to be interpreted.  The lines are:
29 **		Dxval		Define macro x to have value val.
30 **		Cxword		Put word into class x.
31 **		Fxfile [fmt]	Read file for lines to put into
32 **				class x.  Use scanf string 'fmt'
33 **				or "%s" if not present.  Fmt should
34 **				only produce one string-valued result.
35 **		Hname: value	Define header with field-name 'name'
36 **				and value as specified; this will be
37 **				macro expanded immediately before
38 **				use.
39 **		Sn		Use rewriting set n.
40 **		Rlhs rhs	Rewrite addresses that match lhs to
41 **				be rhs.
42 **		Mn arg=val...	Define mailer.  n is the internal name.
43 **				Args specify mailer parameters.
44 **		Oxvalue		Set option x to value.
45 **		Pname=value	Set precedence name to value.
46 **		Vversioncode[/vendorcode]
47 **				Version level/vendor name of
48 **				configuration syntax.
49 **		Kmapname mapclass arguments....
50 **				Define keyed lookup of a given class.
51 **				Arguments are class dependent.
52 **
53 **	Parameters:
54 **		cfname -- control file name.
55 **		safe -- TRUE if this is the system config file;
56 **			FALSE otherwise.
57 **		e -- the main envelope.
58 **
59 **	Returns:
60 **		none.
61 **
62 **	Side Effects:
63 **		Builds several internal tables.
64 */
65 
66 readcf(cfname, safe, e)
67 	char *cfname;
68 	bool safe;
69 	register ENVELOPE *e;
70 {
71 	FILE *cf;
72 	int ruleset = 0;
73 	char *q;
74 	struct rewrite *rwp = NULL;
75 	char *bp;
76 	auto char *ep;
77 	int nfuzzy;
78 	char *file;
79 	bool optional;
80 	char buf[MAXLINE];
81 	register char *p;
82 	extern char **copyplist();
83 	struct stat statb;
84 	char exbuf[MAXLINE];
85 	char pvpbuf[MAXLINE + MAXATOM];
86 	extern char *munchstring();
87 	extern void makemapentry();
88 
89 	FileName = cfname;
90 	LineNumber = 0;
91 
92 	cf = fopen(cfname, "r");
93 	if (cf == NULL)
94 	{
95 		syserr("cannot open");
96 		exit(EX_OSFILE);
97 	}
98 
99 	if (fstat(fileno(cf), &statb) < 0)
100 	{
101 		syserr("cannot fstat");
102 		exit(EX_OSFILE);
103 	}
104 
105 	if (!S_ISREG(statb.st_mode))
106 	{
107 		syserr("not a plain file");
108 		exit(EX_OSFILE);
109 	}
110 
111 	if (OpMode != MD_TEST && bitset(S_IWGRP|S_IWOTH, statb.st_mode))
112 	{
113 		if (OpMode == MD_DAEMON || OpMode == MD_FREEZE)
114 			fprintf(stderr, "%s: WARNING: dangerous write permissions\n",
115 				FileName);
116 #ifdef LOG
117 		if (LogLevel > 0)
118 			syslog(LOG_CRIT, "%s: WARNING: dangerous write permissions",
119 				FileName);
120 #endif
121 	}
122 
123 #ifdef XLA
124 	xla_zero();
125 #endif
126 
127 	while ((bp = fgetfolded(buf, sizeof buf, cf)) != NULL)
128 	{
129 		if (bp[0] == '#')
130 		{
131 			if (bp != buf)
132 				free(bp);
133 			continue;
134 		}
135 
136 		/* map $ into \201 for macro expansion */
137 		for (p = bp; *p != '\0'; p++)
138 		{
139 			if (*p == '#' && p > bp && ConfigLevel >= 3)
140 			{
141 				/* this is an on-line comment */
142 				register char *e;
143 
144 				switch (*--p & 0377)
145 				{
146 				  case MACROEXPAND:
147 					/* it's from $# -- let it go through */
148 					p++;
149 					break;
150 
151 				  case '\\':
152 					/* it's backslash escaped */
153 					(void) strcpy(p, p + 1);
154 					break;
155 
156 				  default:
157 					/* delete preceeding white space */
158 					while (isascii(*p) && isspace(*p) && p > bp)
159 						p--;
160 					if ((e = strchr(++p, '\n')) != NULL)
161 						(void) strcpy(p, e);
162 					else
163 						p[0] = p[1] = '\0';
164 					break;
165 				}
166 				continue;
167 			}
168 
169 			if (*p != '$')
170 				continue;
171 
172 			if (p[1] == '$')
173 			{
174 				/* actual dollar sign.... */
175 				(void) strcpy(p, p + 1);
176 				continue;
177 			}
178 
179 			/* convert to macro expansion character */
180 			*p = MACROEXPAND;
181 		}
182 
183 		/* interpret this line */
184 		errno = 0;
185 		switch (bp[0])
186 		{
187 		  case '\0':
188 		  case '#':		/* comment */
189 			break;
190 
191 		  case 'R':		/* rewriting rule */
192 			for (p = &bp[1]; *p != '\0' && *p != '\t'; p++)
193 				continue;
194 
195 			if (*p == '\0')
196 			{
197 				syserr("invalid rewrite line \"%s\" (tab expected)", bp);
198 				break;
199 			}
200 
201 			/* allocate space for the rule header */
202 			if (rwp == NULL)
203 			{
204 				RewriteRules[ruleset] = rwp =
205 					(struct rewrite *) xalloc(sizeof *rwp);
206 			}
207 			else
208 			{
209 				rwp->r_next = (struct rewrite *) xalloc(sizeof *rwp);
210 				rwp = rwp->r_next;
211 			}
212 			rwp->r_next = NULL;
213 
214 			/* expand and save the LHS */
215 			*p = '\0';
216 			expand(&bp[1], exbuf, &exbuf[sizeof exbuf], e);
217 			rwp->r_lhs = prescan(exbuf, '\t', pvpbuf,
218 					     sizeof pvpbuf, NULL);
219 			nfuzzy = 0;
220 			if (rwp->r_lhs != NULL)
221 			{
222 				register char **ap;
223 
224 				rwp->r_lhs = copyplist(rwp->r_lhs, TRUE);
225 
226 				/* count the number of fuzzy matches in LHS */
227 				for (ap = rwp->r_lhs; *ap != NULL; ap++)
228 				{
229 					char *botch;
230 
231 					botch = NULL;
232 					switch (**ap & 0377)
233 					{
234 					  case MATCHZANY:
235 					  case MATCHANY:
236 					  case MATCHONE:
237 					  case MATCHCLASS:
238 					  case MATCHNCLASS:
239 						nfuzzy++;
240 						break;
241 
242 					  case MATCHREPL:
243 						botch = "$0-$9";
244 						break;
245 
246 					  case CANONNET:
247 						botch = "$#";
248 						break;
249 
250 					  case CANONUSER:
251 						botch = "$:";
252 						break;
253 
254 					  case CALLSUBR:
255 						botch = "$>";
256 						break;
257 
258 					  case CONDIF:
259 						botch = "$?";
260 						break;
261 
262 					  case CONDELSE:
263 						botch = "$|";
264 						break;
265 
266 					  case CONDFI:
267 						botch = "$.";
268 						break;
269 
270 					  case HOSTBEGIN:
271 						botch = "$[";
272 						break;
273 
274 					  case HOSTEND:
275 						botch = "$]";
276 						break;
277 
278 					  case LOOKUPBEGIN:
279 						botch = "$(";
280 						break;
281 
282 					  case LOOKUPEND:
283 						botch = "$)";
284 						break;
285 					}
286 					if (botch != NULL)
287 						syserr("Inappropriate use of %s on LHS",
288 							botch);
289 				}
290 			}
291 			else
292 				syserr("R line: null LHS");
293 
294 			/* expand and save the RHS */
295 			while (*++p == '\t')
296 				continue;
297 			q = p;
298 			while (*p != '\0' && *p != '\t')
299 				p++;
300 			*p = '\0';
301 			expand(q, exbuf, &exbuf[sizeof exbuf], e);
302 			rwp->r_rhs = prescan(exbuf, '\t', pvpbuf,
303 					     sizeof pvpbuf, NULL);
304 			if (rwp->r_rhs != NULL)
305 			{
306 				register char **ap;
307 
308 				rwp->r_rhs = copyplist(rwp->r_rhs, TRUE);
309 
310 				/* check no out-of-bounds replacements */
311 				nfuzzy += '0';
312 				for (ap = rwp->r_rhs; *ap != NULL; ap++)
313 				{
314 					char *botch;
315 
316 					botch = NULL;
317 					switch (**ap & 0377)
318 					{
319 					  case MATCHREPL:
320 						if ((*ap)[1] <= '0' || (*ap)[1] > nfuzzy)
321 						{
322 							syserr("replacement $%c out of bounds",
323 								(*ap)[1]);
324 						}
325 						break;
326 
327 					  case MATCHZANY:
328 						botch = "$*";
329 						break;
330 
331 					  case MATCHANY:
332 						botch = "$+";
333 						break;
334 
335 					  case MATCHONE:
336 						botch = "$-";
337 						break;
338 
339 					  case MATCHCLASS:
340 						botch = "$=";
341 						break;
342 
343 					  case MATCHNCLASS:
344 						botch = "$~";
345 						break;
346 					}
347 					if (botch != NULL)
348 						syserr("Inappropriate use of %s on RHS",
349 							botch);
350 				}
351 			}
352 			else
353 				syserr("R line: null RHS");
354 			break;
355 
356 		  case 'S':		/* select rewriting set */
357 			for (p = &bp[1]; isascii(*p) && isspace(*p); p++)
358 				continue;
359 			if (!isascii(*p) || !isdigit(*p))
360 			{
361 				syserr("invalid argument to S line: \"%.20s\"",
362 					&bp[1]);
363 				break;
364 			}
365 			ruleset = atoi(p);
366 			if (ruleset >= MAXRWSETS || ruleset < 0)
367 			{
368 				syserr("bad ruleset %d (%d max)", ruleset, MAXRWSETS);
369 				ruleset = 0;
370 			}
371 			rwp = NULL;
372 			break;
373 
374 		  case 'D':		/* macro definition */
375 			p = munchstring(&bp[2], NULL);
376 			define(bp[1], newstr(p), e);
377 			break;
378 
379 		  case 'H':		/* required header line */
380 			(void) chompheader(&bp[1], TRUE, e);
381 			break;
382 
383 		  case 'C':		/* word class */
384 			/* scan the list of words and set class for all */
385 			expand(&bp[2], exbuf, &exbuf[sizeof exbuf], e);
386 			for (p = exbuf; *p != '\0'; )
387 			{
388 				register char *wd;
389 				char delim;
390 
391 				while (*p != '\0' && isascii(*p) && isspace(*p))
392 					p++;
393 				wd = p;
394 				while (*p != '\0' && !(isascii(*p) && isspace(*p)))
395 					p++;
396 				delim = *p;
397 				*p = '\0';
398 				if (wd[0] != '\0')
399 					setclass(bp[1], wd);
400 				*p = delim;
401 			}
402 			break;
403 
404 		  case 'F':		/* word class from file */
405 			for (p = &bp[2]; isascii(*p) && isspace(*p); )
406 				p++;
407 			if (p[0] == '-' && p[1] == 'o')
408 			{
409 				optional = TRUE;
410 				while (*p != '\0' && !(isascii(*p) && isspace(*p)))
411 					p++;
412 				while (isascii(*p) && isspace(*p))
413 					*p++;
414 			}
415 			else
416 				optional = FALSE;
417 			file = p;
418 			while (*p != '\0' && !(isascii(*p) && isspace(*p)))
419 				p++;
420 			if (*p == '\0')
421 				p = "%s";
422 			else
423 			{
424 				*p = '\0';
425 				while (isascii(*++p) && isspace(*p))
426 					continue;
427 			}
428 			fileclass(bp[1], file, p, safe, optional);
429 			break;
430 
431 #ifdef XLA
432 		  case 'L':		/* extended load average description */
433 			xla_init(&bp[1]);
434 			break;
435 #endif
436 
437 		  case 'M':		/* define mailer */
438 			makemailer(&bp[1]);
439 			break;
440 
441 		  case 'O':		/* set option */
442 			setoption(bp[1], &bp[2], safe, FALSE, e);
443 			break;
444 
445 		  case 'P':		/* set precedence */
446 			if (NumPriorities >= MAXPRIORITIES)
447 			{
448 				toomany('P', MAXPRIORITIES);
449 				break;
450 			}
451 			for (p = &bp[1]; *p != '\0' && *p != '=' && *p != '\t'; p++)
452 				continue;
453 			if (*p == '\0')
454 				goto badline;
455 			*p = '\0';
456 			Priorities[NumPriorities].pri_name = newstr(&bp[1]);
457 			Priorities[NumPriorities].pri_val = atoi(++p);
458 			NumPriorities++;
459 			break;
460 
461 		  case 'T':		/* trusted user(s) */
462 			/* this option is obsolete, but will be ignored */
463 			break;
464 
465 		  case 'V':		/* configuration syntax version */
466 			for (p = &bp[1]; isascii(*p) && isspace(*p); p++)
467 				continue;
468 			if (!isascii(*p) || !isdigit(*p))
469 			{
470 				syserr("invalid argument to V line: \"%.20s\"",
471 					&bp[1]);
472 				break;
473 			}
474 			ConfigLevel = strtol(p, &ep, 10);
475 			if (ConfigLevel >= 5)
476 			{
477 				/* level 5 configs have short name in $w */
478 				p = macvalue('w', e);
479 				if (p != NULL && (p = strchr(p, '.')) != NULL)
480 					*p = '\0';
481 			}
482 			if (*ep++ == '/')
483 			{
484 				/* extract vendor code */
485 				for (p = ep; isascii(*p) && isalpha(*p); )
486 					p++;
487 				*p = '\0';
488 
489 				if (!setvendor(ep))
490 					syserr("invalid V line vendor code: \"%s\"",
491 						ep);
492 			}
493 			break;
494 
495 		  case 'K':
496 			makemapentry(&bp[1]);
497 			break;
498 
499 		  default:
500 		  badline:
501 			syserr("unknown control line \"%s\"", bp);
502 		}
503 		if (bp != buf)
504 			free(bp);
505 	}
506 	if (ferror(cf))
507 	{
508 		syserr("I/O read error", cfname);
509 		exit(EX_OSFILE);
510 	}
511 	fclose(cf);
512 	FileName = NULL;
513 
514 	if (stab("host", ST_MAP, ST_FIND) == NULL)
515 	{
516 		/* user didn't initialize: set up host map */
517 		strcpy(buf, "host host");
518 #if NAMED_BIND
519 		if (ConfigLevel >= 2)
520 			strcat(buf, " -a.");
521 #endif
522 		makemapentry(buf);
523 	}
524 }
525 /*
526 **  TOOMANY -- signal too many of some option
527 **
528 **	Parameters:
529 **		id -- the id of the error line
530 **		maxcnt -- the maximum possible values
531 **
532 **	Returns:
533 **		none.
534 **
535 **	Side Effects:
536 **		gives a syserr.
537 */
538 
539 toomany(id, maxcnt)
540 	char id;
541 	int maxcnt;
542 {
543 	syserr("too many %c lines, %d max", id, maxcnt);
544 }
545 /*
546 **  FILECLASS -- read members of a class from a file
547 **
548 **	Parameters:
549 **		class -- class to define.
550 **		filename -- name of file to read.
551 **		fmt -- scanf string to use for match.
552 **		safe -- if set, this is a safe read.
553 **		optional -- if set, it is not an error for the file to
554 **			not exist.
555 **
556 **	Returns:
557 **		none
558 **
559 **	Side Effects:
560 **
561 **		puts all lines in filename that match a scanf into
562 **			the named class.
563 */
564 
565 fileclass(class, filename, fmt, safe, optional)
566 	int class;
567 	char *filename;
568 	char *fmt;
569 	bool safe;
570 	bool optional;
571 {
572 	FILE *f;
573 	struct stat stbuf;
574 	char buf[MAXLINE];
575 
576 	if (tTd(37, 2))
577 		printf("fileclass(%s, fmt=%s)\n", filename, fmt);
578 
579 	if (filename[0] == '|')
580 	{
581 		syserr("fileclass: pipes (F%c%s) not supported due to security problems",
582 			class, filename);
583 		return;
584 	}
585 	if (stat(filename, &stbuf) < 0)
586 	{
587 		if (tTd(37, 2))
588 			printf("  cannot stat (%s)\n", errstring(errno));
589 		if (!optional)
590 			syserr("fileclass: cannot stat %s", filename);
591 		return;
592 	}
593 	if (!S_ISREG(stbuf.st_mode))
594 	{
595 		syserr("fileclass: %s not a regular file", filename);
596 		return;
597 	}
598 	if (!safe && access(filename, R_OK) < 0)
599 	{
600 		syserr("fileclass: access denied on %s", filename);
601 		return;
602 	}
603 	f = fopen(filename, "r");
604 	if (f == NULL)
605 	{
606 		syserr("fileclass: cannot open %s", filename);
607 		return;
608 	}
609 
610 	while (fgets(buf, sizeof buf, f) != NULL)
611 	{
612 		register STAB *s;
613 		register char *p;
614 # ifdef SCANF
615 		char wordbuf[MAXNAME+1];
616 
617 		if (sscanf(buf, fmt, wordbuf) != 1)
618 			continue;
619 		p = wordbuf;
620 # else /* SCANF */
621 		p = buf;
622 # endif /* SCANF */
623 
624 		/*
625 		**  Break up the match into words.
626 		*/
627 
628 		while (*p != '\0')
629 		{
630 			register char *q;
631 
632 			/* strip leading spaces */
633 			while (isascii(*p) && isspace(*p))
634 				p++;
635 			if (*p == '\0')
636 				break;
637 
638 			/* find the end of the word */
639 			q = p;
640 			while (*p != '\0' && !(isascii(*p) && isspace(*p)))
641 				p++;
642 			if (*p != '\0')
643 				*p++ = '\0';
644 
645 			/* enter the word in the symbol table */
646 			setclass(class, q);
647 		}
648 	}
649 
650 	(void) fclose(f);
651 }
652 /*
653 **  MAKEMAILER -- define a new mailer.
654 **
655 **	Parameters:
656 **		line -- description of mailer.  This is in labeled
657 **			fields.  The fields are:
658 **			   P -- the path to the mailer
659 **			   F -- the flags associated with the mailer
660 **			   A -- the argv for this mailer
661 **			   S -- the sender rewriting set
662 **			   R -- the recipient rewriting set
663 **			   E -- the eol string
664 **			The first word is the canonical name of the mailer.
665 **
666 **	Returns:
667 **		none.
668 **
669 **	Side Effects:
670 **		enters the mailer into the mailer table.
671 */
672 
673 makemailer(line)
674 	char *line;
675 {
676 	register char *p;
677 	register struct mailer *m;
678 	register STAB *s;
679 	int i;
680 	char fcode;
681 	auto char *endp;
682 	extern int NextMailer;
683 	extern char **makeargv();
684 	extern char *munchstring();
685 	extern long atol();
686 
687 	/* allocate a mailer and set up defaults */
688 	m = (struct mailer *) xalloc(sizeof *m);
689 	bzero((char *) m, sizeof *m);
690 	m->m_eol = "\n";
691 	m->m_uid = m->m_gid = 0;
692 
693 	/* collect the mailer name */
694 	for (p = line; *p != '\0' && *p != ',' && !(isascii(*p) && isspace(*p)); p++)
695 		continue;
696 	if (*p != '\0')
697 		*p++ = '\0';
698 	m->m_name = newstr(line);
699 
700 	/* now scan through and assign info from the fields */
701 	while (*p != '\0')
702 	{
703 		auto char *delimptr;
704 
705 		while (*p != '\0' && (*p == ',' || (isascii(*p) && isspace(*p))))
706 			p++;
707 
708 		/* p now points to field code */
709 		fcode = *p;
710 		while (*p != '\0' && *p != '=' && *p != ',')
711 			p++;
712 		if (*p++ != '=')
713 		{
714 			syserr("mailer %s: `=' expected", m->m_name);
715 			return;
716 		}
717 		while (isascii(*p) && isspace(*p))
718 			p++;
719 
720 		/* p now points to the field body */
721 		p = munchstring(p, &delimptr);
722 
723 		/* install the field into the mailer struct */
724 		switch (fcode)
725 		{
726 		  case 'P':		/* pathname */
727 			m->m_mailer = newstr(p);
728 			break;
729 
730 		  case 'F':		/* flags */
731 			for (; *p != '\0'; p++)
732 				if (!(isascii(*p) && isspace(*p)))
733 					setbitn(*p, m->m_flags);
734 			break;
735 
736 		  case 'S':		/* sender rewriting ruleset */
737 		  case 'R':		/* recipient rewriting ruleset */
738 			i = strtol(p, &endp, 10);
739 			if (i < 0 || i >= MAXRWSETS)
740 			{
741 				syserr("invalid rewrite set, %d max", MAXRWSETS);
742 				return;
743 			}
744 			if (fcode == 'S')
745 				m->m_sh_rwset = m->m_se_rwset = i;
746 			else
747 				m->m_rh_rwset = m->m_re_rwset = i;
748 
749 			p = endp;
750 			if (*p++ == '/')
751 			{
752 				i = strtol(p, NULL, 10);
753 				if (i < 0 || i >= MAXRWSETS)
754 				{
755 					syserr("invalid rewrite set, %d max",
756 						MAXRWSETS);
757 					return;
758 				}
759 				if (fcode == 'S')
760 					m->m_sh_rwset = i;
761 				else
762 					m->m_rh_rwset = i;
763 			}
764 			break;
765 
766 		  case 'E':		/* end of line string */
767 			m->m_eol = newstr(p);
768 			break;
769 
770 		  case 'A':		/* argument vector */
771 			m->m_argv = makeargv(p);
772 			break;
773 
774 		  case 'M':		/* maximum message size */
775 			m->m_maxsize = atol(p);
776 			break;
777 
778 		  case 'L':		/* maximum line length */
779 			m->m_linelimit = atoi(p);
780 			break;
781 
782 		  case 'D':		/* working directory */
783 			m->m_execdir = newstr(p);
784 			break;
785 
786 		  case 'U':		/* user id */
787 			if (isascii(*p) && !isdigit(*p))
788 			{
789 				char *q = p;
790 				struct passwd *pw;
791 
792 				while (isascii(*p) && isalnum(*p))
793 					p++;
794 				while (isascii(*p) && isspace(*p))
795 					*p++ = '\0';
796 				if (*p != '\0')
797 					*p++ = '\0';
798 				pw = getpwnam(q);
799 				if (pw == NULL)
800 					syserr("readcf: mailer U= flag: unknown user %s", q);
801 				else
802 				{
803 					m->m_uid = pw->pw_uid;
804 					m->m_gid = pw->pw_gid;
805 				}
806 			}
807 			else
808 			{
809 				auto char *q;
810 
811 				m->m_uid = strtol(p, &q, 0);
812 				p = q;
813 			}
814 			while (isascii(*p) && isspace(*p))
815 				p++;
816 			if (*p == '\0')
817 				break;
818 			if (isascii(*p) && !isdigit(*p))
819 			{
820 				char *q = p;
821 				struct group *gr;
822 
823 				while (isascii(*p) && isalnum(*p))
824 					p++;
825 				*p++ = '\0';
826 				gr = getgrnam(q);
827 				if (gr == NULL)
828 					syserr("readcf: mailer U= flag: unknown group %s", q);
829 				else
830 					m->m_gid = gr->gr_gid;
831 			}
832 			else
833 			{
834 				m->m_gid = strtol(p, NULL, 0);
835 			}
836 			break;
837 		}
838 
839 		p = delimptr;
840 	}
841 
842 	/* do some heuristic cleanup for back compatibility */
843 	if (bitnset(M_LIMITS, m->m_flags))
844 	{
845 		if (m->m_linelimit == 0)
846 			m->m_linelimit = SMTPLINELIM;
847 		if (ConfigLevel < 2)
848 			setbitn(M_7BITS, m->m_flags);
849 	}
850 
851 	/* do some rationality checking */
852 	if (m->m_argv == NULL)
853 	{
854 		syserr("M%s: A= argument required", m->m_name);
855 		return;
856 	}
857 	if (m->m_mailer == NULL)
858 	{
859 		syserr("M%s: P= argument required", m->m_name);
860 		return;
861 	}
862 
863 	if (NextMailer >= MAXMAILERS)
864 	{
865 		syserr("too many mailers defined (%d max)", MAXMAILERS);
866 		return;
867 	}
868 
869 	s = stab(m->m_name, ST_MAILER, ST_ENTER);
870 	if (s->s_mailer != NULL)
871 	{
872 		i = s->s_mailer->m_mno;
873 		free(s->s_mailer);
874 	}
875 	else
876 	{
877 		i = NextMailer++;
878 	}
879 	Mailer[i] = s->s_mailer = m;
880 	m->m_mno = i;
881 }
882 /*
883 **  MUNCHSTRING -- translate a string into internal form.
884 **
885 **	Parameters:
886 **		p -- the string to munch.
887 **		delimptr -- if non-NULL, set to the pointer of the
888 **			field delimiter character.
889 **
890 **	Returns:
891 **		the munched string.
892 */
893 
894 char *
895 munchstring(p, delimptr)
896 	register char *p;
897 	char **delimptr;
898 {
899 	register char *q;
900 	bool backslash = FALSE;
901 	bool quotemode = FALSE;
902 	static char buf[MAXLINE];
903 
904 	for (q = buf; *p != '\0'; p++)
905 	{
906 		if (backslash)
907 		{
908 			/* everything is roughly literal */
909 			backslash = FALSE;
910 			switch (*p)
911 			{
912 			  case 'r':		/* carriage return */
913 				*q++ = '\r';
914 				continue;
915 
916 			  case 'n':		/* newline */
917 				*q++ = '\n';
918 				continue;
919 
920 			  case 'f':		/* form feed */
921 				*q++ = '\f';
922 				continue;
923 
924 			  case 'b':		/* backspace */
925 				*q++ = '\b';
926 				continue;
927 			}
928 			*q++ = *p;
929 		}
930 		else
931 		{
932 			if (*p == '\\')
933 				backslash = TRUE;
934 			else if (*p == '"')
935 				quotemode = !quotemode;
936 			else if (quotemode || *p != ',')
937 				*q++ = *p;
938 			else
939 				break;
940 		}
941 	}
942 
943 	if (delimptr != NULL)
944 		*delimptr = p;
945 	*q++ = '\0';
946 	return (buf);
947 }
948 /*
949 **  MAKEARGV -- break up a string into words
950 **
951 **	Parameters:
952 **		p -- the string to break up.
953 **
954 **	Returns:
955 **		a char **argv (dynamically allocated)
956 **
957 **	Side Effects:
958 **		munges p.
959 */
960 
961 char **
962 makeargv(p)
963 	register char *p;
964 {
965 	char *q;
966 	int i;
967 	char **avp;
968 	char *argv[MAXPV + 1];
969 
970 	/* take apart the words */
971 	i = 0;
972 	while (*p != '\0' && i < MAXPV)
973 	{
974 		q = p;
975 		while (*p != '\0' && !(isascii(*p) && isspace(*p)))
976 			p++;
977 		while (isascii(*p) && isspace(*p))
978 			*p++ = '\0';
979 		argv[i++] = newstr(q);
980 	}
981 	argv[i++] = NULL;
982 
983 	/* now make a copy of the argv */
984 	avp = (char **) xalloc(sizeof *avp * i);
985 	bcopy((char *) argv, (char *) avp, sizeof *avp * i);
986 
987 	return (avp);
988 }
989 /*
990 **  PRINTRULES -- print rewrite rules (for debugging)
991 **
992 **	Parameters:
993 **		none.
994 **
995 **	Returns:
996 **		none.
997 **
998 **	Side Effects:
999 **		prints rewrite rules.
1000 */
1001 
1002 printrules()
1003 {
1004 	register struct rewrite *rwp;
1005 	register int ruleset;
1006 
1007 	for (ruleset = 0; ruleset < 10; ruleset++)
1008 	{
1009 		if (RewriteRules[ruleset] == NULL)
1010 			continue;
1011 		printf("\n----Rule Set %d:", ruleset);
1012 
1013 		for (rwp = RewriteRules[ruleset]; rwp != NULL; rwp = rwp->r_next)
1014 		{
1015 			printf("\nLHS:");
1016 			printav(rwp->r_lhs);
1017 			printf("RHS:");
1018 			printav(rwp->r_rhs);
1019 		}
1020 	}
1021 }
1022 
1023 /*
1024 **  SETOPTION -- set global processing option
1025 **
1026 **	Parameters:
1027 **		opt -- option name.
1028 **		val -- option value (as a text string).
1029 **		safe -- set if this came from a configuration file.
1030 **			Some options (if set from the command line) will
1031 **			reset the user id to avoid security problems.
1032 **		sticky -- if set, don't let other setoptions override
1033 **			this value.
1034 **		e -- the main envelope.
1035 **
1036 **	Returns:
1037 **		none.
1038 **
1039 **	Side Effects:
1040 **		Sets options as implied by the arguments.
1041 */
1042 
1043 static BITMAP	StickyOpt;		/* set if option is stuck */
1044 
1045 
1046 #if NAMED_BIND
1047 
1048 struct resolverflags
1049 {
1050 	char	*rf_name;	/* name of the flag */
1051 	long	rf_bits;	/* bits to set/clear */
1052 } ResolverFlags[] =
1053 {
1054 	"debug",	RES_DEBUG,
1055 	"aaonly",	RES_AAONLY,
1056 	"usevc",	RES_USEVC,
1057 	"primary",	RES_PRIMARY,
1058 	"igntc",	RES_IGNTC,
1059 	"recurse",	RES_RECURSE,
1060 	"defnames",	RES_DEFNAMES,
1061 	"stayopen",	RES_STAYOPEN,
1062 	"dnsrch",	RES_DNSRCH,
1063 	"true",		0,		/* to avoid error on old syntax */
1064 	NULL,		0
1065 };
1066 
1067 #endif
1068 
1069 setoption(opt, val, safe, sticky, e)
1070 	char opt;
1071 	char *val;
1072 	bool safe;
1073 	bool sticky;
1074 	register ENVELOPE *e;
1075 {
1076 	register char *p;
1077 	extern bool atobool();
1078 	extern time_t convtime();
1079 	extern int QueueLA;
1080 	extern int RefuseLA;
1081 	extern bool Warn_Q_option;
1082 	extern bool trusteduser();
1083 
1084 	if (tTd(37, 1))
1085 		printf("setoption %c=%s", opt, val);
1086 
1087 	/*
1088 	**  See if this option is preset for us.
1089 	*/
1090 
1091 	if (!sticky && bitnset(opt, StickyOpt))
1092 	{
1093 		if (tTd(37, 1))
1094 			printf(" (ignored)\n");
1095 		return;
1096 	}
1097 
1098 	/*
1099 	**  Check to see if this option can be specified by this user.
1100 	*/
1101 
1102 	if (!safe && RealUid == 0)
1103 		safe = TRUE;
1104 	if (!safe && strchr("bCdeijLmoprsvw7", opt) == NULL)
1105 	{
1106 		if (opt != 'M' || (val[0] != 'r' && val[0] != 's'))
1107 		{
1108 			if (tTd(37, 1))
1109 				printf(" (unsafe)");
1110 			if (RealUid != geteuid())
1111 			{
1112 				if (tTd(37, 1))
1113 					printf("(Resetting uid)");
1114 				(void) setgid(RealGid);
1115 				(void) setuid(RealUid);
1116 			}
1117 		}
1118 	}
1119 	if (tTd(37, 1))
1120 		printf("\n");
1121 
1122 	switch (opt)
1123 	{
1124 	  case '7':		/* force seven-bit input */
1125 		SevenBitInput = atobool(val);
1126 		break;
1127 
1128 	  case '8':		/* handling of 8-bit input */
1129 		switch (*val)
1130 		{
1131 		  case 'r':		/* reject 8-bit, don't convert MIME */
1132 			MimeMode = 0;
1133 			break;
1134 
1135 		  case 'm':		/* convert 8-bit, convert MIME */
1136 			MimeMode = MM_CVTMIME|MM_MIME8BIT;
1137 			break;
1138 
1139 		  case 'j':		/* "just send 8" */
1140 			MimeMode = MM_PASS8BIT;
1141 			break;
1142 
1143 		  case 'p':		/* pass 8 bit, convert MIME */
1144 			MimeMode = MM_PASS8BIT|MM_CVTMIME;
1145 			break;
1146 
1147 		  case 's':		/* strict adherence */
1148 			MimeMode = MM_CVTMIME;
1149 			break;
1150 
1151 		  case 'a':		/* encode 8 bit if available */
1152 			MimeMode = MM_MIME8BIT|MM_PASS8BIT|MM_CVTMIME;
1153 			break;
1154 
1155 		  case 'c':		/* convert 8 bit to MIME, never 7 bit */
1156 			MimeMode = MM_MIME8BIT;
1157 			break;
1158 
1159 		  default:
1160 			syserr("Unknown 8-bit mode %c", *val);
1161 			exit(EX_USAGE);
1162 		}
1163 		break;
1164 
1165 	  case 'A':		/* set default alias file */
1166 		if (val[0] == '\0')
1167 			setalias("aliases");
1168 		else
1169 			setalias(val);
1170 		break;
1171 
1172 	  case 'a':		/* look N minutes for "@:@" in alias file */
1173 		if (val[0] == '\0')
1174 			SafeAlias = 5 * 60;		/* five minutes */
1175 		else
1176 			SafeAlias = convtime(val, 'm');
1177 		break;
1178 
1179 	  case 'B':		/* substitution for blank character */
1180 		SpaceSub = val[0];
1181 		if (SpaceSub == '\0')
1182 			SpaceSub = ' ';
1183 		break;
1184 
1185 	  case 'b':		/* min blocks free on queue fs/max msg size */
1186 		p = strchr(val, '/');
1187 		if (p != NULL)
1188 		{
1189 			*p++ = '\0';
1190 			MaxMessageSize = atol(p);
1191 		}
1192 		MinBlocksFree = atol(val);
1193 		break;
1194 
1195 	  case 'c':		/* don't connect to "expensive" mailers */
1196 		NoConnect = atobool(val);
1197 		break;
1198 
1199 	  case 'C':		/* checkpoint every N addresses */
1200 		CheckpointInterval = atoi(val);
1201 		break;
1202 
1203 	  case 'd':		/* delivery mode */
1204 		switch (*val)
1205 		{
1206 		  case '\0':
1207 			e->e_sendmode = SM_DELIVER;
1208 			break;
1209 
1210 		  case SM_QUEUE:	/* queue only */
1211 #ifndef QUEUE
1212 			syserr("need QUEUE to set -odqueue");
1213 #endif /* QUEUE */
1214 			/* fall through..... */
1215 
1216 		  case SM_DELIVER:	/* do everything */
1217 		  case SM_FORK:		/* fork after verification */
1218 			e->e_sendmode = *val;
1219 			break;
1220 
1221 		  default:
1222 			syserr("Unknown delivery mode %c", *val);
1223 			exit(EX_USAGE);
1224 		}
1225 		break;
1226 
1227 	  case 'D':		/* rebuild alias database as needed */
1228 		AutoRebuild = atobool(val);
1229 		break;
1230 
1231 	  case 'E':		/* error message header/header file */
1232 		if (*val != '\0')
1233 			ErrMsgFile = newstr(val);
1234 		break;
1235 
1236 	  case 'e':		/* set error processing mode */
1237 		switch (*val)
1238 		{
1239 		  case EM_QUIET:	/* be silent about it */
1240 		  case EM_MAIL:		/* mail back */
1241 		  case EM_BERKNET:	/* do berknet error processing */
1242 		  case EM_WRITE:	/* write back (or mail) */
1243 		  case EM_PRINT:	/* print errors normally (default) */
1244 			e->e_errormode = *val;
1245 			break;
1246 		}
1247 		break;
1248 
1249 	  case 'F':		/* file mode */
1250 		FileMode = atooct(val) & 0777;
1251 		break;
1252 
1253 	  case 'f':		/* save Unix-style From lines on front */
1254 		SaveFrom = atobool(val);
1255 		break;
1256 
1257 	  case 'G':		/* match recipients against GECOS field */
1258 		MatchGecos = atobool(val);
1259 		break;
1260 
1261 	  case 'g':		/* default gid */
1262 		if (isascii(*val) && isdigit(*val))
1263 			DefGid = atoi(val);
1264 		else
1265 		{
1266 			register struct group *gr;
1267 
1268 			DefGid = -1;
1269 			gr = getgrnam(val);
1270 			if (gr == NULL)
1271 				syserr("readcf: option g: unknown group %s", val);
1272 			else
1273 				DefGid = gr->gr_gid;
1274 		}
1275 		break;
1276 
1277 	  case 'H':		/* help file */
1278 		if (val[0] == '\0')
1279 			HelpFile = "sendmail.hf";
1280 		else
1281 			HelpFile = newstr(val);
1282 		break;
1283 
1284 	  case 'h':		/* maximum hop count */
1285 		MaxHopCount = atoi(val);
1286 		break;
1287 
1288 	  case 'I':		/* use internet domain name server */
1289 #if NAMED_BIND
1290 		UseNameServer = TRUE;
1291 		for (p = val; *p != 0; )
1292 		{
1293 			bool clearmode;
1294 			char *q;
1295 			struct resolverflags *rfp;
1296 
1297 			while (*p == ' ')
1298 				p++;
1299 			if (*p == '\0')
1300 				break;
1301 			clearmode = FALSE;
1302 			if (*p == '-')
1303 				clearmode = TRUE;
1304 			else if (*p != '+')
1305 				p--;
1306 			p++;
1307 			q = p;
1308 			while (*p != '\0' && !(isascii(*p) && isspace(*p)))
1309 				p++;
1310 			if (*p != '\0')
1311 				*p++ = '\0';
1312 			for (rfp = ResolverFlags; rfp->rf_name != NULL; rfp++)
1313 			{
1314 				if (strcasecmp(q, rfp->rf_name) == 0)
1315 					break;
1316 			}
1317 			if (rfp->rf_name == NULL)
1318 				syserr("readcf: I option value %s unrecognized", q);
1319 			else if (clearmode)
1320 				_res.options &= ~rfp->rf_bits;
1321 			else
1322 				_res.options |= rfp->rf_bits;
1323 		}
1324 		if (tTd(8, 2))
1325 			printf("_res.options = %x\n", _res.options);
1326 #else
1327 		usrerr("name server (I option) specified but BIND not compiled in");
1328 #endif
1329 		break;
1330 
1331 	  case 'i':		/* ignore dot lines in message */
1332 		IgnrDot = atobool(val);
1333 		break;
1334 
1335 	  case 'j':		/* send errors in MIME (RFC 1341) format */
1336 		SendMIMEErrors = atobool(val);
1337 		break;
1338 
1339 	  case 'J':		/* .forward search path */
1340 		ForwardPath = newstr(val);
1341 		break;
1342 
1343 	  case 'k':		/* connection cache size */
1344 		MaxMciCache = atoi(val);
1345 		if (MaxMciCache < 0)
1346 			MaxMciCache = 0;
1347 		break;
1348 
1349 	  case 'K':		/* connection cache timeout */
1350 		MciCacheTimeout = convtime(val, 'm');
1351 		break;
1352 
1353 	  case 'l':		/* use Errors-To: header */
1354 		UseErrorsTo = atobool(val);
1355 		break;
1356 
1357 	  case 'L':		/* log level */
1358 		if (safe || LogLevel < atoi(val))
1359 			LogLevel = atoi(val);
1360 		break;
1361 
1362 	  case 'M':		/* define macro */
1363 		define(val[0], newstr(&val[1]), CurEnv);
1364 		sticky = FALSE;
1365 		break;
1366 
1367 	  case 'm':		/* send to me too */
1368 		MeToo = atobool(val);
1369 		break;
1370 
1371 	  case 'n':		/* validate RHS in newaliases */
1372 		CheckAliases = atobool(val);
1373 		break;
1374 
1375 	    /* 'N' available -- was "net name" */
1376 
1377 	  case 'O':		/* daemon options */
1378 		setdaemonoptions(val);
1379 		break;
1380 
1381 	  case 'o':		/* assume old style headers */
1382 		if (atobool(val))
1383 			CurEnv->e_flags |= EF_OLDSTYLE;
1384 		else
1385 			CurEnv->e_flags &= ~EF_OLDSTYLE;
1386 		break;
1387 
1388 	  case 'p':		/* select privacy level */
1389 		p = val;
1390 		for (;;)
1391 		{
1392 			register struct prival *pv;
1393 			extern struct prival PrivacyValues[];
1394 
1395 			while (isascii(*p) && (isspace(*p) || ispunct(*p)))
1396 				p++;
1397 			if (*p == '\0')
1398 				break;
1399 			val = p;
1400 			while (isascii(*p) && isalnum(*p))
1401 				p++;
1402 			if (*p != '\0')
1403 				*p++ = '\0';
1404 
1405 			for (pv = PrivacyValues; pv->pv_name != NULL; pv++)
1406 			{
1407 				if (strcasecmp(val, pv->pv_name) == 0)
1408 					break;
1409 			}
1410 			if (pv->pv_name == NULL)
1411 				syserr("readcf: Op line: %s unrecognized", val);
1412 			PrivacyFlags |= pv->pv_flag;
1413 		}
1414 		break;
1415 
1416 	  case 'P':		/* postmaster copy address for returned mail */
1417 		PostMasterCopy = newstr(val);
1418 		break;
1419 
1420 	  case 'q':		/* slope of queue only function */
1421 		QueueFactor = atoi(val);
1422 		break;
1423 
1424 	  case 'Q':		/* queue directory */
1425 		if (val[0] == '\0')
1426 			QueueDir = "mqueue";
1427 		else
1428 			QueueDir = newstr(val);
1429 		if (RealUid != 0 && !safe)
1430 			Warn_Q_option = TRUE;
1431 		break;
1432 
1433 	  case 'R':		/* don't prune routes */
1434 		DontPruneRoutes = atobool(val);
1435 		break;
1436 
1437 	  case 'r':		/* read timeout */
1438 		settimeouts(val);
1439 		break;
1440 
1441 	  case 'S':		/* status file */
1442 		if (val[0] == '\0')
1443 			StatFile = "sendmail.st";
1444 		else
1445 			StatFile = newstr(val);
1446 		break;
1447 
1448 	  case 's':		/* be super safe, even if expensive */
1449 		SuperSafe = atobool(val);
1450 		break;
1451 
1452 	  case 'T':		/* queue timeout */
1453 		p = strchr(val, '/');
1454 		if (p != NULL)
1455 		{
1456 			*p++ = '\0';
1457 			TimeOuts.to_q_warning = convtime(p, 'd');
1458 		}
1459 		TimeOuts.to_q_return = convtime(val, 'h');
1460 		break;
1461 
1462 	  case 't':		/* time zone name */
1463 		TimeZoneSpec = newstr(val);
1464 		break;
1465 
1466 	  case 'U':		/* location of user database */
1467 		UdbSpec = newstr(val);
1468 		break;
1469 
1470 	  case 'u':		/* set default uid */
1471 		if (isascii(*val) && isdigit(*val))
1472 			DefUid = atoi(val);
1473 		else
1474 		{
1475 			register struct passwd *pw;
1476 
1477 			DefUid = -1;
1478 			pw = getpwnam(val);
1479 			if (pw == NULL)
1480 				syserr("readcf: option u: unknown user %s", val);
1481 			else
1482 				DefUid = pw->pw_uid;
1483 		}
1484 		setdefuser();
1485 		break;
1486 
1487 	  case 'V':		/* fallback MX host */
1488 		FallBackMX = newstr(val);
1489 		break;
1490 
1491 	  case 'v':		/* run in verbose mode */
1492 		Verbose = atobool(val);
1493 		break;
1494 
1495 	  case 'w':		/* if we are best MX, try host directly */
1496 		TryNullMXList = atobool(val);
1497 		break;
1498 
1499 	    /* 'W' available -- was wizard password */
1500 
1501 	  case 'x':		/* load avg at which to auto-queue msgs */
1502 		QueueLA = atoi(val);
1503 		break;
1504 
1505 	  case 'X':		/* load avg at which to auto-reject connections */
1506 		RefuseLA = atoi(val);
1507 		break;
1508 
1509 	  case 'y':		/* work recipient factor */
1510 		WkRecipFact = atoi(val);
1511 		break;
1512 
1513 	  case 'Y':		/* fork jobs during queue runs */
1514 		ForkQueueRuns = atobool(val);
1515 		break;
1516 
1517 	  case 'z':		/* work message class factor */
1518 		WkClassFact = atoi(val);
1519 		break;
1520 
1521 	  case 'Z':		/* work time factor */
1522 		WkTimeFact = atoi(val);
1523 		break;
1524 
1525 	  default:
1526 		break;
1527 	}
1528 	if (sticky)
1529 		setbitn(opt, StickyOpt);
1530 	return;
1531 }
1532 /*
1533 **  SETCLASS -- set a word into a class
1534 **
1535 **	Parameters:
1536 **		class -- the class to put the word in.
1537 **		word -- the word to enter
1538 **
1539 **	Returns:
1540 **		none.
1541 **
1542 **	Side Effects:
1543 **		puts the word into the symbol table.
1544 */
1545 
1546 setclass(class, word)
1547 	int class;
1548 	char *word;
1549 {
1550 	register STAB *s;
1551 
1552 	if (tTd(37, 8))
1553 		printf("setclass(%c, %s)\n", class, word);
1554 	s = stab(word, ST_CLASS, ST_ENTER);
1555 	setbitn(class, s->s_class);
1556 }
1557 /*
1558 **  MAKEMAPENTRY -- create a map entry
1559 **
1560 **	Parameters:
1561 **		line -- the config file line
1562 **
1563 **	Returns:
1564 **		TRUE if it successfully entered the map entry.
1565 **		FALSE otherwise (usually syntax error).
1566 **
1567 **	Side Effects:
1568 **		Enters the map into the dictionary.
1569 */
1570 
1571 void
1572 makemapentry(line)
1573 	char *line;
1574 {
1575 	register char *p;
1576 	char *mapname;
1577 	char *classname;
1578 	register STAB *s;
1579 	STAB *class;
1580 
1581 	for (p = line; isascii(*p) && isspace(*p); p++)
1582 		continue;
1583 	if (!(isascii(*p) && isalnum(*p)))
1584 	{
1585 		syserr("readcf: config K line: no map name");
1586 		return;
1587 	}
1588 
1589 	mapname = p;
1590 	while (isascii(*++p) && isalnum(*p))
1591 		continue;
1592 	if (*p != '\0')
1593 		*p++ = '\0';
1594 	while (isascii(*p) && isspace(*p))
1595 		p++;
1596 	if (!(isascii(*p) && isalnum(*p)))
1597 	{
1598 		syserr("readcf: config K line, map %s: no map class", mapname);
1599 		return;
1600 	}
1601 	classname = p;
1602 	while (isascii(*++p) && isalnum(*p))
1603 		continue;
1604 	if (*p != '\0')
1605 		*p++ = '\0';
1606 	while (isascii(*p) && isspace(*p))
1607 		p++;
1608 
1609 	/* look up the class */
1610 	class = stab(classname, ST_MAPCLASS, ST_FIND);
1611 	if (class == NULL)
1612 	{
1613 		syserr("readcf: map %s: class %s not available", mapname, classname);
1614 		return;
1615 	}
1616 
1617 	/* enter the map */
1618 	s = stab(mapname, ST_MAP, ST_ENTER);
1619 	s->s_map.map_class = &class->s_mapclass;
1620 	s->s_map.map_mname = newstr(mapname);
1621 
1622 	if (class->s_mapclass.map_parse(&s->s_map, p))
1623 		s->s_map.map_mflags |= MF_VALID;
1624 
1625 	if (tTd(37, 5))
1626 	{
1627 		printf("map %s, class %s, flags %x, file %s,\n",
1628 			s->s_map.map_mname, s->s_map.map_class->map_cname,
1629 			s->s_map.map_mflags,
1630 			s->s_map.map_file == NULL ? "(null)" : s->s_map.map_file);
1631 		printf("\tapp %s, domain %s, rebuild %s\n",
1632 			s->s_map.map_app == NULL ? "(null)" : s->s_map.map_app,
1633 			s->s_map.map_domain == NULL ? "(null)" : s->s_map.map_domain,
1634 			s->s_map.map_rebuild == NULL ? "(null)" : s->s_map.map_rebuild);
1635 	}
1636 }
1637 /*
1638 **  SETTIMEOUTS -- parse and set timeout values
1639 **
1640 **	Parameters:
1641 **		val -- a pointer to the values.  If NULL, do initial
1642 **			settings.
1643 **
1644 **	Returns:
1645 **		none.
1646 **
1647 **	Side Effects:
1648 **		Initializes the TimeOuts structure
1649 */
1650 
1651 #define SECONDS
1652 #define MINUTES	* 60
1653 #define HOUR	* 3600
1654 
1655 settimeouts(val)
1656 	register char *val;
1657 {
1658 	register char *p;
1659 	extern time_t convtime();
1660 
1661 	if (val == NULL)
1662 	{
1663 		TimeOuts.to_initial = (time_t) 5 MINUTES;
1664 		TimeOuts.to_helo = (time_t) 5 MINUTES;
1665 		TimeOuts.to_mail = (time_t) 10 MINUTES;
1666 		TimeOuts.to_rcpt = (time_t) 1 HOUR;
1667 		TimeOuts.to_datainit = (time_t) 5 MINUTES;
1668 		TimeOuts.to_datablock = (time_t) 1 HOUR;
1669 		TimeOuts.to_datafinal = (time_t) 1 HOUR;
1670 		TimeOuts.to_rset = (time_t) 5 MINUTES;
1671 		TimeOuts.to_quit = (time_t) 2 MINUTES;
1672 		TimeOuts.to_nextcommand = (time_t) 1 HOUR;
1673 		TimeOuts.to_miscshort = (time_t) 2 MINUTES;
1674 		TimeOuts.to_ident = (time_t) 30 SECONDS;
1675 		return;
1676 	}
1677 
1678 	for (;; val = p)
1679 	{
1680 		while (isascii(*val) && isspace(*val))
1681 			val++;
1682 		if (*val == '\0')
1683 			break;
1684 		for (p = val; *p != '\0' && *p != ','; p++)
1685 			continue;
1686 		if (*p != '\0')
1687 			*p++ = '\0';
1688 
1689 		if (isascii(*val) && isdigit(*val))
1690 		{
1691 			/* old syntax -- set everything */
1692 			TimeOuts.to_mail = convtime(val, 'm');
1693 			TimeOuts.to_rcpt = TimeOuts.to_mail;
1694 			TimeOuts.to_datainit = TimeOuts.to_mail;
1695 			TimeOuts.to_datablock = TimeOuts.to_mail;
1696 			TimeOuts.to_datafinal = TimeOuts.to_mail;
1697 			TimeOuts.to_nextcommand = TimeOuts.to_mail;
1698 			continue;
1699 		}
1700 		else
1701 		{
1702 			register char *q = strchr(val, '=');
1703 			time_t to;
1704 
1705 			if (q == NULL)
1706 			{
1707 				/* syntax error */
1708 				continue;
1709 			}
1710 			*q++ = '\0';
1711 			to = convtime(q, 'm');
1712 
1713 			if (strcasecmp(val, "initial") == 0)
1714 				TimeOuts.to_initial = to;
1715 			else if (strcasecmp(val, "mail") == 0)
1716 				TimeOuts.to_mail = to;
1717 			else if (strcasecmp(val, "rcpt") == 0)
1718 				TimeOuts.to_rcpt = to;
1719 			else if (strcasecmp(val, "datainit") == 0)
1720 				TimeOuts.to_datainit = to;
1721 			else if (strcasecmp(val, "datablock") == 0)
1722 				TimeOuts.to_datablock = to;
1723 			else if (strcasecmp(val, "datafinal") == 0)
1724 				TimeOuts.to_datafinal = to;
1725 			else if (strcasecmp(val, "command") == 0)
1726 				TimeOuts.to_nextcommand = to;
1727 			else if (strcasecmp(val, "rset") == 0)
1728 				TimeOuts.to_rset = to;
1729 			else if (strcasecmp(val, "helo") == 0)
1730 				TimeOuts.to_helo = to;
1731 			else if (strcasecmp(val, "quit") == 0)
1732 				TimeOuts.to_quit = to;
1733 			else if (strcasecmp(val, "misc") == 0)
1734 				TimeOuts.to_miscshort = to;
1735 			else if (strcasecmp(val, "ident") == 0)
1736 				TimeOuts.to_ident = to;
1737 			else
1738 				syserr("settimeouts: invalid timeout %s", val);
1739 		}
1740 	}
1741 }
1742