Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Annotate
Revision Log

readcf.c @ 19204

Visit:

Revision 19204, 96.9 KB checked in by zacheiss, 21 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r19203, which included commits to RCS files with non-trunk default branches.

Line
1	/*
2	* Copyright (c) 1998-2002 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: readcf.c,v 1.1.1.1 2003-04-08 15:09:07 zacheiss Exp $")
17
18	#if NETINET \|\| NETINET6
19	# include <arpa/inet.h>
20	#endif /* NETINET \|\| NETINET6 */
21
22	#define SECONDS
23	#define MINUTES * 60
24	#define HOUR * 3600
25	#define HOURS HOUR
26
27	static void fileclass __P((int, char , char , bool, bool, bool));
28	static char *makeargv __P((char ));
29	static void settimeout __P((char , char , bool));
30	static void toomany __P((int, int));
31	static char extrquotstr __P((char , char *, char , bool *));
32
33	/*
34	** READCF -- read configuration file.
35	**
36	** This routine reads the configuration file and builds the internal
37	** form.
38	**
39	** The file is formatted as a sequence of lines, each taken
40	** atomically. The first character of each line describes how
41	** the line is to be interpreted. The lines are:
42	** Dxval Define macro x to have value val.
43	** Cxword Put word into class x.
44	** Fxfile [fmt] Read file for lines to put into
45	** class x. Use scanf string 'fmt'
46	** or "%s" if not present. Fmt should
47	** only produce one string-valued result.
48	** Hname: value Define header with field-name 'name'
49	** and value as specified; this will be
50	** macro expanded immediately before
51	** use.
52	** Sn Use rewriting set n.
53	** Rlhs rhs Rewrite addresses that match lhs to
54	** be rhs.
55	** Mn arg=val... Define mailer. n is the internal name.
56	** Args specify mailer parameters.
57	** Oxvalue Set option x to value.
58	** O option value Set option (long name) to value.
59	** Pname=value Set precedence name to value.
60	** Qn arg=val... Define queue groups. n is the internal name.
61	** Args specify queue parameters.
62	** Vversioncode[/vendorcode]
63	** Version level/vendor name of
64	** configuration syntax.
65	** Kmapname mapclass arguments....
66	** Define keyed lookup of a given class.
67	** Arguments are class dependent.
68	** Eenvar=value Set the environment value to the given value.
69	**
70	** Parameters:
71	** cfname -- configuration file name.
72	** safe -- true if this is the system config file;
73	** false otherwise.
74	** e -- the main envelope.
75	**
76	** Returns:
77	** none.
78	**
79	** Side Effects:
80	** Builds several internal tables.
81	*/
82
83	void
84	readcf(cfname, safe, e)
85	char *cfname;
86	bool safe;
87	register ENVELOPE *e;
88	{
89	SM_FILE_T *cf;
90	int ruleset = -1;
91	char *q;
92	struct rewrite *rwp = NULL;
93	char *bp;
94	auto char *ep;
95	int nfuzzy;
96	char *file;
97	bool optional;
98	bool ok;
99	bool ismap;
100	int mid;
101	register char *p;
102	long sff = SFF_OPENASROOT;
103	struct stat statb;
104	char buf[MAXLINE];
105	char exbuf[MAXLINE];
106	char pvpbuf[MAXLINE + MAXATOM];
107	static char *null_list[1] = { NULL };
108	extern unsigned char TokTypeNoC[];
109
110	FileName = cfname;
111	LineNumber = 0;
112
113	if (DontLockReadFiles)
114	sff \|= SFF_NOLOCK;
115	cf = safefopen(cfname, O_RDONLY, 0444, sff);
116	if (cf == NULL)
117	{
118	syserr("cannot open");
119	finis(false, true, EX_OSFILE);
120	}
121
122	if (fstat(sm_io_getinfo(cf, SM_IO_WHAT_FD, NULL), &statb) < 0)
123	{
124	syserr("cannot fstat");
125	finis(false, true, EX_OSFILE);
126	}
127
128	if (!S_ISREG(statb.st_mode))
129	{
130	syserr("not a plain file");
131	finis(false, true, EX_OSFILE);
132	}
133
134	if (OpMode != MD_TEST && bitset(S_IWGRP\|S_IWOTH, statb.st_mode))
135	{
136	if (OpMode == MD_DAEMON \|\| OpMode == MD_INITALIAS)
137	(void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT,
138	"%s: WARNING: dangerous write permissions\n",
139	FileName);
140	if (LogLevel > 0)
141	sm_syslog(LOG_CRIT, NOQID,
142	"%s: WARNING: dangerous write permissions",
143	FileName);
144	}
145
146	#if XLA
147	xla_zero();
148	#endif /* XLA */
149
150	while ((bp = fgetfolded(buf, sizeof buf, cf)) != NULL)
151	{
152	if (bp[0] == '#')
153	{
154	if (bp != buf)
155	sm_free(bp); /* XXX */
156	continue;
157	}
158
159	/* do macro expansion mappings */
160	translate_dollars(bp);
161
162	/* interpret this line */
163	errno = 0;
164	switch (bp[0])
165	{
166	case '\0':
167	case '#': /* comment */
168	break;
169
170	case 'R': /* rewriting rule */
171	if (ruleset < 0)
172	{
173	syserr("missing valid ruleset for \"%s\"", bp);
174	break;
175	}
176	for (p = &bp[1]; p != '\0' && p != '\t'; p++)
177	continue;
178
179	if (*p == '\0')
180	{
181	syserr("invalid rewrite line \"%s\" (tab expected)", bp);
182	break;
183	}
184
185	/* allocate space for the rule header */
186	if (rwp == NULL)
187	{
188	RewriteRules[ruleset] = rwp =
189	(struct rewrite ) xalloc(sizeof rwp);
190	}
191	else
192	{
193	rwp->r_next = (struct rewrite ) xalloc(sizeof rwp);
194	rwp = rwp->r_next;
195	}
196	rwp->r_next = NULL;
197
198	/* expand and save the LHS */
199	*p = '\0';
200	expand(&bp[1], exbuf, sizeof exbuf, e);
201	rwp->r_lhs = prescan(exbuf, '\t', pvpbuf,
202	sizeof pvpbuf, NULL,
203	ConfigLevel >= 9 ? TokTypeNoC : NULL);
204	nfuzzy = 0;
205	if (rwp->r_lhs != NULL)
206	{
207	register char **ap;
208
209	rwp->r_lhs = copyplist(rwp->r_lhs, true, NULL);
210
211	/* count the number of fuzzy matches in LHS */
212	for (ap = rwp->r_lhs; *ap != NULL; ap++)
213	{
214	char *botch;
215
216	botch = NULL;
217	switch (**ap & 0377)
218	{
219	case MATCHZANY:
220	case MATCHANY:
221	case MATCHONE:
222	case MATCHCLASS:
223	case MATCHNCLASS:
224	nfuzzy++;
225	break;
226
227	case MATCHREPL:
228	botch = "$0-$9";
229	break;
230
231	case CANONUSER:
232	botch = "$:";
233	break;
234
235	case CALLSUBR:
236	botch = "$>";
237	break;
238
239	case CONDIF:
240	botch = "$?";
241	break;
242
243	case CONDFI:
244	botch = "$.";
245	break;
246
247	case HOSTBEGIN:
248	botch = "$[";
249	break;
250
251	case HOSTEND:
252	botch = "$]";
253	break;
254
255	case LOOKUPBEGIN:
256	botch = "$(";
257	break;
258
259	case LOOKUPEND:
260	botch = "$)";
261	break;
262	}
263	if (botch != NULL)
264	syserr("Inappropriate use of %s on LHS",
265	botch);
266	}
267	rwp->r_line = LineNumber;
268	}
269	else
270	{
271	syserr("R line: null LHS");
272	rwp->r_lhs = null_list;
273	}
274	if (nfuzzy > MAXMATCH)
275	{
276	syserr("R line: too many wildcards");
277	rwp->r_lhs = null_list;
278	}
279
280	/* expand and save the RHS */
281	while (*++p == '\t')
282	continue;
283	q = p;
284	while (p != '\0' && p != '\t')
285	p++;
286	*p = '\0';
287	expand(q, exbuf, sizeof exbuf, e);
288	rwp->r_rhs = prescan(exbuf, '\t', pvpbuf,
289	sizeof pvpbuf, NULL,
290	ConfigLevel >= 9 ? TokTypeNoC : NULL);
291	if (rwp->r_rhs != NULL)
292	{
293	register char **ap;
294
295	rwp->r_rhs = copyplist(rwp->r_rhs, true, NULL);
296
297	/* check no out-of-bounds replacements */
298	nfuzzy += '0';
299	for (ap = rwp->r_rhs; *ap != NULL; ap++)
300	{
301	char *botch;
302
303	botch = NULL;
304	switch (**ap & 0377)
305	{
306	case MATCHREPL:
307	if ((ap)[1] <= '0' \|\| (ap)[1] > nfuzzy)
308	{
309	syserr("replacement $%c out of bounds",
310	(*ap)[1]);
311	}
312	break;
313
314	case MATCHZANY:
315	botch = "$*";
316	break;
317
318	case MATCHANY:
319	botch = "$+";
320	break;
321
322	case MATCHONE:
323	botch = "$-";
324	break;
325
326	case MATCHCLASS:
327	botch = "$=";
328	break;
329
330	case MATCHNCLASS:
331	botch = "$~";
332	break;
333
334	#if 0
335	/*
336	** This doesn't work yet as there are maps defined after the cf
337	** is read such as host, user, and alias. So for now, it's removed.
338	** When it comes back, the RELEASE_NOTES entry will be:
339	** Emit warnings for unknown maps when reading the .cf file. Based on
340	** patch from Robert Harker of Harker Systems.
341	*/
342
343	case LOOKUPBEGIN:
344	/*
345	** Got a database lookup,
346	** check if map is defined.
347	*/
348
349	ep = *(ap + 1);
350	if ((*ep & 0377) != MACRODEXPAND &&
351	stab(ep, ST_MAP,
352	ST_FIND) == NULL)
353	{
354	(void) sm_io_fprintf(smioout,
355	SM_TIME_DEFAULT,
356	"Warning: %s: line %d: map %s not found\n",
357	FileName,
358	LineNumber,
359	ep);
360	}
361	break;
362	#endif /* 0 */
363	}
364	if (botch != NULL)
365	syserr("Inappropriate use of %s on RHS",
366	botch);
367	}
368	}
369	else
370	{
371	syserr("R line: null RHS");
372	rwp->r_rhs = null_list;
373	}
374	break;
375
376	case 'S': /* select rewriting set */
377	expand(&bp[1], exbuf, sizeof exbuf, e);
378	ruleset = strtorwset(exbuf, NULL, ST_ENTER);
379	if (ruleset < 0)
380	break;
381
382	rwp = RewriteRules[ruleset];
383	if (rwp != NULL)
384	{
385	if (OpMode == MD_TEST)
386	(void) sm_io_fprintf(smioout,
387	SM_TIME_DEFAULT,
388	"WARNING: Ruleset %s has multiple definitions\n",
389	&bp[1]);
390	if (tTd(37, 1))
391	sm_dprintf("WARNING: Ruleset %s has multiple definitions\n",
392	&bp[1]);
393	while (rwp->r_next != NULL)
394	rwp = rwp->r_next;
395	}
396	break;
397
398	case 'D': /* macro definition */
399	mid = macid_parse(&bp[1], &ep);
400	if (mid == 0)
401	break;
402	p = munchstring(ep, NULL, '\0');
403	macdefine(&e->e_macro, A_TEMP, mid, p);
404	break;
405
406	case 'H': /* required header line */
407	(void) chompheader(&bp[1], CHHDR_DEF, NULL, e);
408	break;
409
410	case 'C': /* word class */
411	case 'T': /* trusted user (set class `t') */
412	if (bp[0] == 'C')
413	{
414	mid = macid_parse(&bp[1], &ep);
415	if (mid == 0)
416	break;
417	expand(ep, exbuf, sizeof exbuf, e);
418	p = exbuf;
419	}
420	else
421	{
422	mid = 't';
423	p = &bp[1];
424	}
425	while (*p != '\0')
426	{
427	register char *wd;
428	char delim;
429
430	while (p != '\0' && isascii(p) && isspace(*p))
431	p++;
432	wd = p;
433	while (p != '\0' && !(isascii(p) && isspace(*p)))
434	p++;
435	delim = *p;
436	*p = '\0';
437	if (wd[0] != '\0')
438	setclass(mid, wd);
439	*p = delim;
440	}
441	break;
442
443	case 'F': /* word class from file */
444	mid = macid_parse(&bp[1], &ep);
445	if (mid == 0)
446	break;
447	for (p = ep; isascii(p) && isspace(p); )
448	p++;
449	if (p[0] == '-' && p[1] == 'o')
450	{
451	optional = true;
452	while (*p != '\0' &&
453	!(isascii(p) && isspace(p)))
454	p++;
455	while (isascii(p) && isspace(p))
456	p++;
457	file = p;
458	}
459	else
460	optional = false;
461
462	/* check if [key]@map:spec */
463	ismap = false;
464	if (!SM_IS_DIR_DELIM(*p) &&
465	*p != '\|' &&
466	(q = strchr(p, '@')) != NULL)
467	{
468	q++;
469
470	/* look for @LDAP or @map: in string */
471	if (strcmp(q, "LDAP") == 0 \|\|
472	(*q != ':' &&
473	strchr(q, ':') != NULL))
474	ismap = true;
475	}
476
477	if (ismap)
478	{
479	/* use entire spec */
480	file = p;
481	}
482	else
483	{
484	file = extrquotstr(p, &q, " ", &ok);
485	if (!ok)
486	{
487	syserr("illegal filename '%s'", p);
488	break;
489	}
490	}
491
492	if (*file == '\|' \|\| ismap)
493	p = "%s";
494	else
495	{
496	p = q;
497	if (*p == '\0')
498	p = "%s";
499	else
500	{
501	*p = '\0';
502	while (isascii(++p) && isspace(p))
503	continue;
504	}
505	}
506	fileclass(mid, file, p, ismap, safe, optional);
507	break;
508
509	#if XLA
510	case 'L': /* extended load average description */
511	xla_init(&bp[1]);
512	break;
513	#endif /* XLA */
514
515	#if defined(SUN_EXTENSIONS) && defined(SUN_LOOKUP_MACRO)
516	case 'L': /* lookup macro */
517	case 'G': /* lookup class */
518	/* reserved for Sun -- NIS+ database lookup */
519	if (VendorCode != VENDOR_SUN)
520	goto badline;
521	sun_lg_config_line(bp, e);
522	break;
523	#endif /* defined(SUN_EXTENSIONS) && defined(SUN_LOOKUP_MACRO) */
524
525	case 'M': /* define mailer */
526	makemailer(&bp[1]);
527	break;
528
529	case 'O': /* set option */
530	setoption(bp[1], &bp[2], safe, false, e);
531	break;
532
533	case 'P': /* set precedence */
534	if (NumPriorities >= MAXPRIORITIES)
535	{
536	toomany('P', MAXPRIORITIES);
537	break;
538	}
539	for (p = &bp[1]; p != '\0' && p != '='; p++)
540	continue;
541	if (*p == '\0')
542	goto badline;
543	*p = '\0';
544	Priorities[NumPriorities].pri_name = newstr(&bp[1]);
545	Priorities[NumPriorities].pri_val = atoi(++p);
546	NumPriorities++;
547	break;
548
549	case 'Q': /* define queue */
550	makequeue(&bp[1], true);
551	break;
552
553	case 'V': /* configuration syntax version */
554	for (p = &bp[1]; isascii(p) && isspace(p); p++)
555	continue;
556	if (!isascii(p) \|\| !isdigit(p))
557	{
558	syserr("invalid argument to V line: \"%.20s\"",
559	&bp[1]);
560	break;
561	}
562	ConfigLevel = strtol(p, &ep, 10);
563
564	/*
565	** Do heuristic tweaking for back compatibility.
566	*/
567
568	if (ConfigLevel >= 5)
569	{
570	/* level 5 configs have short name in $w */
571	p = macvalue('w', e);
572	if (p != NULL && (p = strchr(p, '.')) != NULL)
573	{
574	*p = '\0';
575	macdefine(&e->e_macro, A_TEMP, 'w',
576	macvalue('w', e));
577	}
578	}
579	if (ConfigLevel >= 6)
580	{
581	ColonOkInAddr = false;
582	}
583
584	/*
585	** Look for vendor code.
586	*/
587
588	if (*ep++ == '/')
589	{
590	/* extract vendor code */
591	for (p = ep; isascii(p) && isalpha(p); )
592	p++;
593	*p = '\0';
594
595	if (!setvendor(ep))
596	syserr("invalid V line vendor code: \"%s\"",
597	ep);
598	}
599	break;
600
601	case 'K':
602	expand(&bp[1], exbuf, sizeof exbuf, e);
603	(void) makemapentry(exbuf);
604	break;
605
606	case 'E':
607	p = strchr(bp, '=');
608	if (p != NULL)
609	*p++ = '\0';
610	setuserenv(&bp[1], p);
611	break;
612
613	case 'X': /* mail filter */
614	#if MILTER
615	milter_setup(&bp[1]);
616	#else /* MILTER */
617	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
618	"Warning: Filter usage ('X') requires Milter support (-DMILTER)\n");
619	#endif /* MILTER */
620	break;
621
622	default:
623	badline:
624	syserr("unknown configuration line \"%s\"", bp);
625	}
626	if (bp != buf)
627	sm_free(bp); /* XXX */
628	}
629	if (sm_io_error(cf))
630	{
631	syserr("I/O read error");
632	finis(false, true, EX_OSFILE);
633	}
634	(void) sm_io_close(cf, SM_TIME_DEFAULT);
635	FileName = NULL;
636
637	/* initialize host maps from local service tables */
638	inithostmaps();
639
640	/* initialize daemon (if not defined yet) */
641	initdaemon();
642
643	/* determine if we need to do special name-server frotz */
644	{
645	int nmaps;
646	char *maptype[MAXMAPSTACK];
647	short mapreturn[MAXMAPACTIONS];
648
649	nmaps = switch_map_find("hosts", maptype, mapreturn);
650	UseNameServer = false;
651	if (nmaps > 0 && nmaps <= MAXMAPSTACK)
652	{
653	register int mapno;
654
655	for (mapno = 0; mapno < nmaps && !UseNameServer;
656	mapno++)
657	{
658	if (strcmp(maptype[mapno], "dns") == 0)
659	UseNameServer = true;
660	}
661	}
662	}
663	}
664	/*
665	** TRANSLATE_DOLLARS -- convert $x into internal form
666	**
667	** Actually does all appropriate pre-processing of a config line
668	** to turn it into internal form.
669	**
670	** Parameters:
671	** bp -- the buffer to translate.
672	**
673	** Returns:
674	** None. The buffer is translated in place. Since the
675	** translations always make the buffer shorter, this is
676	** safe without a size parameter.
677	*/
678
679	void
680	translate_dollars(bp)
681	char *bp;
682	{
683	register char *p;
684	auto char *ep;
685
686	for (p = bp; *p != '\0'; p++)
687	{
688	if (*p == '#' && p > bp && ConfigLevel >= 3)
689	{
690	register char *e;
691
692	switch (*--p & 0377)
693	{
694	case MACROEXPAND:
695	/* it's from $# -- let it go through */
696	p++;
697	break;
698
699	case '\\':
700	/* it's backslash escaped */
701	(void) sm_strlcpy(p, p + 1, strlen(p));
702	break;
703
704	default:
705	/* delete leading white space */
706	while (isascii(p) && isspace(p) &&
707	*p != '\n' && p > bp)
708	p--;
709	if ((e = strchr(++p, '\n')) != NULL)
710	(void) sm_strlcpy(p, e, strlen(p));
711	else
712	*p-- = '\0';
713	break;
714	}
715	continue;
716	}
717
718	if (*p != '$' \|\| p[1] == '\0')
719	continue;
720
721	if (p[1] == '$')
722	{
723	/* actual dollar sign.... */
724	(void) sm_strlcpy(p, p + 1, strlen(p));
725	continue;
726	}
727
728	/* convert to macro expansion character */
729	*p++ = MACROEXPAND;
730
731	/* special handling for $=, $~, $&, and $? */
732	if (p == '=' \|\| p == '~' \|\| p == '&' \|\| p == '?')
733	p++;
734
735	/* convert macro name to code */
736	*p = macid_parse(p, &ep);
737	if (ep != p + 1)
738	(void) sm_strlcpy(p + 1, ep, strlen(p + 1));
739	}
740
741	/* strip trailing white space from the line */
742	while (--p > bp && isascii(p) && isspace(p))
743	*p = '\0';
744	}
745	/*
746	** TOOMANY -- signal too many of some option
747	**
748	** Parameters:
749	** id -- the id of the error line
750	** maxcnt -- the maximum possible values
751	**
752	** Returns:
753	** none.
754	**
755	** Side Effects:
756	** gives a syserr.
757	*/
758
759	static void
760	toomany(id, maxcnt)
761	int id;
762	int maxcnt;
763	{
764	syserr("too many %c lines, %d max", id, maxcnt);
765	}
766	/*
767	** FILECLASS -- read members of a class from a file
768	**
769	** Parameters:
770	** class -- class to define.
771	** filename -- name of file to read.
772	** fmt -- scanf string to use for match.
773	** ismap -- if set, this is a map lookup.
774	** safe -- if set, this is a safe read.
775	** optional -- if set, it is not an error for the file to
776	** not exist.
777	**
778	** Returns:
779	** none
780	**
781	** Side Effects:
782	** puts all lines in filename that match a scanf into
783	** the named class.
784	*/
785
786	/*
787	** Break up the match into words and add to class.
788	*/
789
790	static void
791	parse_class_words(class, line)
792	int class;
793	char *line;
794	{
795	while (line != NULL && *line != '\0')
796	{
797	register char *q;
798
799	/* strip leading spaces */
800	while (isascii(line) && isspace(line))
801	line++;
802	if (*line == '\0')
803	break;
804
805	/* find the end of the word */
806	q = line;
807	while (line != '\0' && !(isascii(line) && isspace(*line)))
808	line++;
809	if (*line != '\0')
810	*line++ = '\0';
811
812	/* enter the word in the symbol table */
813	setclass(class, q);
814	}
815	}
816
817	static void
818	fileclass(class, filename, fmt, ismap, safe, optional)
819	int class;
820	char *filename;
821	char *fmt;
822	bool ismap;
823	bool safe;
824	bool optional;
825	{
826	SM_FILE_T *f;
827	long sff;
828	pid_t pid;
829	register char *p;
830	char buf[MAXLINE];
831
832	if (tTd(37, 2))
833	sm_dprintf("fileclass(%s, fmt=%s)\n", filename, fmt);
834
835	if (*filename == '\0')
836	{
837	syserr("fileclass: missing file name");
838	return;
839	}
840	else if (ismap)
841	{
842	int status = 0;
843	char *key;
844	char *mn;
845	char cl, spec;
846	STAB *mapclass;
847	MAP map;
848
849	mn = newstr(macname(class));
850
851	key = filename;
852
853	/* skip past key */
854	if ((p = strchr(filename, '@')) == NULL)
855	{
856	/* should not happen */
857	syserr("fileclass: bogus map specification");
858	sm_free(mn);
859	return;
860	}
861
862	/* skip past '@' */
863	*p++ = '\0';
864	cl = p;
865
866	if (strcmp(cl, "LDAP") == 0)
867	{
868	int n;
869	char *lc;
870	char jbuf[MAXHOSTNAMELEN];
871	char lcbuf[MAXLINE];
872
873	/* Get $j */
874	expand("\201j", jbuf, sizeof jbuf, &BlankEnvelope);
875	if (jbuf[0] == '\0')
876	{
877	(void) sm_strlcpy(jbuf, "localhost",
878	sizeof jbuf);
879	}
880
881	/* impose the default schema */
882	lc = macvalue(macid("{sendmailMTACluster}"), CurEnv);
883	if (lc == NULL)
884	lc = "";
885	else
886	{
887	expand(lc, lcbuf, sizeof lcbuf, CurEnv);
888	lc = lcbuf;
889	}
890
891	cl = "ldap";
892	n = sm_snprintf(buf, sizeof buf,
893	"-k (&(objectClass=sendmailMTAClass)(sendmailMTAClassName=%s)(\|(sendmailMTACluster=%s)(sendmailMTAHost=%s))) -v sendmailMTAClassValue",
894	mn, lc, jbuf);
895	if (n >= sizeof buf)
896	{
897	syserr("fileclass: F{%s}: Default LDAP string too long",
898	mn);
899	sm_free(mn);
900	return;
901	}
902	spec = buf;
903	}
904	else
905	{
906	if ((spec = strchr(cl, ':')) == NULL)
907	{
908	syserr("fileclass: F{%s}: missing map class",
909	mn);
910	sm_free(mn);
911	return;
912	}
913	*spec++ ='\0';
914	}
915
916	/* set up map structure */
917	mapclass = stab(cl, ST_MAPCLASS, ST_FIND);
918	if (mapclass == NULL)
919	{
920	syserr("fileclass: F{%s}: class %s not available",
921	mn, cl);
922	sm_free(mn);
923	return;
924	}
925	memset(&map, '\0', sizeof map);
926	map.map_class = &mapclass->s_mapclass;
927	map.map_mname = mn;
928	map.map_mflags \|= MF_FILECLASS;
929
930	if (tTd(37, 5))
931	sm_dprintf("fileclass: F{%s}: map class %s, key %s, spec %s\n",
932	mn, cl, key, spec);
933
934
935	/* parse map spec */
936	if (!map.map_class->map_parse(&map, spec))
937	{
938	/* map_parse() showed the error already */
939	sm_free(mn);
940	return;
941	}
942	map.map_mflags \|= MF_VALID;
943
944	/* open map */
945	if (map.map_class->map_open(&map, O_RDONLY))
946	{
947	map.map_mflags \|= MF_OPEN;
948	map.map_pid = getpid();
949	}
950	else
951	{
952	if (!optional &&
953	!bitset(MF_OPTIONAL, map.map_mflags))
954	syserr("fileclass: F{%s}: map open failed",
955	mn);
956	sm_free(mn);
957	return;
958	}
959
960	/* lookup */
961	p = (*map.map_class->map_lookup)(&map, key, NULL, &status);
962	if (status != EX_OK && status != EX_NOTFOUND)
963	{
964	if (!optional)
965	syserr("fileclass: F{%s}: map lookup failed",
966	mn);
967	p = NULL;
968	}
969
970	/* use the results */
971	if (p != NULL)
972	parse_class_words(class, p);
973
974	/* close map */
975	map.map_mflags \|= MF_CLOSING;
976	map.map_class->map_close(&map);
977	map.map_mflags &= ~(MF_OPEN\|MF_WRITABLE\|MF_CLOSING);
978	sm_free(mn);
979	return;
980	}
981	else if (filename[0] == '\|')
982	{
983	auto int fd;
984	int i;
985	char *argv[MAXPV + 1];
986
987	i = 0;
988	for (p = strtok(&filename[1], " \t");
989	p != NULL && i < MAXPV;
990	p = strtok(NULL, " \t"))
991	argv[i++] = p;
992	argv[i] = NULL;
993	pid = prog_open(argv, &fd, CurEnv);
994	if (pid < 0)
995	f = NULL;
996	else
997	f = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
998	(void *) &fd, SM_IO_RDONLY, NULL);
999	}
1000	else
1001	{
1002	pid = -1;
1003	sff = SFF_REGONLY;
1004	if (!bitnset(DBS_CLASSFILEINUNSAFEDIRPATH, DontBlameSendmail))
1005	sff \|= SFF_SAFEDIRPATH;
1006	if (!bitnset(DBS_LINKEDCLASSFILEINWRITABLEDIR,
1007	DontBlameSendmail))
1008	sff \|= SFF_NOWLINK;
1009	if (safe)
1010	sff \|= SFF_OPENASROOT;
1011	else if (RealUid == 0)
1012	sff \|= SFF_ROOTOK;
1013	if (DontLockReadFiles)
1014	sff \|= SFF_NOLOCK;
1015	f = safefopen(filename, O_RDONLY, 0, sff);
1016	}
1017	if (f == NULL)
1018	{
1019	if (!optional)
1020	syserr("fileclass: cannot open '%s'", filename);
1021	return;
1022	}
1023
1024	while (sm_io_fgets(f, SM_TIME_DEFAULT, buf, sizeof buf) != NULL)
1025	{
1026	#if SCANF
1027	char wordbuf[MAXLINE + 1];
1028	#endif /* SCANF */
1029
1030	if (buf[0] == '#')
1031	continue;
1032	#if SCANF
1033	if (sm_io_sscanf(buf, fmt, wordbuf) != 1)
1034	continue;
1035	p = wordbuf;
1036	#else /* SCANF */
1037	p = buf;
1038	#endif /* SCANF */
1039
1040	parse_class_words(class, p);
1041
1042	/*
1043	** If anything else is added here,
1044	** check if the '@' map case above
1045	** needs the code as well.
1046	*/
1047	}
1048
1049	(void) sm_io_close(f, SM_TIME_DEFAULT);
1050	if (pid > 0)
1051	(void) waitfor(pid);
1052	}
1053	/*
1054	** MAKEMAILER -- define a new mailer.
1055	**
1056	** Parameters:
1057	** line -- description of mailer. This is in labeled
1058	** fields. The fields are:
1059	** A -- the argv for this mailer
1060	** C -- the character set for MIME conversions
1061	** D -- the directory to run in
1062	** E -- the eol string
1063	** F -- the flags associated with the mailer
1064	** L -- the maximum line length
1065	** M -- the maximum message size
1066	** N -- the niceness at which to run
1067	** P -- the path to the mailer
1068	** Q -- the queue group for the mailer
1069	** R -- the recipient rewriting set
1070	** S -- the sender rewriting set
1071	** T -- the mailer type (for DSNs)
1072	** U -- the uid to run as
1073	** W -- the time to wait at the end
1074	** m -- maximum messages per connection
1075	** r -- maximum number of recipients per message
1076	** / -- new root directory
1077	** The first word is the canonical name of the mailer.
1078	**
1079	** Returns:
1080	** none.
1081	**
1082	** Side Effects:
1083	** enters the mailer into the mailer table.
1084	*/
1085
1086	void
1087	makemailer(line)
1088	char *line;
1089	{
1090	register char *p;
1091	register struct mailer *m;
1092	register STAB *s;
1093	int i;
1094	char fcode;
1095	auto char *endp;
1096	static int nextmailer = 0; /* "free" index into Mailer struct */
1097
1098	/* allocate a mailer and set up defaults */
1099	m = (struct mailer ) xalloc(sizeof m);
1100	memset((char ) m, '\0', sizeof m);
1101	errno = 0; /* avoid bogus error text */
1102
1103	/* collect the mailer name */
1104	for (p = line;
1105	p != '\0' && p != ',' && !(isascii(p) && isspace(p));
1106	p++)
1107	continue;
1108	if (*p != '\0')
1109	*p++ = '\0';
1110	if (line[0] == '\0')
1111	{
1112	syserr("name required for mailer");
1113	return;
1114	}
1115	m->m_name = newstr(line);
1116	m->m_qgrp = NOQGRP;
1117
1118	/* now scan through and assign info from the fields */
1119	while (*p != '\0')
1120	{
1121	auto char *delimptr;
1122
1123	while (*p != '\0' &&
1124	(p == ',' \|\| (isascii(p) && isspace(*p))))
1125	p++;
1126
1127	/* p now points to field code */
1128	fcode = *p;
1129	while (p != '\0' && p != '=' && *p != ',')
1130	p++;
1131	if (*p++ != '=')
1132	{
1133	syserr("mailer %s: `=' expected", m->m_name);
1134	return;
1135	}
1136	while (isascii(p) && isspace(p))
1137	p++;
1138
1139	/* p now points to the field body */
1140	p = munchstring(p, &delimptr, ',');
1141
1142	/* install the field into the mailer struct */
1143	switch (fcode)
1144	{
1145	case 'P': /* pathname */
1146	if (p != '\0') / error is issued below */
1147	m->m_mailer = newstr(p);
1148	break;
1149
1150	case 'F': /* flags */
1151	for (; *p != '\0'; p++)
1152	{
1153	if (!(isascii(p) && isspace(p)))
1154	{
1155	#if _FFR_DEPRECATE_MAILER_FLAG_I
1156	if (*p == M_INTERNAL)
1157	sm_syslog(LOG_WARNING, NOQID,
1158	"WARNING: mailer=%s, flag=%c deprecated",
1159	m->m_name, *p);
1160	#endif /* _FFR_DEPRECATE_MAILER_FLAG_I */
1161	setbitn(bitidx(*p), m->m_flags);
1162	}
1163	}
1164	break;
1165
1166	case 'S': /* sender rewriting ruleset */
1167	case 'R': /* recipient rewriting ruleset */
1168	i = strtorwset(p, &endp, ST_ENTER);
1169	if (i < 0)
1170	return;
1171	if (fcode == 'S')
1172	m->m_sh_rwset = m->m_se_rwset = i;
1173	else
1174	m->m_rh_rwset = m->m_re_rwset = i;
1175
1176	p = endp;
1177	if (*p++ == '/')
1178	{
1179	i = strtorwset(p, NULL, ST_ENTER);
1180	if (i < 0)
1181	return;
1182	if (fcode == 'S')
1183	m->m_sh_rwset = i;
1184	else
1185	m->m_rh_rwset = i;
1186	}
1187	break;
1188
1189	case 'E': /* end of line string */
1190	if (*p == '\0')
1191	syserr("mailer %s: null end-of-line string",
1192	m->m_name);
1193	else
1194	m->m_eol = newstr(p);
1195	break;
1196
1197	case 'A': /* argument vector */
1198	if (p != '\0') / error is issued below */
1199	m->m_argv = makeargv(p);
1200	break;
1201
1202	case 'M': /* maximum message size */
1203	m->m_maxsize = atol(p);
1204	break;
1205
1206	case 'm': /* maximum messages per connection */
1207	m->m_maxdeliveries = atoi(p);
1208	break;
1209
1210	case 'r': /* max recipient per envelope */
1211	m->m_maxrcpt = atoi(p);
1212	break;
1213
1214	case 'L': /* maximum line length */
1215	m->m_linelimit = atoi(p);
1216	if (m->m_linelimit < 0)
1217	m->m_linelimit = 0;
1218	break;
1219
1220	case 'N': /* run niceness */
1221	m->m_nice = atoi(p);
1222	break;
1223
1224	case 'D': /* working directory */
1225	if (*p == '\0')
1226	syserr("mailer %s: null working directory",
1227	m->m_name);
1228	else
1229	m->m_execdir = newstr(p);
1230	break;
1231
1232	case 'C': /* default charset */
1233	if (*p == '\0')
1234	syserr("mailer %s: null charset", m->m_name);
1235	else
1236	m->m_defcharset = newstr(p);
1237	break;
1238
1239	case 'Q': /* queue for this mailer */
1240	if (*p == '\0')
1241	{
1242	syserr("mailer %s: null queue", m->m_name);
1243	break;
1244	}
1245	s = stab(p, ST_QUEUE, ST_FIND);
1246	if (s == NULL)
1247	syserr("mailer %s: unknown queue %s",
1248	m->m_name, p);
1249	else
1250	m->m_qgrp = s->s_quegrp->qg_index;
1251	break;
1252
1253	case 'T': /* MTA-Name/Address/Diagnostic types */
1254	/* extract MTA name type; default to "dns" */
1255	m->m_mtatype = newstr(p);
1256	p = strchr(m->m_mtatype, '/');
1257	if (p != NULL)
1258	{
1259	*p++ = '\0';
1260	if (*p == '\0')
1261	p = NULL;
1262	}
1263	if (*m->m_mtatype == '\0')
1264	m->m_mtatype = "dns";
1265
1266	/* extract address type; default to "rfc822" */
1267	m->m_addrtype = p;
1268	if (p != NULL)
1269	p = strchr(p, '/');
1270	if (p != NULL)
1271	{
1272	*p++ = '\0';
1273	if (*p == '\0')
1274	p = NULL;
1275	}
1276	if (m->m_addrtype == NULL \|\| *m->m_addrtype == '\0')
1277	m->m_addrtype = "rfc822";
1278
1279	/* extract diagnostic type; default to "smtp" */
1280	m->m_diagtype = p;
1281	if (m->m_diagtype == NULL \|\| *m->m_diagtype == '\0')
1282	m->m_diagtype = "smtp";
1283	break;
1284
1285	case 'U': /* user id */
1286	if (isascii(p) && !isdigit(p))
1287	{
1288	char *q = p;
1289	struct passwd *pw;
1290
1291	while (p != '\0' && isascii(p) &&
1292	(isalnum(p) \|\| strchr("-_", p) != NULL))
1293	p++;
1294	while (isascii(p) && isspace(p))
1295	*p++ = '\0';
1296	if (*p != '\0')
1297	*p++ = '\0';
1298	if (*q == '\0')
1299	{
1300	syserr("mailer %s: null user name",
1301	m->m_name);
1302	break;
1303	}
1304	pw = sm_getpwnam(q);
1305	if (pw == NULL)
1306	{
1307	syserr("readcf: mailer U= flag: unknown user %s", q);
1308	break;
1309	}
1310	else
1311	{
1312	m->m_uid = pw->pw_uid;
1313	m->m_gid = pw->pw_gid;
1314	}
1315	}
1316	else
1317	{
1318	auto char *q;
1319
1320	m->m_uid = strtol(p, &q, 0);
1321	p = q;
1322	while (isascii(p) && isspace(p))
1323	p++;
1324	if (*p != '\0')
1325	p++;
1326	}
1327	while (isascii(p) && isspace(p))
1328	p++;
1329	if (*p == '\0')
1330	break;
1331	if (isascii(p) && !isdigit(p))
1332	{
1333	char *q = p;
1334	struct group *gr;
1335
1336	while (isascii(p) && isalnum(p))
1337	p++;
1338	*p++ = '\0';
1339	if (*q == '\0')
1340	{
1341	syserr("mailer %s: null group name",
1342	m->m_name);
1343	break;
1344	}
1345	gr = getgrnam(q);
1346	if (gr == NULL)
1347	{
1348	syserr("readcf: mailer U= flag: unknown group %s", q);
1349	break;
1350	}
1351	else
1352	m->m_gid = gr->gr_gid;
1353	}
1354	else
1355	{
1356	m->m_gid = strtol(p, NULL, 0);
1357	}
1358	break;
1359
1360	case 'W': /* wait timeout */
1361	m->m_wait = convtime(p, 's');
1362	break;
1363
1364	case '/': /* new root directory */
1365	if (*p == '\0')
1366	syserr("mailer %s: null root directory",
1367	m->m_name);
1368	else
1369	m->m_rootdir = newstr(p);
1370	break;
1371
1372	default:
1373	syserr("M%s: unknown mailer equate %c=",
1374	m->m_name, fcode);
1375	break;
1376	}
1377
1378	p = delimptr;
1379	}
1380
1381	#if !HASRRESVPORT
1382	if (bitnset(M_SECURE_PORT, m->m_flags))
1383	{
1384	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1385	"M%s: Warning: F=%c set on system that doesn't support rresvport()\n",
1386	m->m_name, M_SECURE_PORT);
1387	}
1388	#endif /* !HASRRESVPORT */
1389
1390	#if !HASNICE
1391	if (m->m_nice != 0)
1392	{
1393	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1394	"M%s: Warning: N= set on system that doesn't support nice()\n",
1395	m->m_name);
1396	}
1397	#endif /* !HASNICE */
1398
1399	/* do some rationality checking */
1400	if (m->m_argv == NULL)
1401	{
1402	syserr("M%s: A= argument required", m->m_name);
1403	return;
1404	}
1405	if (m->m_mailer == NULL)
1406	{
1407	syserr("M%s: P= argument required", m->m_name);
1408	return;
1409	}
1410
1411	if (nextmailer >= MAXMAILERS)
1412	{
1413	syserr("too many mailers defined (%d max)", MAXMAILERS);
1414	return;
1415	}
1416
1417	if (m->m_maxrcpt <= 0)
1418	m->m_maxrcpt = DEFAULT_MAX_RCPT;
1419
1420	/* do some heuristic cleanup for back compatibility */
1421	if (bitnset(M_LIMITS, m->m_flags))
1422	{
1423	if (m->m_linelimit == 0)
1424	m->m_linelimit = SMTPLINELIM;
1425	if (ConfigLevel < 2)
1426	setbitn(M_7BITS, m->m_flags);
1427	}
1428
1429	if (strcmp(m->m_mailer, "[TCP]") == 0)
1430	{
1431	syserr("M%s: P=[TCP] must be replaced by P=[IPC]", m->m_name);
1432	return;
1433	}
1434
1435	if (strcmp(m->m_mailer, "[IPC]") == 0)
1436	{
1437	/* Use the second argument for host or path to socket */
1438	if (m->m_argv[0] == NULL \|\| m->m_argv[1] == NULL \|\|
1439	m->m_argv[1][0] == '\0')
1440	{
1441	syserr("M%s: too few parameters for %s mailer",
1442	m->m_name, m->m_mailer);
1443	return;
1444	}
1445	if (strcmp(m->m_argv[0], "TCP") != 0
1446	#if NETUNIX
1447	&& strcmp(m->m_argv[0], "FILE") != 0
1448	#endif /* NETUNIX */
1449	)
1450	{
1451	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1452	"M%s: Warning: first argument in %s mailer must be %s\n",
1453	m->m_name, m->m_mailer,
1454	#if NETUNIX
1455	"TCP or FILE"
1456	#else /* NETUNIX */
1457	"TCP"
1458	#endif /* NETUNIX */
1459	);
1460	}
1461	if (m->m_mtatype == NULL)
1462	m->m_mtatype = "dns";
1463	if (m->m_addrtype == NULL)
1464	m->m_addrtype = "rfc822";
1465	if (m->m_diagtype == NULL)
1466	{
1467	if (m->m_argv[0] != NULL &&
1468	strcmp(m->m_argv[0], "FILE") == 0)
1469	m->m_diagtype = "x-unix";
1470	else
1471	m->m_diagtype = "smtp";
1472	}
1473	}
1474	else if (strcmp(m->m_mailer, "[FILE]") == 0)
1475	{
1476	/* Use the second argument for filename */
1477	if (m->m_argv[0] == NULL \|\| m->m_argv[1] == NULL \|\|
1478	m->m_argv[2] != NULL)
1479	{
1480	syserr("M%s: too %s parameters for [FILE] mailer",
1481	m->m_name,
1482	(m->m_argv[0] == NULL \|\|
1483	m->m_argv[1] == NULL) ? "few" : "many");
1484	return;
1485	}
1486	else if (strcmp(m->m_argv[0], "FILE") != 0)
1487	{
1488	syserr("M%s: first argument in [FILE] mailer must be FILE",
1489	m->m_name);
1490	return;
1491	}
1492	}
1493
1494	if (m->m_eol == NULL)
1495	{
1496	char **pp;
1497
1498	/* default for SMTP is \r\n; use \n for local delivery */
1499	for (pp = m->m_argv; *pp != NULL; pp++)
1500	{
1501	for (p = pp; p != '\0'; )
1502	{
1503	if ((p++ & 0377) == MACROEXPAND && p == 'u')
1504	break;
1505	}
1506	if (*p != '\0')
1507	break;
1508	}
1509	if (*pp == NULL)
1510	m->m_eol = "\r\n";
1511	else
1512	m->m_eol = "\n";
1513	}
1514
1515	/* enter the mailer into the symbol table */
1516	s = stab(m->m_name, ST_MAILER, ST_ENTER);
1517	if (s->s_mailer != NULL)
1518	{
1519	i = s->s_mailer->m_mno;
1520	sm_free(s->s_mailer); /* XXX */
1521	}
1522	else
1523	{
1524	i = nextmailer++;
1525	}
1526	Mailer[i] = s->s_mailer = m;
1527	m->m_mno = i;
1528	}
1529	/*
1530	** MUNCHSTRING -- translate a string into internal form.
1531	**
1532	** Parameters:
1533	** p -- the string to munch.
1534	** delimptr -- if non-NULL, set to the pointer of the
1535	** field delimiter character.
1536	** delim -- the delimiter for the field.
1537	**
1538	** Returns:
1539	** the munched string.
1540	**
1541	** Side Effects:
1542	** the munched string is a local static buffer.
1543	** it must be copied before the function is called again.
1544	*/
1545
1546	char *
1547	munchstring(p, delimptr, delim)
1548	register char *p;
1549	char **delimptr;
1550	int delim;
1551	{
1552	register char *q;
1553	bool backslash = false;
1554	bool quotemode = false;
1555	static char buf[MAXLINE];
1556
1557	for (q = buf; *p != '\0' && q < &buf[sizeof buf - 1]; p++)
1558	{
1559	if (backslash)
1560	{
1561	/* everything is roughly literal */
1562	backslash = false;
1563	switch (*p)
1564	{
1565	case 'r': /* carriage return */
1566	*q++ = '\r';
1567	continue;
1568
1569	case 'n': /* newline */
1570	*q++ = '\n';
1571	continue;
1572
1573	case 'f': /* form feed */
1574	*q++ = '\f';
1575	continue;
1576
1577	case 'b': /* backspace */
1578	*q++ = '\b';
1579	continue;
1580	}
1581	q++ = p;
1582	}
1583	else
1584	{
1585	if (*p == '\\')
1586	backslash = true;
1587	else if (*p == '"')
1588	quotemode = !quotemode;
1589	else if (quotemode \|\| *p != delim)
1590	q++ = p;
1591	else
1592	break;
1593	}
1594	}
1595
1596	if (delimptr != NULL)
1597	*delimptr = p;
1598	*q++ = '\0';
1599	return buf;
1600	}
1601	/*
1602	** EXTRQUOTSTR -- extract a (quoted) string.
1603	**
1604	** This routine deals with quoted (") strings and escaped
1605	** spaces (\\ ).
1606	**
1607	** Parameters:
1608	** p -- source string.
1609	** delimptr -- if non-NULL, set to the pointer of the
1610	** field delimiter character.
1611	** delimbuf -- delimiters for the field.
1612	** st -- if non-NULL, store the return value (whether the
1613	** string was correctly quoted) here.
1614	**
1615	** Returns:
1616	** the extracted string.
1617	**
1618	** Side Effects:
1619	** the returned string is a local static buffer.
1620	** it must be copied before the function is called again.
1621	*/
1622
1623	static char *
1624	extrquotstr(p, delimptr, delimbuf, st)
1625	register char *p;
1626	char **delimptr;
1627	char *delimbuf;
1628	bool *st;
1629	{
1630	register char *q;
1631	bool backslash = false;
1632	bool quotemode = false;
1633	static char buf[MAXLINE];
1634
1635	for (q = buf; *p != '\0' && q < &buf[sizeof buf - 1]; p++)
1636	{
1637	if (backslash)
1638	{
1639	backslash = false;
1640	if (*p != ' ')
1641	*q++ = '\\';
1642	}
1643	if (*p == '\\')
1644	backslash = true;
1645	else if (*p == '"')
1646	quotemode = !quotemode;
1647	else if (quotemode \|\|
1648	strchr(delimbuf, (int) *p) == NULL)
1649	q++ = p;
1650	else
1651	break;
1652	}
1653
1654	if (delimptr != NULL)
1655	*delimptr = p;
1656	*q++ = '\0';
1657	if (st != NULL)
1658	*st = !(quotemode \|\| backslash);
1659	return buf;
1660	}
1661	/*
1662	** MAKEARGV -- break up a string into words
1663	**
1664	** Parameters:
1665	** p -- the string to break up.
1666	**
1667	** Returns:
1668	a char argv (dynamically allocated)
1669	**
1670	** Side Effects:
1671	** munges p.
1672	*/
1673
1674	static char **
1675	makeargv(p)
1676	register char *p;
1677	{
1678	char *q;
1679	int i;
1680	char **avp;
1681	char *argv[MAXPV + 1];
1682
1683	/* take apart the words */
1684	i = 0;
1685	while (*p != '\0' && i < MAXPV)
1686	{
1687	q = p;
1688	while (p != '\0' && !(isascii(p) && isspace(*p)))
1689	p++;
1690	while (isascii(p) && isspace(p))
1691	*p++ = '\0';
1692	argv[i++] = newstr(q);
1693	}
1694	argv[i++] = NULL;
1695
1696	/* now make a copy of the argv */
1697	avp = (char *) xalloc(sizeof avp * i);
1698	memmove((char ) avp, (char ) argv, sizeof avp i);
1699
1700	return avp;
1701	}
1702	/*
1703	** PRINTRULES -- print rewrite rules (for debugging)
1704	**
1705	** Parameters:
1706	** none.
1707	**
1708	** Returns:
1709	** none.
1710	**
1711	** Side Effects:
1712	** prints rewrite rules.
1713	*/
1714
1715	void
1716	printrules()
1717	{
1718	register struct rewrite *rwp;
1719	register int ruleset;
1720
1721	for (ruleset = 0; ruleset < 10; ruleset++)
1722	{
1723	if (RewriteRules[ruleset] == NULL)
1724	continue;
1725	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1726	"\n----Rule Set %d:", ruleset);
1727
1728	for (rwp = RewriteRules[ruleset]; rwp != NULL; rwp = rwp->r_next)
1729	{
1730	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1731	"\nLHS:");
1732	printav(rwp->r_lhs);
1733	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1734	"RHS:");
1735	printav(rwp->r_rhs);
1736	}
1737	}
1738	}
1739	/*
1740	** PRINTMAILER -- print mailer structure (for debugging)
1741	**
1742	** Parameters:
1743	** m -- the mailer to print
1744	**
1745	** Returns:
1746	** none.
1747	*/
1748
1749	void
1750	printmailer(m)
1751	register MAILER *m;
1752	{
1753	int j;
1754
1755	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1756	"mailer %d (%s): P=%s S=", m->m_mno, m->m_name,
1757	m->m_mailer);
1758	if (RuleSetNames[m->m_se_rwset] == NULL)
1759	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%d/",
1760	m->m_se_rwset);
1761	else
1762	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%s/",
1763	RuleSetNames[m->m_se_rwset]);
1764	if (RuleSetNames[m->m_sh_rwset] == NULL)
1765	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%d R=",
1766	m->m_sh_rwset);
1767	else
1768	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%s R=",
1769	RuleSetNames[m->m_sh_rwset]);
1770	if (RuleSetNames[m->m_re_rwset] == NULL)
1771	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%d/",
1772	m->m_re_rwset);
1773	else
1774	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%s/",
1775	RuleSetNames[m->m_re_rwset]);
1776	if (RuleSetNames[m->m_rh_rwset] == NULL)
1777	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%d ",
1778	m->m_rh_rwset);
1779	else
1780	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%s ",
1781	RuleSetNames[m->m_rh_rwset]);
1782	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "M=%ld U=%d:%d F=",
1783	m->m_maxsize, (int) m->m_uid, (int) m->m_gid);
1784	for (j = '\0'; j <= '\177'; j++)
1785	if (bitnset(j, m->m_flags))
1786	(void) sm_io_putc(smioout, SM_TIME_DEFAULT, j);
1787	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, " L=%d E=",
1788	m->m_linelimit);
1789	xputs(m->m_eol);
1790	if (m->m_defcharset != NULL)
1791	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, " C=%s",
1792	m->m_defcharset);
1793	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, " T=%s/%s/%s",
1794	m->m_mtatype == NULL
1795	? "<undefined>" : m->m_mtatype,
1796	m->m_addrtype == NULL
1797	? "<undefined>" : m->m_addrtype,
1798	m->m_diagtype == NULL
1799	? "<undefined>" : m->m_diagtype);
1800	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, " r=%d", m->m_maxrcpt);
1801	if (m->m_argv != NULL)
1802	{
1803	char **a = m->m_argv;
1804
1805	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, " A=");
1806	while (*a != NULL)
1807	{
1808	if (a != m->m_argv)
1809	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1810	" ");
1811	xputs(*a++);
1812	}
1813	}
1814	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "\n");
1815	}
1816	/*
1817	** SETOPTION -- set global processing option
1818	**
1819	** Parameters:
1820	** opt -- option name.
1821	** val -- option value (as a text string).
1822	** safe -- set if this came from a configuration file.
1823	** Some options (if set from the command line) will
1824	** reset the user id to avoid security problems.
1825	** sticky -- if set, don't let other setoptions override
1826	** this value.
1827	** e -- the main envelope.
1828	**
1829	** Returns:
1830	** none.
1831	**
1832	** Side Effects:
1833	** Sets options as implied by the arguments.
1834	*/
1835
1836	static BITMAP256 StickyOpt; /* set if option is stuck */
1837
1838	#if NAMED_BIND
1839
1840	static struct resolverflags
1841	{
1842	char rf_name; / name of the flag */
1843	long rf_bits; /* bits to set/clear */
1844	} ResolverFlags[] =
1845	{
1846	{ "debug", RES_DEBUG },
1847	{ "aaonly", RES_AAONLY },
1848	{ "usevc", RES_USEVC },
1849	{ "primary", RES_PRIMARY },
1850	{ "igntc", RES_IGNTC },
1851	{ "recurse", RES_RECURSE },
1852	{ "defnames", RES_DEFNAMES },
1853	{ "stayopen", RES_STAYOPEN },
1854	{ "dnsrch", RES_DNSRCH },
1855	# ifdef RES_USE_INET6
1856	{ "use_inet6", RES_USE_INET6 },
1857	# endif /* RES_USE_INET6 */
1858	{ "true", 0 }, /* avoid error on old syntax */
1859	{ NULL, 0 }
1860	};
1861
1862	#endif /* NAMED_BIND */
1863
1864	#define OI_NONE 0 /* no special treatment */
1865	#define OI_SAFE 0x0001 /* safe for random people to use */
1866	#define OI_SUBOPT 0x0002 /* option has suboptions */
1867
1868	static struct optioninfo
1869	{
1870	char o_name; / long name of option */
1871	unsigned char o_code; /* short name of option */
1872	unsigned short o_flags; /* option flags */
1873	} OptionTab[] =
1874	{
1875	#if defined(SUN_EXTENSIONS) && defined(REMOTE_MODE)
1876	{ "RemoteMode", '>', OI_NONE },
1877	#endif /* defined(SUN_EXTENSIONS) && defined(REMOTE_MODE) */
1878	{ "SevenBitInput", '7', OI_SAFE },
1879	{ "EightBitMode", '8', OI_SAFE },
1880	{ "AliasFile", 'A', OI_NONE },
1881	{ "AliasWait", 'a', OI_NONE },
1882	{ "BlankSub", 'B', OI_NONE },
1883	{ "MinFreeBlocks", 'b', OI_SAFE },
1884	{ "CheckpointInterval", 'C', OI_SAFE },
1885	{ "HoldExpensive", 'c', OI_NONE },
1886	{ "DeliveryMode", 'd', OI_SAFE },
1887	{ "ErrorHeader", 'E', OI_NONE },
1888	{ "ErrorMode", 'e', OI_SAFE },
1889	{ "TempFileMode", 'F', OI_NONE },
1890	{ "SaveFromLine", 'f', OI_NONE },
1891	{ "MatchGECOS", 'G', OI_NONE },
1892
1893	/* no long name, just here to avoid problems in setoption */
1894	{ "", 'g', OI_NONE },
1895	{ "HelpFile", 'H', OI_NONE },
1896	{ "MaxHopCount", 'h', OI_NONE },
1897	{ "ResolverOptions", 'I', OI_NONE },
1898	{ "IgnoreDots", 'i', OI_SAFE },
1899	{ "ForwardPath", 'J', OI_NONE },
1900	{ "SendMimeErrors", 'j', OI_SAFE },
1901	{ "ConnectionCacheSize", 'k', OI_NONE },
1902	{ "ConnectionCacheTimeout", 'K', OI_NONE },
1903	{ "UseErrorsTo", 'l', OI_NONE },
1904	{ "LogLevel", 'L', OI_SAFE },
1905	{ "MeToo", 'm', OI_SAFE },
1906
1907	/* no long name, just here to avoid problems in setoption */
1908	{ "", 'M', OI_NONE },
1909	{ "CheckAliases", 'n', OI_NONE },
1910	{ "OldStyleHeaders", 'o', OI_SAFE },
1911	{ "DaemonPortOptions", 'O', OI_NONE },
1912	{ "PrivacyOptions", 'p', OI_SAFE },
1913	{ "PostmasterCopy", 'P', OI_NONE },
1914	{ "QueueFactor", 'q', OI_NONE },
1915	{ "QueueDirectory", 'Q', OI_NONE },
1916	{ "DontPruneRoutes", 'R', OI_NONE },
1917	{ "Timeout", 'r', OI_SUBOPT },
1918	{ "StatusFile", 'S', OI_NONE },
1919	{ "SuperSafe", 's', OI_SAFE },
1920	{ "QueueTimeout", 'T', OI_NONE },
1921	{ "TimeZoneSpec", 't', OI_NONE },
1922	{ "UserDatabaseSpec", 'U', OI_NONE },
1923	{ "DefaultUser", 'u', OI_NONE },
1924	{ "FallbackMXhost", 'V', OI_NONE },
1925	{ "Verbose", 'v', OI_SAFE },
1926	{ "TryNullMXList", 'w', OI_NONE },
1927	{ "QueueLA", 'x', OI_NONE },
1928	{ "RefuseLA", 'X', OI_NONE },
1929	{ "RecipientFactor", 'y', OI_NONE },
1930	{ "ForkEachJob", 'Y', OI_NONE },
1931	{ "ClassFactor", 'z', OI_NONE },
1932	{ "RetryFactor", 'Z', OI_NONE },
1933	#define O_QUEUESORTORD 0x81
1934	{ "QueueSortOrder", O_QUEUESORTORD, OI_SAFE },
1935	#define O_HOSTSFILE 0x82
1936	{ "HostsFile", O_HOSTSFILE, OI_NONE },
1937	#define O_MQA 0x83
1938	{ "MinQueueAge", O_MQA, OI_SAFE },
1939	#define O_DEFCHARSET 0x85
1940	{ "DefaultCharSet", O_DEFCHARSET, OI_SAFE },
1941	#define O_SSFILE 0x86
1942	{ "ServiceSwitchFile", O_SSFILE, OI_NONE },
1943	#define O_DIALDELAY 0x87
1944	{ "DialDelay", O_DIALDELAY, OI_SAFE },
1945	#define O_NORCPTACTION 0x88
1946	{ "NoRecipientAction", O_NORCPTACTION, OI_SAFE },
1947	#define O_SAFEFILEENV 0x89
1948	{ "SafeFileEnvironment", O_SAFEFILEENV, OI_NONE },
1949	#define O_MAXMSGSIZE 0x8a
1950	{ "MaxMessageSize", O_MAXMSGSIZE, OI_NONE },
1951	#define O_COLONOKINADDR 0x8b
1952	{ "ColonOkInAddr", O_COLONOKINADDR, OI_SAFE },
1953	#define O_MAXQUEUERUN 0x8c
1954	{ "MaxQueueRunSize", O_MAXQUEUERUN, OI_SAFE },
1955	#define O_MAXCHILDREN 0x8d
1956	{ "MaxDaemonChildren", O_MAXCHILDREN, OI_NONE },
1957	#define O_KEEPCNAMES 0x8e
1958	{ "DontExpandCnames", O_KEEPCNAMES, OI_NONE },
1959	#define O_MUSTQUOTE 0x8f
1960	{ "MustQuoteChars", O_MUSTQUOTE, OI_NONE },
1961	#define O_SMTPGREETING 0x90
1962	{ "SmtpGreetingMessage", O_SMTPGREETING, OI_NONE },
1963	#define O_UNIXFROM 0x91
1964	{ "UnixFromLine", O_UNIXFROM, OI_NONE },
1965	#define O_OPCHARS 0x92
1966	{ "OperatorChars", O_OPCHARS, OI_NONE },
1967	#define O_DONTINITGRPS 0x93
1968	{ "DontInitGroups", O_DONTINITGRPS, OI_NONE },
1969	#define O_SLFH 0x94
1970	{ "SingleLineFromHeader", O_SLFH, OI_SAFE },
1971	#define O_ABH 0x95
1972	{ "AllowBogusHELO", O_ABH, OI_SAFE },
1973	#define O_CONNTHROT 0x97
1974	{ "ConnectionRateThrottle", O_CONNTHROT, OI_NONE },
1975	#define O_UGW 0x99
1976	{ "UnsafeGroupWrites", O_UGW, OI_NONE },
1977	#define O_DBLBOUNCE 0x9a
1978	{ "DoubleBounceAddress", O_DBLBOUNCE, OI_NONE },
1979	#define O_HSDIR 0x9b
1980	{ "HostStatusDirectory", O_HSDIR, OI_NONE },
1981	#define O_SINGTHREAD 0x9c
1982	{ "SingleThreadDelivery", O_SINGTHREAD, OI_NONE },
1983	#define O_RUNASUSER 0x9d
1984	{ "RunAsUser", O_RUNASUSER, OI_NONE },
1985	#define O_DSN_RRT 0x9e
1986	{ "RrtImpliesDsn", O_DSN_RRT, OI_NONE },
1987	#define O_PIDFILE 0x9f
1988	{ "PidFile", O_PIDFILE, OI_NONE },
1989	#define O_DONTBLAMESENDMAIL 0xa0
1990	{ "DontBlameSendmail", O_DONTBLAMESENDMAIL, OI_NONE },
1991	#define O_DPI 0xa1
1992	{ "DontProbeInterfaces", O_DPI, OI_NONE },
1993	#define O_MAXRCPT 0xa2
1994	{ "MaxRecipientsPerMessage", O_MAXRCPT, OI_SAFE },
1995	#define O_DEADLETTER 0xa3
1996	{ "DeadLetterDrop", O_DEADLETTER, OI_NONE },
1997	#if _FFR_DONTLOCKFILESFORREAD_OPTION
1998	# define O_DONTLOCK 0xa4
1999	{ "DontLockFilesForRead", O_DONTLOCK, OI_NONE },
2000	#endif /* _FFR_DONTLOCKFILESFORREAD_OPTION */
2001	#define O_MAXALIASRCSN 0xa5
2002	{ "MaxAliasRecursion", O_MAXALIASRCSN, OI_NONE },
2003	#define O_CNCTONLYTO 0xa6
2004	{ "ConnectOnlyTo", O_CNCTONLYTO, OI_NONE },
2005	#define O_TRUSTUSER 0xa7
2006	{ "TrustedUser", O_TRUSTUSER, OI_NONE },
2007	#define O_MAXMIMEHDRLEN 0xa8
2008	{ "MaxMimeHeaderLength", O_MAXMIMEHDRLEN, OI_NONE },
2009	#define O_CONTROLSOCKET 0xa9
2010	{ "ControlSocketName", O_CONTROLSOCKET, OI_NONE },
2011	#define O_MAXHDRSLEN 0xaa
2012	{ "MaxHeadersLength", O_MAXHDRSLEN, OI_NONE },
2013	#if _FFR_MAX_FORWARD_ENTRIES
2014	# define O_MAXFORWARD 0xab
2015	{ "MaxForwardEntries", O_MAXFORWARD, OI_NONE },
2016	#endif /* _FFR_MAX_FORWARD_ENTRIES */
2017	#define O_PROCTITLEPREFIX 0xac
2018	{ "ProcessTitlePrefix", O_PROCTITLEPREFIX, OI_NONE },
2019	#define O_SASLINFO 0xad
2020	#if _FFR_ALLOW_SASLINFO
2021	{ "DefaultAuthInfo", O_SASLINFO, OI_SAFE },
2022	#else /* _FFR_ALLOW_SASLINFO */
2023	{ "DefaultAuthInfo", O_SASLINFO, OI_NONE },
2024	#endif /* _FFR_ALLOW_SASLINFO */
2025	#define O_SASLMECH 0xae
2026	{ "AuthMechanisms", O_SASLMECH, OI_NONE },
2027	#define O_CLIENTPORT 0xaf
2028	{ "ClientPortOptions", O_CLIENTPORT, OI_NONE },
2029	#define O_DF_BUFSIZE 0xb0
2030	{ "DataFileBufferSize", O_DF_BUFSIZE, OI_NONE },
2031	#define O_XF_BUFSIZE 0xb1
2032	{ "XscriptFileBufferSize", O_XF_BUFSIZE, OI_NONE },
2033	#define O_LDAPDEFAULTSPEC 0xb2
2034	{ "LDAPDefaultSpec", O_LDAPDEFAULTSPEC, OI_NONE },
2035	#if _FFR_QUEUEDELAY
2036	# define O_QUEUEDELAY 0xb3
2037	{ "QueueDelay", O_QUEUEDELAY, OI_NONE },
2038	#endif /* _FFR_QUEUEDELAY */
2039	#define O_SRVCERTFILE 0xb4
2040	{ "ServerCertFile", O_SRVCERTFILE, OI_NONE },
2041	#define O_SRVKEYFILE 0xb5
2042	{ "ServerKeyFile", O_SRVKEYFILE, OI_NONE },
2043	#define O_CLTCERTFILE 0xb6
2044	{ "ClientCertFile", O_CLTCERTFILE, OI_NONE },
2045	#define O_CLTKEYFILE 0xb7
2046	{ "ClientKeyFile", O_CLTKEYFILE, OI_NONE },
2047	#define O_CACERTFILE 0xb8
2048	{ "CACertFile", O_CACERTFILE, OI_NONE },
2049	#define O_CACERTPATH 0xb9
2050	{ "CACertPath", O_CACERTPATH, OI_NONE },
2051	#define O_DHPARAMS 0xba
2052	{ "DHParameters", O_DHPARAMS, OI_NONE },
2053	#define O_INPUTMILTER 0xbb
2054	{ "InputMailFilters", O_INPUTMILTER, OI_NONE },
2055	#define O_MILTER 0xbc
2056	{ "Milter", O_MILTER, OI_SUBOPT },
2057	#define O_SASLOPTS 0xbd
2058	{ "AuthOptions", O_SASLOPTS, OI_NONE },
2059	#define O_QUEUE_FILE_MODE 0xbe
2060	{ "QueueFileMode", O_QUEUE_FILE_MODE, OI_NONE },
2061	#if _FFR_TLS_1
2062	# define O_DHPARAMS5 0xbf
2063	{ "DHParameters512", O_DHPARAMS5, OI_NONE },
2064	# define O_CIPHERLIST 0xc0
2065	{ "CipherList", O_CIPHERLIST, OI_NONE },
2066	#endif /* _FFR_TLS_1 */
2067	#define O_RANDFILE 0xc1
2068	{ "RandFile", O_RANDFILE, OI_NONE },
2069	#define O_TLS_SRV_OPTS 0xc2
2070	{ "TLSSrvOptions", O_TLS_SRV_OPTS, OI_NONE },
2071	#define O_RCPTTHROT 0xc3
2072	{ "BadRcptThrottle", O_RCPTTHROT, OI_SAFE },
2073	#define O_DLVR_MIN 0xc4
2074	{ "DeliverByMin", O_DLVR_MIN, OI_NONE },
2075	#define O_MAXQUEUECHILDREN 0xc5
2076	{ "MaxQueueChildren", O_MAXQUEUECHILDREN, OI_NONE },
2077	#define O_MAXRUNNERSPERQUEUE 0xc6
2078	{ "MaxRunnersPerQueue", O_MAXRUNNERSPERQUEUE, OI_NONE },
2079	#define O_DIRECTSUBMODIFIERS 0xc7
2080	{ "DirectSubmissionModifiers", O_DIRECTSUBMODIFIERS, OI_NONE },
2081	#define O_NICEQUEUERUN 0xc8
2082	{ "NiceQueueRun", O_NICEQUEUERUN, OI_NONE },
2083	#define O_SHMKEY 0xc9
2084	{ "SharedMemoryKey", O_SHMKEY, OI_NONE },
2085	#define O_SASLBITS 0xca
2086	{ "AuthMaxBits", O_SASLBITS, OI_NONE },
2087	#define O_MBDB 0xcb
2088	{ "MailboxDatabase", O_MBDB, OI_NONE },
2089	#define O_MSQ 0xcc
2090	{ "UseMSP", O_MSQ, OI_NONE },
2091	#define O_DELAY_LA 0xcd
2092	{ "DelayLA", O_DELAY_LA, OI_NONE },
2093	#define O_FASTSPLIT 0xce
2094	{ "FastSplit", O_FASTSPLIT, OI_NONE },
2095	#if _FFR_SOFT_BOUNCE
2096	# define O_SOFTBOUNCE 0xcf
2097	{ "SoftBounce", O_SOFTBOUNCE, OI_NONE },
2098	#endif /* _FFR_SOFT_BOUNCE */
2099	#if _FFR_SELECT_SHM
2100	# define O_SHMKEYFILE 0xd0
2101	{ "SharedMemoryKeyFile", O_SHMKEYFILE, OI_NONE },
2102	#endif /* _FFR_SELECT_SHM */
2103	#if _FFR_REJECT_LOG
2104	# define O_REJECTLOGINTERVAL 0xd1
2105	{ "RejectLogInterval", O_REJECTLOGINTERVAL, OI_NONE },
2106	#endif /* _FFR_REJECT_LOG */
2107	#if _FFR_REQ_DIR_FSYNC_OPT
2108	# define O_REQUIRES_DIR_FSYNC 0xd2
2109	{ "RequiresDirfsync", O_REQUIRES_DIR_FSYNC, OI_NONE },
2110	#endif /* _FFR_REQ_DIR_FSYNC_OPT */
2111	{ NULL, '\0', OI_NONE }
2112	};
2113
2114	# define CANONIFY(val)
2115
2116	# define SET_OPT_DEFAULT(opt, val) opt = val
2117
2118	/* set a string option by expanding the value and assigning it */
2119	/* WARNING this belongs ONLY into a case statement! */
2120	#define SET_STRING_EXP(str) \
2121	expand(val, exbuf, sizeof exbuf, e); \
2122	newval = sm_pstrdup_x(exbuf); \
2123	if (str != NULL) \
2124	sm_free(str); \
2125	CANONIFY(newval); \
2126	str = newval; \
2127	break
2128
2129	#define OPTNAME o->o_name == NULL ? "<unknown>" : o->o_name
2130
2131	void
2132	setoption(opt, val, safe, sticky, e)
2133	int opt;
2134	char *val;
2135	bool safe;
2136	bool sticky;
2137	register ENVELOPE *e;
2138	{
2139	register char *p;
2140	register struct optioninfo *o;
2141	char *subopt;
2142	int mid;
2143	bool can_setuid = RunAsUid == 0;
2144	auto char *ep;
2145	char buf[50];
2146	extern bool Warn_Q_option;
2147	#if _FFR_ALLOW_SASLINFO
2148	extern unsigned int SubmitMode;
2149	#endif /* _FFR_ALLOW_SASLINFO */
2150	#if STARTTLS
2151	char *newval;
2152	char exbuf[MAXLINE];
2153	#endif /* STARTTLS */
2154
2155	errno = 0;
2156	if (opt == ' ')
2157	{
2158	/* full word options */
2159	struct optioninfo *sel;
2160
2161	p = strchr(val, '=');
2162	if (p == NULL)
2163	p = &val[strlen(val)];
2164	while (*--p == ' ')
2165	continue;
2166	while (*++p == ' ')
2167	*p = '\0';
2168	if (p == val)
2169	{
2170	syserr("readcf: null option name");
2171	return;
2172	}
2173	if (*p == '=')
2174	*p++ = '\0';
2175	while (*p == ' ')
2176	p++;
2177	subopt = strchr(val, '.');
2178	if (subopt != NULL)
2179	*subopt++ = '\0';
2180	sel = NULL;
2181	for (o = OptionTab; o->o_name != NULL; o++)
2182	{
2183	if (sm_strncasecmp(o->o_name, val, strlen(val)) != 0)
2184	continue;
2185	if (strlen(o->o_name) == strlen(val))
2186	{
2187	/* completely specified -- this must be it */
2188	sel = NULL;
2189	break;
2190	}
2191	if (sel != NULL)
2192	break;
2193	sel = o;
2194	}
2195	if (sel != NULL && o->o_name == NULL)
2196	o = sel;
2197	else if (o->o_name == NULL)
2198	{
2199	syserr("readcf: unknown option name %s", val);
2200	return;
2201	}
2202	else if (sel != NULL)
2203	{
2204	syserr("readcf: ambiguous option name %s (matches %s and %s)",
2205	val, sel->o_name, o->o_name);
2206	return;
2207	}
2208	if (strlen(val) != strlen(o->o_name))
2209	{
2210	int oldVerbose = Verbose;
2211
2212	Verbose = 1;
2213	message("Option %s used as abbreviation for %s",
2214	val, o->o_name);
2215	Verbose = oldVerbose;
2216	}
2217	opt = o->o_code;
2218	val = p;
2219	}
2220	else
2221	{
2222	for (o = OptionTab; o->o_name != NULL; o++)
2223	{
2224	if (o->o_code == opt)
2225	break;
2226	}
2227	if (o->o_name == NULL)
2228	{
2229	syserr("readcf: unknown option name 0x%x", opt & 0xff);
2230	return;
2231	}
2232	subopt = NULL;
2233	}
2234
2235	if (subopt != NULL && !bitset(OI_SUBOPT, o->o_flags))
2236	{
2237	if (tTd(37, 1))
2238	sm_dprintf("setoption: %s does not support suboptions, ignoring .%s\n",
2239	OPTNAME, subopt);
2240	subopt = NULL;
2241	}
2242
2243	if (tTd(37, 1))
2244	{
2245	sm_dprintf(isascii(opt) && isprint(opt) ?
2246	"setoption %s (%c)%s%s=" :
2247	"setoption %s (0x%x)%s%s=",
2248	OPTNAME, opt, subopt == NULL ? "" : ".",
2249	subopt == NULL ? "" : subopt);
2250	xputs(val);
2251	}
2252
2253	/*
2254	** See if this option is preset for us.
2255	*/
2256
2257	if (!sticky && bitnset(opt, StickyOpt))
2258	{
2259	if (tTd(37, 1))
2260	sm_dprintf(" (ignored)\n");
2261	return;
2262	}
2263
2264	/*
2265	** Check to see if this option can be specified by this user.
2266	*/
2267
2268	if (!safe && RealUid == 0)
2269	safe = true;
2270	if (!safe && !bitset(OI_SAFE, o->o_flags))
2271	{
2272	if (opt != 'M' \|\| (val[0] != 'r' && val[0] != 's'))
2273	{
2274	int dp;
2275
2276	if (tTd(37, 1))
2277	sm_dprintf(" (unsafe)");
2278	dp = drop_privileges(true);
2279	setstat(dp);
2280	}
2281	}
2282	if (tTd(37, 1))
2283	sm_dprintf("\n");
2284
2285	switch (opt & 0xff)
2286	{
2287	case '7': /* force seven-bit input */
2288	SevenBitInput = atobool(val);
2289	break;
2290
2291	case '8': /* handling of 8-bit input */
2292	#if MIME8TO7
2293	switch (*val)
2294	{
2295	case 'p': /* pass 8 bit, convert MIME */
2296	MimeMode = MM_CVTMIME\|MM_PASS8BIT;
2297	break;
2298
2299	case 'm': /* convert 8-bit, convert MIME */
2300	MimeMode = MM_CVTMIME\|MM_MIME8BIT;
2301	break;
2302
2303	case 's': /* strict adherence */
2304	MimeMode = MM_CVTMIME;
2305	break;
2306
2307	# if 0
2308	case 'r': /* reject 8-bit, don't convert MIME */
2309	MimeMode = 0;
2310	break;
2311
2312	case 'j': /* "just send 8" */
2313	MimeMode = MM_PASS8BIT;
2314	break;
2315
2316	case 'a': /* encode 8 bit if available */
2317	MimeMode = MM_MIME8BIT\|MM_PASS8BIT\|MM_CVTMIME;
2318	break;
2319
2320	case 'c': /* convert 8 bit to MIME, never 7 bit */
2321	MimeMode = MM_MIME8BIT;
2322	break;
2323	# endif /* 0 */
2324
2325	default:
2326	syserr("Unknown 8-bit mode %c", *val);
2327	finis(false, true, EX_USAGE);
2328	}
2329	#else /* MIME8TO7 */
2330	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
2331	"Warning: Option: %s requires MIME8TO7 support\n",
2332	OPTNAME);
2333	#endif /* MIME8TO7 */
2334	break;
2335
2336	case 'A': /* set default alias file */
2337	if (val[0] == '\0')
2338	{
2339	char *al;
2340
2341	SET_OPT_DEFAULT(al, "aliases");
2342	setalias(al);
2343	}
2344	else
2345	setalias(val);
2346	break;
2347
2348	case 'a': /* look N minutes for "@:@" in alias file */
2349	if (val[0] == '\0')
2350	SafeAlias = 5 MINUTES;
2351	else
2352	SafeAlias = convtime(val, 'm');
2353	break;
2354
2355	case 'B': /* substitution for blank character */
2356	SpaceSub = val[0];
2357	if (SpaceSub == '\0')
2358	SpaceSub = ' ';
2359	break;
2360
2361	case 'b': /* min blocks free on queue fs/max msg size */
2362	p = strchr(val, '/');
2363	if (p != NULL)
2364	{
2365	*p++ = '\0';
2366	MaxMessageSize = atol(p);
2367	}
2368	MinBlocksFree = atol(val);
2369	break;
2370
2371	case 'c': /* don't connect to "expensive" mailers */
2372	NoConnect = atobool(val);
2373	break;
2374
2375	case 'C': /* checkpoint every N addresses */
2376	CheckpointInterval = atoi(val);
2377	break;
2378
2379	case 'd': /* delivery mode */
2380	switch (*val)
2381	{
2382	case '\0':
2383	set_delivery_mode(SM_DELIVER, e);
2384	break;
2385
2386	case SM_QUEUE: /* queue only */
2387	case SM_DEFER: /* queue only and defer map lookups */
2388	case SM_DELIVER: /* do everything */
2389	case SM_FORK: /* fork after verification */
2390	set_delivery_mode(*val, e);
2391	break;
2392
2393	default:
2394	syserr("Unknown delivery mode %c", *val);
2395	finis(false, true, EX_USAGE);
2396	}
2397	break;
2398
2399	case 'E': /* error message header/header file */
2400	if (*val != '\0')
2401	ErrMsgFile = newstr(val);
2402	break;
2403
2404	case 'e': /* set error processing mode */
2405	switch (*val)
2406	{
2407	case EM_QUIET: /* be silent about it */
2408	case EM_MAIL: /* mail back */
2409	case EM_BERKNET: /* do berknet error processing */
2410	case EM_WRITE: /* write back (or mail) */
2411	case EM_PRINT: /* print errors normally (default) */
2412	e->e_errormode = *val;
2413	break;
2414	}
2415	break;
2416
2417	case 'F': /* file mode */
2418	FileMode = atooct(val) & 0777;
2419	break;
2420
2421	case 'f': /* save Unix-style From lines on front */
2422	SaveFrom = atobool(val);
2423	break;
2424
2425	case 'G': /* match recipients against GECOS field */
2426	MatchGecos = atobool(val);
2427	break;
2428
2429	case 'g': /* default gid */
2430	g_opt:
2431	if (isascii(val) && isdigit(val))
2432	DefGid = atoi(val);
2433	else
2434	{
2435	register struct group *gr;
2436
2437	DefGid = -1;
2438	gr = getgrnam(val);
2439	if (gr == NULL)
2440	syserr("readcf: option %c: unknown group %s",
2441	opt, val);
2442	else
2443	DefGid = gr->gr_gid;
2444	}
2445	break;
2446
2447	case 'H': /* help file */
2448	if (val[0] == '\0')
2449	{
2450	SET_OPT_DEFAULT(HelpFile, "helpfile");
2451	}
2452	else
2453	{
2454	CANONIFY(val);
2455	HelpFile = newstr(val);
2456	}
2457	break;
2458
2459	case 'h': /* maximum hop count */
2460	MaxHopCount = atoi(val);
2461	break;
2462
2463	case 'I': /* use internet domain name server */
2464	#if NAMED_BIND
2465	for (p = val; *p != 0; )
2466	{
2467	bool clearmode;
2468	char *q;
2469	struct resolverflags *rfp;
2470
2471	while (*p == ' ')
2472	p++;
2473	if (*p == '\0')
2474	break;
2475	clearmode = false;
2476	if (*p == '-')
2477	clearmode = true;
2478	else if (*p != '+')
2479	p--;
2480	p++;
2481	q = p;
2482	while (p != '\0' && !(isascii(p) && isspace(*p)))
2483	p++;
2484	if (*p != '\0')
2485	*p++ = '\0';
2486	if (sm_strcasecmp(q, "HasWildcardMX") == 0)
2487	{
2488	HasWildcardMX = !clearmode;
2489	continue;
2490	}
2491	if (sm_strcasecmp(q, "WorkAroundBrokenAAAA") == 0)
2492	{
2493	WorkAroundBrokenAAAA = !clearmode;
2494	continue;
2495	}
2496	for (rfp = ResolverFlags; rfp->rf_name != NULL; rfp++)
2497	{
2498	if (sm_strcasecmp(q, rfp->rf_name) == 0)
2499	break;
2500	}
2501	if (rfp->rf_name == NULL)
2502	syserr("readcf: I option value %s unrecognized", q);
2503	else if (clearmode)
2504	_res.options &= ~rfp->rf_bits;
2505	else
2506	_res.options \|= rfp->rf_bits;
2507	}
2508	if (tTd(8, 2))
2509	sm_dprintf("_res.options = %x, HasWildcardMX = %d\n",
2510	(unsigned int) _res.options, HasWildcardMX);
2511	#else /* NAMED_BIND */
2512	usrerr("name server (I option) specified but BIND not compiled in");
2513	#endif /* NAMED_BIND */
2514	break;
2515
2516	case 'i': /* ignore dot lines in message */
2517	IgnrDot = atobool(val);
2518	break;
2519
2520	case 'j': /* send errors in MIME (RFC 1341) format */
2521	SendMIMEErrors = atobool(val);
2522	break;
2523
2524	case 'J': /* .forward search path */
2525	CANONIFY(val);
2526	ForwardPath = newstr(val);
2527	break;
2528
2529	case 'k': /* connection cache size */
2530	MaxMciCache = atoi(val);
2531	if (MaxMciCache < 0)
2532	MaxMciCache = 0;
2533	break;
2534
2535	case 'K': /* connection cache timeout */
2536	MciCacheTimeout = convtime(val, 'm');
2537	break;
2538
2539	case 'l': /* use Errors-To: header */
2540	UseErrorsTo = atobool(val);
2541	break;
2542
2543	case 'L': /* log level */
2544	if (safe \|\| LogLevel < atoi(val))
2545	LogLevel = atoi(val);
2546	break;
2547
2548	case 'M': /* define macro */
2549	sticky = false;
2550	mid = macid_parse(val, &ep);
2551	if (mid == 0)
2552	break;
2553	p = newstr(ep);
2554	if (!safe)
2555	cleanstrcpy(p, p, MAXNAME);
2556	macdefine(&CurEnv->e_macro, A_TEMP, mid, p);
2557	break;
2558
2559	case 'm': /* send to me too */
2560	MeToo = atobool(val);
2561	break;
2562
2563	case 'n': /* validate RHS in newaliases */
2564	CheckAliases = atobool(val);
2565	break;
2566
2567	/* 'N' available -- was "net name" */
2568
2569	case 'O': /* daemon options */
2570	if (!setdaemonoptions(val))
2571	syserr("too many daemons defined (%d max)", MAXDAEMONS);
2572	break;
2573
2574	case 'o': /* assume old style headers */
2575	if (atobool(val))
2576	CurEnv->e_flags \|= EF_OLDSTYLE;
2577	else
2578	CurEnv->e_flags &= ~EF_OLDSTYLE;
2579	break;
2580
2581	case 'p': /* select privacy level */
2582	p = val;
2583	for (;;)
2584	{
2585	register struct prival *pv;
2586	extern struct prival PrivacyValues[];
2587
2588	while (isascii(p) && (isspace(p) \|\| ispunct(*p)))
2589	p++;
2590	if (*p == '\0')
2591	break;
2592	val = p;
2593	while (isascii(p) && isalnum(p))
2594	p++;
2595	if (*p != '\0')
2596	*p++ = '\0';
2597
2598	for (pv = PrivacyValues; pv->pv_name != NULL; pv++)
2599	{
2600	if (sm_strcasecmp(val, pv->pv_name) == 0)
2601	break;
2602	}
2603	if (pv->pv_name == NULL)
2604	syserr("readcf: Op line: %s unrecognized", val);
2605	else
2606	PrivacyFlags \|= pv->pv_flag;
2607	}
2608	sticky = false;
2609	break;
2610
2611	case 'P': /* postmaster copy address for returned mail */
2612	PostMasterCopy = newstr(val);
2613	break;
2614
2615	case 'q': /* slope of queue only function */
2616	QueueFactor = atoi(val);
2617	break;
2618
2619	case 'Q': /* queue directory */
2620	if (val[0] == '\0')
2621	{
2622	QueueDir = "mqueue";
2623	}
2624	else
2625	{
2626	QueueDir = newstr(val);
2627	}
2628	if (RealUid != 0 && !safe)
2629	Warn_Q_option = true;
2630	break;
2631
2632	case 'R': /* don't prune routes */
2633	DontPruneRoutes = atobool(val);
2634	break;
2635
2636	case 'r': /* read timeout */
2637	if (subopt == NULL)
2638	inittimeouts(val, sticky);
2639	else
2640	settimeout(subopt, val, sticky);
2641	break;
2642
2643	case 'S': /* status file */
2644	if (val[0] == '\0')
2645	{
2646	SET_OPT_DEFAULT(StatFile, "statistics");
2647	}
2648	else
2649	{
2650	CANONIFY(val);
2651	StatFile = newstr(val);
2652	}
2653	break;
2654
2655	case 's': /* be super safe, even if expensive */
2656	if (tolower(*val) == 'i')
2657	SuperSafe = SAFE_INTERACTIVE;
2658	else
2659	SuperSafe = atobool(val) ? SAFE_REALLY : SAFE_NO;
2660	break;
2661
2662	case 'T': /* queue timeout */
2663	p = strchr(val, '/');
2664	if (p != NULL)
2665	{
2666	*p++ = '\0';
2667	settimeout("queuewarn", p, sticky);
2668	}
2669	settimeout("queuereturn", val, sticky);
2670	break;
2671
2672	case 't': /* time zone name */
2673	TimeZoneSpec = newstr(val);
2674	break;
2675
2676	case 'U': /* location of user database */
2677	UdbSpec = newstr(val);
2678	break;
2679
2680	case 'u': /* set default uid */
2681	for (p = val; *p != '\0'; p++)
2682	{
2683	# if _FFR_DOTTED_USERNAMES
2684	if (p == '/' \|\| p == ':')
2685	# else /* _FFR_DOTTED_USERNAMES */
2686	if (p == '.' \|\| p == '/' \|\| *p == ':')
2687	# endif /* _FFR_DOTTED_USERNAMES */
2688	{
2689	*p++ = '\0';
2690	break;
2691	}
2692	}
2693	if (isascii(val) && isdigit(val))
2694	{
2695	DefUid = atoi(val);
2696	setdefuser();
2697	}
2698	else
2699	{
2700	register struct passwd *pw;
2701
2702	DefUid = -1;
2703	pw = sm_getpwnam(val);
2704	if (pw == NULL)
2705	{
2706	syserr("readcf: option u: unknown user %s", val);
2707	break;
2708	}
2709	else
2710	{
2711	DefUid = pw->pw_uid;
2712	DefGid = pw->pw_gid;
2713	DefUser = newstr(pw->pw_name);
2714	}
2715	}
2716
2717	# ifdef UID_MAX
2718	if (DefUid > UID_MAX)
2719	{
2720	syserr("readcf: option u: uid value (%ld) > UID_MAX (%ld); ignored",
2721	(long)DefUid, (long)UID_MAX);
2722	break;
2723	}
2724	# endif /* UID_MAX */
2725
2726	/* handle the group if it is there */
2727	if (*p == '\0')
2728	break;
2729	val = p;
2730	goto g_opt;
2731
2732	case 'V': /* fallback MX host */
2733	if (val[0] != '\0')
2734	FallBackMX = newstr(val);
2735	break;
2736
2737	case 'v': /* run in verbose mode */
2738	Verbose = atobool(val) ? 1 : 0;
2739	break;
2740
2741	case 'w': /* if we are best MX, try host directly */
2742	TryNullMXList = atobool(val);
2743	break;
2744
2745	/* 'W' available -- was wizard password */
2746
2747	case 'x': /* load avg at which to auto-queue msgs */
2748	QueueLA = atoi(val);
2749	break;
2750
2751	case 'X': /* load avg at which to auto-reject connections */
2752	RefuseLA = atoi(val);
2753	break;
2754
2755	case O_DELAY_LA: /* load avg at which to delay connections */
2756	DelayLA = atoi(val);
2757	break;
2758
2759	case 'y': /* work recipient factor */
2760	WkRecipFact = atoi(val);
2761	break;
2762
2763	case 'Y': /* fork jobs during queue runs */
2764	ForkQueueRuns = atobool(val);
2765	break;
2766
2767	case 'z': /* work message class factor */
2768	WkClassFact = atoi(val);
2769	break;
2770
2771	case 'Z': /* work time factor */
2772	WkTimeFact = atoi(val);
2773	break;
2774
2775
2776	#if _FFR_QUEUE_GROUP_SORTORDER
2777	/* coordinate this with makequeue() */
2778	#endif /* _FFR_QUEUE_GROUP_SORTORDER */
2779	case O_QUEUESORTORD: /* queue sorting order */
2780	switch (*val)
2781	{
2782	case 'f': /* File Name */
2783	case 'F':
2784	QueueSortOrder = QSO_BYFILENAME;
2785	break;
2786
2787	case 'h': /* Host first */
2788	case 'H':
2789	QueueSortOrder = QSO_BYHOST;
2790	break;
2791
2792	case 'm': /* Modification time */
2793	case 'M':
2794	QueueSortOrder = QSO_BYMODTIME;
2795	break;
2796
2797	case 'p': /* Priority order */
2798	case 'P':
2799	QueueSortOrder = QSO_BYPRIORITY;
2800	break;
2801
2802	case 't': /* Submission time */
2803	case 'T':
2804	QueueSortOrder = QSO_BYTIME;
2805	break;
2806
2807	case 'r': /* Random */
2808	case 'R':
2809	QueueSortOrder = QSO_RANDOM;
2810	break;
2811
2812	#if _FFR_RHS
2813	case 's': /* Shuffled host name */
2814	case 'S':
2815	QueueSortOrder = QSO_BYSHUFFLE;
2816	break;
2817	#endif /* _FFR_RHS */
2818
2819	default:
2820	syserr("Invalid queue sort order \"%s\"", val);
2821	}
2822	break;
2823
2824	#if _FFR_QUEUEDELAY
2825	case O_QUEUEDELAY: /* queue delay algorithm */
2826	switch (*val)
2827	{
2828	case 'e': /* exponential */
2829	case 'E':
2830	QueueAlg = QD_EXP;
2831	QueueInitDelay = 10 MINUTES;
2832	QueueMaxDelay = 2 HOURS;
2833	p = strchr(val, '/');
2834	if (p != NULL)
2835	{
2836	char *q;
2837
2838	*p++ = '\0';
2839	q = strchr(p, '/');
2840	if (q != NULL)
2841	*q++ = '\0';
2842	QueueInitDelay = convtime(p, 's');
2843	if (q != NULL)
2844	{
2845	QueueMaxDelay = convtime(q, 's');
2846	}
2847	}
2848	break;
2849
2850	case 'l': /* linear */
2851	case 'L':
2852	QueueAlg = QD_LINEAR;
2853	break;
2854
2855	default:
2856	syserr("Invalid queue delay algorithm \"%s\"", val);
2857	}
2858	break;
2859	#endif /* _FFR_QUEUEDELAY */
2860
2861	case O_HOSTSFILE: /* pathname of /etc/hosts file */
2862	CANONIFY(val);
2863	HostsFile = newstr(val);
2864	break;
2865
2866	case O_MQA: /* minimum queue age between deliveries */
2867	MinQueueAge = convtime(val, 'm');
2868	break;
2869
2870	case O_DEFCHARSET: /* default character set for mimefying */
2871	DefaultCharSet = newstr(denlstring(val, true, true));
2872	break;
2873
2874	case O_SSFILE: /* service switch file */
2875	CANONIFY(val);
2876	ServiceSwitchFile = newstr(val);
2877	break;
2878
2879	case O_DIALDELAY: /* delay for dial-on-demand operation */
2880	DialDelay = convtime(val, 's');
2881	break;
2882
2883	case O_NORCPTACTION: /* what to do if no recipient */
2884	if (sm_strcasecmp(val, "none") == 0)
2885	NoRecipientAction = NRA_NO_ACTION;
2886	else if (sm_strcasecmp(val, "add-to") == 0)
2887	NoRecipientAction = NRA_ADD_TO;
2888	else if (sm_strcasecmp(val, "add-apparently-to") == 0)
2889	NoRecipientAction = NRA_ADD_APPARENTLY_TO;
2890	else if (sm_strcasecmp(val, "add-bcc") == 0)
2891	NoRecipientAction = NRA_ADD_BCC;
2892	else if (sm_strcasecmp(val, "add-to-undisclosed") == 0)
2893	NoRecipientAction = NRA_ADD_TO_UNDISCLOSED;
2894	else
2895	syserr("Invalid NoRecipientAction: %s", val);
2896	break;
2897
2898	case O_SAFEFILEENV: /* chroot() environ for writing to files */
2899	if (*val == '\0')
2900	break;
2901
2902	/* strip trailing slashes */
2903	p = val + strlen(val) - 1;
2904	while (p >= val && *p == '/')
2905	*p-- = '\0';
2906
2907	if (*val == '\0')
2908	break;
2909
2910	SafeFileEnv = newstr(val);
2911	break;
2912
2913	case O_MAXMSGSIZE: /* maximum message size */
2914	MaxMessageSize = atol(val);
2915	break;
2916
2917	case O_COLONOKINADDR: /* old style handling of colon addresses */
2918	ColonOkInAddr = atobool(val);
2919	break;
2920
2921	case O_MAXQUEUERUN: /* max # of jobs in a single queue run */
2922	MaxQueueRun = atoi(val);
2923	break;
2924
2925	case O_MAXCHILDREN: /* max # of children of daemon */
2926	MaxChildren = atoi(val);
2927	break;
2928
2929	case O_MAXQUEUECHILDREN: /* max # of children of daemon */
2930	MaxQueueChildren = atoi(val);
2931	break;
2932
2933	case O_MAXRUNNERSPERQUEUE: /* max # runners in a queue group */
2934	MaxRunnersPerQueue = atoi(val);
2935	break;
2936
2937	case O_NICEQUEUERUN: /* nice queue runs */
2938	#if !HASNICE
2939	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
2940	"Warning: NiceQueueRun set on system that doesn't support nice()\n");
2941	#endif /* !HASNICE */
2942
2943	/* XXX do we want to check the range? > 0 ? */
2944	NiceQueueRun = atoi(val);
2945	break;
2946
2947	case O_SHMKEY: /* shared memory key */
2948	#if SM_CONF_SHM
2949	ShmKey = atol(val);
2950	#else /* SM_CONF_SHM */
2951	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
2952	"Warning: Option: %s requires shared memory support (-DSM_CONF_SHM)\n",
2953	OPTNAME);
2954	#endif /* SM_CONF_SHM */
2955	break;
2956
2957	#if _FFR_SELECT_SHM
2958	case O_SHMKEYFILE: /* shared memory key file */
2959	# if SM_CONF_SHM
2960	SET_STRING_EXP(ShmKeyFile);
2961	# else /* SM_CONF_SHM */
2962	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
2963	"Warning: Option: %s requires shared memory support (-DSM_CONF_SHM)\n",
2964	OPTNAME);
2965	break;
2966	# endif /* SM_CONF_SHM */
2967	#endif /* _FFR_SELECT_SHM */
2968
2969	#if _FFR_MAX_FORWARD_ENTRIES
2970	case O_MAXFORWARD: /* max # of forward entries */
2971	MaxForwardEntries = atoi(val);
2972	break;
2973	#endif /* _FFR_MAX_FORWARD_ENTRIES */
2974
2975	case O_KEEPCNAMES: /* don't expand CNAME records */
2976	DontExpandCnames = atobool(val);
2977	break;
2978
2979	case O_MUSTQUOTE: /* must quote these characters in phrases */
2980	(void) sm_strlcpy(buf, "@,;:\\()[]", sizeof buf);
2981	if (strlen(val) < sizeof buf - 10)
2982	(void) sm_strlcat(buf, val, sizeof buf);
2983	else
2984	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
2985	"Warning: MustQuoteChars too long, ignored.\n");
2986	MustQuoteChars = newstr(buf);
2987	break;
2988
2989	case O_SMTPGREETING: /* SMTP greeting message (old $e macro) */
2990	SmtpGreeting = newstr(munchstring(val, NULL, '\0'));
2991	break;
2992
2993	case O_UNIXFROM: /* UNIX From_ line (old $l macro) */
2994	UnixFromLine = newstr(munchstring(val, NULL, '\0'));
2995	break;
2996
2997	case O_OPCHARS: /* operator characters (old $o macro) */
2998	if (OperatorChars != NULL)
2999	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3000	"Warning: OperatorChars is being redefined.\n It should only be set before ruleset definitions.\n");
3001	OperatorChars = newstr(munchstring(val, NULL, '\0'));
3002	break;
3003
3004	case O_DONTINITGRPS: /* don't call initgroups(3) */
3005	DontInitGroups = atobool(val);
3006	break;
3007
3008	case O_SLFH: /* make sure from fits on one line */
3009	SingleLineFromHeader = atobool(val);
3010	break;
3011
3012	case O_ABH: /* allow HELO commands with syntax errors */
3013	AllowBogusHELO = atobool(val);
3014	break;
3015
3016	case O_CONNTHROT: /* connection rate throttle */
3017	ConnRateThrottle = atoi(val);
3018	break;
3019
3020	case O_UGW: /* group writable files are unsafe */
3021	if (!atobool(val))
3022	{
3023	setbitn(DBS_GROUPWRITABLEFORWARDFILESAFE,
3024	DontBlameSendmail);
3025	setbitn(DBS_GROUPWRITABLEINCLUDEFILESAFE,
3026	DontBlameSendmail);
3027	}
3028	break;
3029
3030	case O_DBLBOUNCE: /* address to which to send double bounces */
3031	DoubleBounceAddr = newstr(val);
3032	break;
3033
3034	case O_HSDIR: /* persistent host status directory */
3035	if (val[0] != '\0')
3036	{
3037	CANONIFY(val);
3038	HostStatDir = newstr(val);
3039	}
3040	break;
3041
3042	case O_SINGTHREAD: /* single thread deliveries (requires hsdir) */
3043	SingleThreadDelivery = atobool(val);
3044	break;
3045
3046	case O_RUNASUSER: /* run bulk of code as this user */
3047	for (p = val; *p != '\0'; p++)
3048	{
3049	# if _FFR_DOTTED_USERNAMES
3050	if (p == '/' \|\| p == ':')
3051	# else /* _FFR_DOTTED_USERNAMES */
3052	if (p == '.' \|\| p == '/' \|\| *p == ':')
3053	# endif /* _FFR_DOTTED_USERNAMES */
3054	{
3055	*p++ = '\0';
3056	break;
3057	}
3058	}
3059	if (isascii(val) && isdigit(val))
3060	{
3061	if (can_setuid)
3062	RunAsUid = atoi(val);
3063	}
3064	else
3065	{
3066	register struct passwd *pw;
3067
3068	pw = sm_getpwnam(val);
3069	if (pw == NULL)
3070	{
3071	syserr("readcf: option RunAsUser: unknown user %s", val);
3072	break;
3073	}
3074	else if (can_setuid)
3075	{
3076	if (*p == '\0')
3077	RunAsUserName = newstr(val);
3078	RunAsUid = pw->pw_uid;
3079	RunAsGid = pw->pw_gid;
3080	}
3081	else if (EffGid == pw->pw_gid)
3082	RunAsGid = pw->pw_gid;
3083	else if (UseMSP && *p == '\0')
3084	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3085	"WARNING: RunAsGid for MSP ignored, check group ids (egid=%d, want=%d)\n",
3086	(int) EffGid,
3087	(int) pw->pw_gid);
3088	}
3089	# ifdef UID_MAX
3090	if (RunAsUid > UID_MAX)
3091	{
3092	syserr("readcf: option RunAsUser: uid value (%ld) > UID_MAX (%ld); ignored",
3093	(long) RunAsUid, (long) UID_MAX);
3094	break;
3095	}
3096	# endif /* UID_MAX */
3097	if (*p != '\0')
3098	{
3099	if (isascii(p) && isdigit(p))
3100	{
3101	gid_t runasgid;
3102
3103	runasgid = (gid_t) atoi(p);
3104	if (can_setuid \|\| EffGid == runasgid)
3105	RunAsGid = runasgid;
3106	else if (UseMSP)
3107	(void) sm_io_fprintf(smioout,
3108	SM_TIME_DEFAULT,
3109	"WARNING: RunAsGid for MSP ignored, check group ids (egid=%d, want=%d)\n",
3110	(int) EffGid,
3111	(int) runasgid);
3112	}
3113	else
3114	{
3115	register struct group *gr;
3116
3117	gr = getgrnam(p);
3118	if (gr == NULL)
3119	syserr("readcf: option RunAsUser: unknown group %s",
3120	p);
3121	else if (can_setuid \|\| EffGid == gr->gr_gid)
3122	RunAsGid = gr->gr_gid;
3123	else if (UseMSP)
3124	(void) sm_io_fprintf(smioout,
3125	SM_TIME_DEFAULT,
3126	"WARNING: RunAsGid for MSP ignored, check group ids (egid=%d, want=%d)\n",
3127	(int) EffGid,
3128	(int) gr->gr_gid);
3129	}
3130	}
3131	if (tTd(47, 5))
3132	sm_dprintf("readcf: RunAsUser = %d:%d\n",
3133	(int) RunAsUid, (int) RunAsGid);
3134	break;
3135
3136	case O_DSN_RRT:
3137	RrtImpliesDsn = atobool(val);
3138	break;
3139
3140	case O_PIDFILE:
3141	PSTRSET(PidFile, val);
3142	break;
3143
3144	case O_DONTBLAMESENDMAIL:
3145	p = val;
3146	for (;;)
3147	{
3148	register struct dbsval *dbs;
3149	extern struct dbsval DontBlameSendmailValues[];
3150
3151	while (isascii(p) && (isspace(p) \|\| ispunct(*p)))
3152	p++;
3153	if (*p == '\0')
3154	break;
3155	val = p;
3156	while (isascii(p) && isalnum(p))
3157	p++;
3158	if (*p != '\0')
3159	*p++ = '\0';
3160
3161	for (dbs = DontBlameSendmailValues;
3162	dbs->dbs_name != NULL; dbs++)
3163	{
3164	if (sm_strcasecmp(val, dbs->dbs_name) == 0)
3165	break;
3166	}
3167	if (dbs->dbs_name == NULL)
3168	syserr("readcf: DontBlameSendmail option: %s unrecognized", val);
3169	else if (dbs->dbs_flag == DBS_SAFE)
3170	clrbitmap(DontBlameSendmail);
3171	else
3172	setbitn(dbs->dbs_flag, DontBlameSendmail);
3173	}
3174	sticky = false;
3175	break;
3176
3177	case O_DPI:
3178	if (sm_strcasecmp(val, "loopback") == 0)
3179	DontProbeInterfaces = DPI_SKIPLOOPBACK;
3180	else if (atobool(val))
3181	DontProbeInterfaces = DPI_PROBENONE;
3182	else
3183	DontProbeInterfaces = DPI_PROBEALL;
3184	break;
3185
3186	case O_MAXRCPT:
3187	MaxRcptPerMsg = atoi(val);
3188	break;
3189
3190	case O_RCPTTHROT:
3191	BadRcptThrottle = atoi(val);
3192	break;
3193
3194	case O_DEADLETTER:
3195	CANONIFY(val);
3196	PSTRSET(DeadLetterDrop, val);
3197	break;
3198
3199	#if _FFR_DONTLOCKFILESFORREAD_OPTION
3200	case O_DONTLOCK:
3201	DontLockReadFiles = atobool(val);
3202	break;
3203	#endif /* _FFR_DONTLOCKFILESFORREAD_OPTION */
3204
3205	case O_MAXALIASRCSN:
3206	MaxAliasRecursion = atoi(val);
3207	break;
3208
3209	case O_CNCTONLYTO:
3210	/* XXX should probably use gethostbyname */
3211	#if NETINET \|\| NETINET6
3212	ConnectOnlyTo.sa.sa_family = AF_UNSPEC;
3213	# if NETINET6
3214	if (anynet_pton(AF_INET6, val,
3215	&ConnectOnlyTo.sin6.sin6_addr) != 1)
3216	ConnectOnlyTo.sa.sa_family = AF_INET6;
3217	else
3218	# endif /* NETINET6 */
3219	# if NETINET
3220	{
3221	ConnectOnlyTo.sin.sin_addr.s_addr = inet_addr(val);
3222	if (ConnectOnlyTo.sin.sin_addr.s_addr != INADDR_NONE)
3223	ConnectOnlyTo.sa.sa_family = AF_INET;
3224	}
3225
3226	# endif /* NETINET */
3227	if (ConnectOnlyTo.sa.sa_family == AF_UNSPEC)
3228	{
3229	syserr("readcf: option ConnectOnlyTo: invalid IP address %s",
3230	val);
3231	break;
3232	}
3233	#endif /* NETINET \|\| NETINET6 */
3234	break;
3235
3236	case O_TRUSTUSER:
3237	# if !HASFCHOWN && !defined(_FFR_DROP_TRUSTUSER_WARNING)
3238	if (!UseMSP)
3239	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3240	"readcf: option TrustedUser may cause problems on systems\n which do not support fchown() if UseMSP is not set.\n");
3241	# endif /* !HASFCHOWN && !defined(_FFR_DROP_TRUSTUSER_WARNING) */
3242	if (isascii(val) && isdigit(val))
3243	TrustedUid = atoi(val);
3244	else
3245	{
3246	register struct passwd *pw;
3247
3248	TrustedUid = 0;
3249	pw = sm_getpwnam(val);
3250	if (pw == NULL)
3251	{
3252	syserr("readcf: option TrustedUser: unknown user %s", val);
3253	break;
3254	}
3255	else
3256	TrustedUid = pw->pw_uid;
3257	}
3258
3259	# ifdef UID_MAX
3260	if (TrustedUid > UID_MAX)
3261	{
3262	syserr("readcf: option TrustedUser: uid value (%ld) > UID_MAX (%ld)",
3263	(long) TrustedUid, (long) UID_MAX);
3264	TrustedUid = 0;
3265	}
3266	# endif /* UID_MAX */
3267	break;
3268
3269	case O_MAXMIMEHDRLEN:
3270	p = strchr(val, '/');
3271	if (p != NULL)
3272	*p++ = '\0';
3273	MaxMimeHeaderLength = atoi(val);
3274	if (p != NULL && *p != '\0')
3275	MaxMimeFieldLength = atoi(p);
3276	else
3277	MaxMimeFieldLength = MaxMimeHeaderLength / 2;
3278
3279	if (MaxMimeHeaderLength < 0)
3280	MaxMimeHeaderLength = 0;
3281	else if (MaxMimeHeaderLength < 128)
3282	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3283	"Warning: MaxMimeHeaderLength: header length limit set lower than 128\n");
3284
3285	if (MaxMimeFieldLength < 0)
3286	MaxMimeFieldLength = 0;
3287	else if (MaxMimeFieldLength < 40)
3288	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3289	"Warning: MaxMimeHeaderLength: field length limit set lower than 40\n");
3290	break;
3291
3292	case O_CONTROLSOCKET:
3293	PSTRSET(ControlSocketName, val);
3294	break;
3295
3296	case O_MAXHDRSLEN:
3297	MaxHeadersLength = atoi(val);
3298
3299	if (MaxHeadersLength > 0 &&
3300	MaxHeadersLength < (MAXHDRSLEN / 2))
3301	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3302	"Warning: MaxHeadersLength: headers length limit set lower than %d\n",
3303	(MAXHDRSLEN / 2));
3304	break;
3305
3306	case O_PROCTITLEPREFIX:
3307	PSTRSET(ProcTitlePrefix, val);
3308	break;
3309
3310	#if SASL
3311	case O_SASLINFO:
3312	# if _FFR_ALLOW_SASLINFO
3313	/*
3314	** Allow users to select their own authinfo file
3315	** under certain circumstances, otherwise just ignore
3316	** the option. If the option isn't ignored, several
3317	** commands don't work very well, e.g., mailq.
3318	** However, this is not a "perfect" solution.
3319	** If mail is queued, the authentication info
3320	** will not be used in subsequent delivery attempts.
3321	** If we really want to support this, then it has
3322	** to be stored in the queue file.
3323	*/
3324	if (!bitset(SUBMIT_MSA, SubmitMode) && RealUid != 0 &&
3325	RunAsUid != RealUid)
3326	break;
3327	# endif /* _FFR_ALLOW_SASLINFO */
3328	PSTRSET(SASLInfo, val);
3329	break;
3330
3331	case O_SASLMECH:
3332	if (AuthMechanisms != NULL)
3333	sm_free(AuthMechanisms); /* XXX */
3334	if (*val != '\0')
3335	AuthMechanisms = newstr(val);
3336	else
3337	AuthMechanisms = NULL;
3338	break;
3339
3340	case O_SASLOPTS:
3341	while (val != NULL && *val != '\0')
3342	{
3343	switch (*val)
3344	{
3345	case 'A':
3346	SASLOpts \|= SASL_AUTH_AUTH;
3347	break;
3348
3349	case 'a':
3350	SASLOpts \|= SASL_SEC_NOACTIVE;
3351	break;
3352
3353	case 'c':
3354	SASLOpts \|= SASL_SEC_PASS_CREDENTIALS;
3355	break;
3356
3357	case 'd':
3358	SASLOpts \|= SASL_SEC_NODICTIONARY;
3359	break;
3360
3361	case 'f':
3362	SASLOpts \|= SASL_SEC_FORWARD_SECRECY;
3363	break;
3364
3365	# if _FFR_SASL_OPT_M
3366	/* to be activated in 8.13 */
3367	# if SASL >= 20101
3368	case 'm':
3369	SASLOpts \|= SASL_SEC_MUTUAL_AUTH;
3370	break;
3371	# endif /* SASL >= 20101 */
3372	# endif /* _FFR_SASL_OPT_M */
3373
3374	case 'p':
3375	SASLOpts \|= SASL_SEC_NOPLAINTEXT;
3376	break;
3377
3378	case 'y':
3379	SASLOpts \|= SASL_SEC_NOANONYMOUS;
3380	break;
3381
3382	case ' ': /* ignore */
3383	case '\t': /* ignore */
3384	case ',': /* ignore */
3385	break;
3386
3387	default:
3388	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3389	"Warning: Option: %s unknown parameter '%c'\n",
3390	OPTNAME,
3391	(isascii(*val) &&
3392	isprint(*val))
3393	? *val : '?');
3394	break;
3395	}
3396	++val;
3397	val = strpbrk(val, ", \t");
3398	if (val != NULL)
3399	++val;
3400	}
3401	break;
3402
3403	case O_SASLBITS:
3404	MaxSLBits = atoi(val);
3405	break;
3406
3407	#else /* SASL */
3408	case O_SASLINFO:
3409	case O_SASLMECH:
3410	case O_SASLOPTS:
3411	case O_SASLBITS:
3412	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3413	"Warning: Option: %s requires SASL support (-DSASL)\n",
3414	OPTNAME);
3415	break;
3416	#endif /* SASL */
3417
3418	#if STARTTLS
3419	case O_SRVCERTFILE:
3420	SET_STRING_EXP(SrvCertFile);
3421	case O_SRVKEYFILE:
3422	SET_STRING_EXP(SrvKeyFile);
3423	case O_CLTCERTFILE:
3424	SET_STRING_EXP(CltCertFile);
3425	case O_CLTKEYFILE:
3426	SET_STRING_EXP(CltKeyFile);
3427	case O_CACERTFILE:
3428	SET_STRING_EXP(CACertFile);
3429	case O_CACERTPATH:
3430	SET_STRING_EXP(CACertPath);
3431	case O_DHPARAMS:
3432	SET_STRING_EXP(DHParams);
3433	# if _FFR_TLS_1
3434	case O_DHPARAMS5:
3435	SET_STRING_EXP(DHParams5);
3436	case O_CIPHERLIST:
3437	SET_STRING_EXP(CipherList);
3438	# endif /* _FFR_TLS_1 */
3439
3440	/*
3441	** XXX How about options per daemon/client instead of globally?
3442	** This doesn't work well for some options, e.g., no server cert,
3443	** but fine for others.
3444	**
3445	** XXX Some people may want different certs per server.
3446	**
3447	** See also srvfeatures()
3448	*/
3449
3450	case O_TLS_SRV_OPTS:
3451	while (val != NULL && *val != '\0')
3452	{
3453	switch (*val)
3454	{
3455	case 'V':
3456	TLS_Srv_Opts \|= TLS_I_NO_VRFY;
3457	break;
3458	# if _FFR_TLS_1
3459	/*
3460	** Server without a cert? That works only if
3461	** AnonDH is enabled as cipher, which is not in the
3462	** default list. Hence the CipherList option must
3463	** be available. Moreover: which clients support this
3464	** besides sendmail with this setting?
3465	*/
3466
3467	case 'C':
3468	TLS_Srv_Opts &= ~TLS_I_SRV_CERT;
3469	break;
3470	# endif /* _FFR_TLS_1 */
3471	case ' ': /* ignore */
3472	case '\t': /* ignore */
3473	case ',': /* ignore */
3474	break;
3475	default:
3476	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3477	"Warning: Option: %s unknown parameter '%c'\n",
3478	OPTNAME,
3479	(isascii(*val) &&
3480	isprint(*val))
3481	? *val : '?');
3482	break;
3483	}
3484	++val;
3485	val = strpbrk(val, ", \t");
3486	if (val != NULL)
3487	++val;
3488	}
3489	break;
3490
3491	case O_RANDFILE:
3492	PSTRSET(RandFile, val);
3493	break;
3494
3495	#else /* STARTTLS */
3496	case O_SRVCERTFILE:
3497	case O_SRVKEYFILE:
3498	case O_CLTCERTFILE:
3499	case O_CLTKEYFILE:
3500	case O_CACERTFILE:
3501	case O_CACERTPATH:
3502	case O_DHPARAMS:
3503	# if _FFR_TLS_1
3504	case O_DHPARAMS5:
3505	case O_CIPHERLIST:
3506	# endif /* _FFR_TLS_1 */
3507	case O_RANDFILE:
3508	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3509	"Warning: Option: %s requires TLS support\n",
3510	OPTNAME);
3511	break;
3512
3513	#endif /* STARTTLS */
3514
3515	case O_CLIENTPORT:
3516	setclientoptions(val);
3517	break;
3518
3519	case O_DF_BUFSIZE:
3520	DataFileBufferSize = atoi(val);
3521	break;
3522
3523	case O_XF_BUFSIZE:
3524	XscriptFileBufferSize = atoi(val);
3525	break;
3526
3527	case O_LDAPDEFAULTSPEC:
3528	#if LDAPMAP
3529	ldapmap_set_defaults(val);
3530	#else /* LDAPMAP */
3531	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3532	"Warning: Option: %s requires LDAP support (-DLDAPMAP)\n",
3533	OPTNAME);
3534	#endif /* LDAPMAP */
3535	break;
3536
3537	case O_INPUTMILTER:
3538	#if MILTER
3539	InputFilterList = newstr(val);
3540	#else /* MILTER */
3541	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3542	"Warning: Option: %s requires Milter support (-DMILTER)\n",
3543	OPTNAME);
3544	#endif /* MILTER */
3545	break;
3546
3547	case O_MILTER:
3548	#if MILTER
3549	milter_set_option(subopt, val, sticky);
3550	#else /* MILTER */
3551	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3552	"Warning: Option: %s requires Milter support (-DMILTER)\n",
3553	OPTNAME);
3554	#endif /* MILTER */
3555	break;
3556
3557	case O_QUEUE_FILE_MODE: /* queue file mode */
3558	QueueFileMode = atooct(val) & 0777;
3559	break;
3560
3561	case O_DLVR_MIN: /* deliver by minimum time */
3562	DeliverByMin = convtime(val, 's');
3563	break;
3564
3565	/* modifiers {daemon_flags} for direct submissions */
3566	case O_DIRECTSUBMODIFIERS:
3567	{
3568	BITMAP256 m; /* ignored */
3569	extern ENVELOPE BlankEnvelope;
3570
3571	macdefine(&BlankEnvelope.e_macro, A_PERM,
3572	macid("{daemon_flags}"),
3573	getmodifiers(val, m));
3574	}
3575	break;
3576
3577	case O_FASTSPLIT:
3578	FastSplit = atoi(val);
3579	break;
3580
3581	case O_MBDB:
3582	Mbdb = newstr(val);
3583	break;
3584
3585	case O_MSQ:
3586	UseMSP = atobool(val);
3587	break;
3588
3589	#if _FFR_SOFT_BOUNCE
3590	case O_SOFTBOUNCE:
3591	SoftBounce = atobool(val);
3592	break;
3593	#endif /* _FFR_SOFT_BOUNCE */
3594
3595	#if _FFR_REJECT_LOG
3596	case O_REJECTLOGINTERVAL: /* time btwn log msgs while refusing */
3597	RejectLogInterval = convtime(val, 'h');
3598	break;
3599	#endif /* _FFR_REJECT_LOG */
3600
3601	#if _FFR_REQ_DIR_FSYNC_OPT
3602	case O_REQUIRES_DIR_FSYNC:
3603	# if REQUIRES_DIR_FSYNC
3604	RequiresDirfsync = atobool(val);
3605	# else /* REQUIRES_DIR_FSYNC */
3606	/* silently ignored... required for cf file option */
3607	# endif /* REQUIRES_DIR_FSYNC */
3608	break;
3609	#endif /* _FFR_REQ_DIR_FSYNC_OPT */
3610
3611	default:
3612	if (tTd(37, 1))
3613	{
3614	if (isascii(opt) && isprint(opt))
3615	sm_dprintf("Warning: option %c unknown\n", opt);
3616	else
3617	sm_dprintf("Warning: option 0x%x unknown\n", opt);
3618	}
3619	break;
3620	}
3621
3622	/*
3623	** Options with suboptions are responsible for taking care
3624	** of sticky-ness (e.g., that a command line setting is kept
3625	** when reading in the sendmail.cf file). This has to be done
3626	** when the suboptions are parsed since each suboption must be
3627	** sticky, not the root option.
3628	*/
3629
3630	if (sticky && !bitset(OI_SUBOPT, o->o_flags))
3631	setbitn(opt, StickyOpt);
3632	}
3633	/*
3634	** SETCLASS -- set a string into a class
3635	**
3636	** Parameters:
3637	** class -- the class to put the string in.
3638	** str -- the string to enter
3639	**
3640	** Returns:
3641	** none.
3642	**
3643	** Side Effects:
3644	** puts the word into the symbol table.
3645	*/
3646
3647	void
3648	setclass(class, str)
3649	int class;
3650	char *str;
3651	{
3652	register STAB *s;
3653
3654	if ((*str & 0377) == MATCHCLASS)
3655	{
3656	int mid;
3657
3658	str++;
3659	mid = macid(str);
3660	if (mid == 0)
3661	return;
3662
3663	if (tTd(37, 8))
3664	sm_dprintf("setclass(%s, $=%s)\n",
3665	macname(class), macname(mid));
3666	copy_class(mid, class);
3667	}
3668	else
3669	{
3670	if (tTd(37, 8))
3671	sm_dprintf("setclass(%s, %s)\n", macname(class), str);
3672
3673	s = stab(str, ST_CLASS, ST_ENTER);
3674	setbitn(bitidx(class), s->s_class);
3675	}
3676	}
3677	/*
3678	** MAKEMAPENTRY -- create a map entry
3679	**
3680	** Parameters:
3681	** line -- the config file line
3682	**
3683	** Returns:
3684	** A pointer to the map that has been created.
3685	** NULL if there was a syntax error.
3686	**
3687	** Side Effects:
3688	** Enters the map into the dictionary.
3689	*/
3690
3691	MAP *
3692	makemapentry(line)
3693	char *line;
3694	{
3695	register char *p;
3696	char *mapname;
3697	char *classname;
3698	register STAB *s;
3699	STAB *class;
3700
3701	for (p = line; isascii(p) && isspace(p); p++)
3702	continue;
3703	if (!(isascii(p) && isalnum(p)))
3704	{
3705	syserr("readcf: config K line: no map name");
3706	return NULL;
3707	}
3708
3709	mapname = p;
3710	while ((isascii(++p) && isalnum(p)) \|\| p == '_' \|\| p == '.')
3711	continue;
3712	if (*p != '\0')
3713	*p++ = '\0';
3714	while (isascii(p) && isspace(p))
3715	p++;
3716	if (!(isascii(p) && isalnum(p)))
3717	{
3718	syserr("readcf: config K line, map %s: no map class", mapname);
3719	return NULL;
3720	}
3721	classname = p;
3722	while (isascii(++p) && isalnum(p))
3723	continue;
3724	if (*p != '\0')
3725	*p++ = '\0';
3726	while (isascii(p) && isspace(p))
3727	p++;
3728
3729	/* look up the class */
3730	class = stab(classname, ST_MAPCLASS, ST_FIND);
3731	if (class == NULL)
3732	{
3733	syserr("readcf: map %s: class %s not available", mapname,
3734	classname);
3735	return NULL;
3736	}
3737
3738	/* enter the map */
3739	s = stab(mapname, ST_MAP, ST_ENTER);
3740	s->s_map.map_class = &class->s_mapclass;
3741	s->s_map.map_mname = newstr(mapname);
3742
3743	if (class->s_mapclass.map_parse(&s->s_map, p))
3744	s->s_map.map_mflags \|= MF_VALID;
3745
3746	if (tTd(37, 5))
3747	{
3748	sm_dprintf("map %s, class %s, flags %lx, file %s,\n",
3749	s->s_map.map_mname, s->s_map.map_class->map_cname,
3750	s->s_map.map_mflags, s->s_map.map_file);
3751	sm_dprintf("\tapp %s, domain %s, rebuild %s\n",
3752	s->s_map.map_app, s->s_map.map_domain,
3753	s->s_map.map_rebuild);
3754	}
3755	return &s->s_map;
3756	}
3757	/*
3758	** STRTORWSET -- convert string to rewriting set number
3759	**
3760	** Parameters:
3761	** p -- the pointer to the string to decode.
3762	** endp -- if set, store the trailing delimiter here.
3763	** stabmode -- ST_ENTER to create this entry, ST_FIND if
3764	** it must already exist.
3765	**
3766	** Returns:
3767	** The appropriate ruleset number.
3768	** -1 if it is not valid (error already printed)
3769	*/
3770
3771	int
3772	strtorwset(p, endp, stabmode)
3773	char *p;
3774	char **endp;
3775	int stabmode;
3776	{
3777	int ruleset;
3778	static int nextruleset = MAXRWSETS;
3779
3780	while (isascii(p) && isspace(p))
3781	p++;
3782	if (!isascii(*p))
3783	{
3784	syserr("invalid ruleset name: \"%.20s\"", p);
3785	return -1;
3786	}
3787	if (isdigit(*p))
3788	{
3789	ruleset = strtol(p, endp, 10);
3790	if (ruleset >= MAXRWSETS / 2 \|\| ruleset < 0)
3791	{
3792	syserr("bad ruleset %d (%d max)",
3793	ruleset, MAXRWSETS / 2);
3794	ruleset = -1;
3795	}
3796	}
3797	else
3798	{
3799	STAB *s;
3800	char delim;
3801	char *q = NULL;
3802
3803	q = p;
3804	while (p != '\0' && isascii(p) &&
3805	(isalnum(p) \|\| p == '_'))
3806	p++;
3807	if (q == p \|\| !(isascii(q) && isalpha(q)))
3808	{
3809	/* no valid characters */
3810	syserr("invalid ruleset name: \"%.20s\"", q);
3811	return -1;
3812	}
3813	while (isascii(p) && isspace(p))
3814	*p++ = '\0';
3815	delim = *p;
3816	if (delim != '\0')
3817	*p = '\0';
3818	s = stab(q, ST_RULESET, stabmode);
3819	if (delim != '\0')
3820	*p = delim;
3821
3822	if (s == NULL)
3823	return -1;
3824
3825	if (stabmode == ST_ENTER && delim == '=')
3826	{
3827	while (isascii(++p) && isspace(p))
3828	continue;
3829	if (!(isascii(p) && isdigit(p)))
3830	{
3831	syserr("bad ruleset definition \"%s\" (number required after `=')", q);
3832	ruleset = -1;
3833	}
3834	else
3835	{
3836	ruleset = strtol(p, endp, 10);
3837	if (ruleset >= MAXRWSETS / 2 \|\| ruleset < 0)
3838	{
3839	syserr("bad ruleset number %d in \"%s\" (%d max)",
3840	ruleset, q, MAXRWSETS / 2);
3841	ruleset = -1;
3842	}
3843	}
3844	}
3845	else
3846	{
3847	if (endp != NULL)
3848	*endp = p;
3849	if (s->s_ruleset >= 0)
3850	ruleset = s->s_ruleset;
3851	else if ((ruleset = --nextruleset) < MAXRWSETS / 2)
3852	{
3853	syserr("%s: too many named rulesets (%d max)",
3854	q, MAXRWSETS / 2);
3855	ruleset = -1;
3856	}
3857	}
3858	if (s->s_ruleset >= 0 &&
3859	ruleset >= 0 &&
3860	ruleset != s->s_ruleset)
3861	{
3862	syserr("%s: ruleset changed value (old %d, new %d)",
3863	q, s->s_ruleset, ruleset);
3864	ruleset = s->s_ruleset;
3865	}
3866	else if (ruleset >= 0)
3867	{
3868	s->s_ruleset = ruleset;
3869	}
3870	if (stabmode == ST_ENTER && ruleset >= 0)
3871	{
3872	char *h = NULL;
3873
3874	if (RuleSetNames[ruleset] != NULL)
3875	sm_free(RuleSetNames[ruleset]); /* XXX */
3876	if (delim != '\0' && (h = strchr(q, delim)) != NULL)
3877	*h = '\0';
3878	RuleSetNames[ruleset] = newstr(q);
3879	if (delim == '/' && h != NULL)
3880	h = delim; / put back delim */
3881	}
3882	}
3883	return ruleset;
3884	}
3885	/*
3886	** SETTIMEOUT -- set an individual timeout
3887	**
3888	** Parameters:
3889	** name -- the name of the timeout.
3890	** val -- the value of the timeout.
3891	** sticky -- if set, don't let other setoptions override
3892	** this value.
3893	**
3894	** Returns:
3895	** none.
3896	*/
3897
3898	/* set if Timeout sub-option is stuck */
3899	static BITMAP256 StickyTimeoutOpt;
3900
3901	static struct timeoutinfo
3902	{
3903	char to_name; / long name of timeout */
3904	unsigned char to_code; /* code for option */
3905	} TimeOutTab[] =
3906	{
3907	#define TO_INITIAL 0x01
3908	{ "initial", TO_INITIAL },
3909	#define TO_MAIL 0x02
3910	{ "mail", TO_MAIL },
3911	#define TO_RCPT 0x03
3912	{ "rcpt", TO_RCPT },
3913	#define TO_DATAINIT 0x04
3914	{ "datainit", TO_DATAINIT },
3915	#define TO_DATABLOCK 0x05
3916	{ "datablock", TO_DATABLOCK },
3917	#define TO_DATAFINAL 0x06
3918	{ "datafinal", TO_DATAFINAL },
3919	#define TO_COMMAND 0x07
3920	{ "command", TO_COMMAND },
3921	#define TO_RSET 0x08
3922	{ "rset", TO_RSET },
3923	#define TO_HELO 0x09
3924	{ "helo", TO_HELO },
3925	#define TO_QUIT 0x0A
3926	{ "quit", TO_QUIT },
3927	#define TO_MISC 0x0B
3928	{ "misc", TO_MISC },
3929	#define TO_IDENT 0x0C
3930	{ "ident", TO_IDENT },
3931	#define TO_FILEOPEN 0x0D
3932	{ "fileopen", TO_FILEOPEN },
3933	#define TO_CONNECT 0x0E
3934	{ "connect", TO_CONNECT },
3935	#define TO_ICONNECT 0x0F
3936	{ "iconnect", TO_ICONNECT },
3937	#define TO_QUEUEWARN 0x10
3938	{ "queuewarn", TO_QUEUEWARN },
3939	{ "queuewarn.*", TO_QUEUEWARN },
3940	#define TO_QUEUEWARN_NORMAL 0x11
3941	{ "queuewarn.normal", TO_QUEUEWARN_NORMAL },
3942	#define TO_QUEUEWARN_URGENT 0x12
3943	{ "queuewarn.urgent", TO_QUEUEWARN_URGENT },
3944	#define TO_QUEUEWARN_NON_URGENT 0x13
3945	{ "queuewarn.non-urgent", TO_QUEUEWARN_NON_URGENT },
3946	#define TO_QUEUERETURN 0x14
3947	{ "queuereturn", TO_QUEUERETURN },
3948	{ "queuereturn.*", TO_QUEUERETURN },
3949	#define TO_QUEUERETURN_NORMAL 0x15
3950	{ "queuereturn.normal", TO_QUEUERETURN_NORMAL },
3951	#define TO_QUEUERETURN_URGENT 0x16
3952	{ "queuereturn.urgent", TO_QUEUERETURN_URGENT },
3953	#define TO_QUEUERETURN_NON_URGENT 0x17
3954	{ "queuereturn.non-urgent", TO_QUEUERETURN_NON_URGENT },
3955	#define TO_HOSTSTATUS 0x18
3956	{ "hoststatus", TO_HOSTSTATUS },
3957	#define TO_RESOLVER_RETRANS 0x19
3958	{ "resolver.retrans", TO_RESOLVER_RETRANS },
3959	#define TO_RESOLVER_RETRANS_NORMAL 0x1A
3960	{ "resolver.retrans.normal", TO_RESOLVER_RETRANS_NORMAL },
3961	#define TO_RESOLVER_RETRANS_FIRST 0x1B
3962	{ "resolver.retrans.first", TO_RESOLVER_RETRANS_FIRST },
3963	#define TO_RESOLVER_RETRY 0x1C
3964	{ "resolver.retry", TO_RESOLVER_RETRY },
3965	#define TO_RESOLVER_RETRY_NORMAL 0x1D
3966	{ "resolver.retry.normal", TO_RESOLVER_RETRY_NORMAL },
3967	#define TO_RESOLVER_RETRY_FIRST 0x1E
3968	{ "resolver.retry.first", TO_RESOLVER_RETRY_FIRST },
3969	#define TO_CONTROL 0x1F
3970	{ "control", TO_CONTROL },
3971	#define TO_LHLO 0x20
3972	{ "lhlo", TO_LHLO },
3973	#define TO_AUTH 0x21
3974	{ "auth", TO_AUTH },
3975	#define TO_STARTTLS 0x22
3976	{ "starttls", TO_STARTTLS },
3977	#define TO_ACONNECT 0x23
3978	{ "aconnect", TO_ACONNECT },
3979	#if _FFR_QUEUERETURN_DSN
3980	# define TO_QUEUEWARN_DSN 0x24
3981	{ "queuewarn.dsn", TO_QUEUEWARN_DSN },
3982	# define TO_QUEUERETURN_DSN 0x25
3983	{ "queuereturn.dsn", TO_QUEUERETURN_DSN },
3984	#endif /* _FFR_QUEUERETURN_DSN */
3985	{ NULL, 0 },
3986	};
3987
3988
3989	static void
3990	settimeout(name, val, sticky)
3991	char *name;
3992	char *val;
3993	bool sticky;
3994	{
3995	register struct timeoutinfo *to;
3996	int i, addopts;
3997	time_t toval;
3998
3999	if (tTd(37, 2))
4000	sm_dprintf("settimeout(%s = %s)", name, val);
4001
4002	for (to = TimeOutTab; to->to_name != NULL; to++)
4003	{
4004	if (sm_strcasecmp(to->to_name, name) == 0)
4005	break;
4006	}
4007
4008	if (to->to_name == NULL)
4009	{
4010	errno = 0; /* avoid bogus error text */
4011	syserr("settimeout: invalid timeout %s", name);
4012	return;
4013	}
4014
4015	/*
4016	** See if this option is preset for us.
4017	*/
4018
4019	if (!sticky && bitnset(to->to_code, StickyTimeoutOpt))
4020	{
4021	if (tTd(37, 2))
4022	sm_dprintf(" (ignored)\n");
4023	return;
4024	}
4025
4026	if (tTd(37, 2))
4027	sm_dprintf("\n");
4028
4029	toval = convtime(val, 'm');
4030	addopts = 0;
4031
4032	switch (to->to_code)
4033	{
4034	case TO_INITIAL:
4035	TimeOuts.to_initial = toval;
4036	break;
4037
4038	case TO_MAIL:
4039	TimeOuts.to_mail = toval;
4040	break;
4041
4042	case TO_RCPT:
4043	TimeOuts.to_rcpt = toval;
4044	break;
4045
4046	case TO_DATAINIT:
4047	TimeOuts.to_datainit = toval;
4048	break;
4049
4050	case TO_DATABLOCK:
4051	TimeOuts.to_datablock = toval;
4052	break;
4053
4054	case TO_DATAFINAL:
4055	TimeOuts.to_datafinal = toval;
4056	break;
4057
4058	case TO_COMMAND:
4059	TimeOuts.to_nextcommand = toval;
4060	break;
4061
4062	case TO_RSET:
4063	TimeOuts.to_rset = toval;
4064	break;
4065
4066	case TO_HELO:
4067	TimeOuts.to_helo = toval;
4068	break;
4069
4070	case TO_QUIT:
4071	TimeOuts.to_quit = toval;
4072	break;
4073
4074	case TO_MISC:
4075	TimeOuts.to_miscshort = toval;
4076	break;
4077
4078	case TO_IDENT:
4079	TimeOuts.to_ident = toval;
4080	break;
4081
4082	case TO_FILEOPEN:
4083	TimeOuts.to_fileopen = toval;
4084	break;
4085
4086	case TO_CONNECT:
4087	TimeOuts.to_connect = toval;
4088	break;
4089
4090	case TO_ICONNECT:
4091	TimeOuts.to_iconnect = toval;
4092	break;
4093
4094	case TO_ACONNECT:
4095	TimeOuts.to_aconnect = toval;
4096	break;
4097
4098	case TO_QUEUEWARN:
4099	toval = convtime(val, 'h');
4100	TimeOuts.to_q_warning[TOC_NORMAL] = toval;
4101	TimeOuts.to_q_warning[TOC_URGENT] = toval;
4102	TimeOuts.to_q_warning[TOC_NONURGENT] = toval;
4103	#if _FFR_QUEUERETURN_DSN
4104	TimeOuts.to_q_warning[TOC_DSN] = toval;
4105	#endif /* _FFR_QUEUERETURN_DSN */
4106	addopts = 2;
4107	break;
4108
4109	case TO_QUEUEWARN_NORMAL:
4110	toval = convtime(val, 'h');
4111	TimeOuts.to_q_warning[TOC_NORMAL] = toval;
4112	break;
4113
4114	case TO_QUEUEWARN_URGENT:
4115	toval = convtime(val, 'h');
4116	TimeOuts.to_q_warning[TOC_URGENT] = toval;
4117	break;
4118
4119	case TO_QUEUEWARN_NON_URGENT:
4120	toval = convtime(val, 'h');
4121	TimeOuts.to_q_warning[TOC_NONURGENT] = toval;
4122	break;
4123
4124	#if _FFR_QUEUERETURN_DSN
4125	case TO_QUEUEWARN_DSN:
4126	toval = convtime(val, 'h');
4127	TimeOuts.to_q_warning[TOC_DSN] = toval;
4128	break;
4129	#endif /* _FFR_QUEUERETURN_DSN */
4130
4131	case TO_QUEUERETURN:
4132	toval = convtime(val, 'd');
4133	TimeOuts.to_q_return[TOC_NORMAL] = toval;
4134	TimeOuts.to_q_return[TOC_URGENT] = toval;
4135	TimeOuts.to_q_return[TOC_NONURGENT] = toval;
4136	#if _FFR_QUEUERETURN_DSN
4137	TimeOuts.to_q_return[TOC_DSN] = toval;
4138	#endif /* _FFR_QUEUERETURN_DSN */
4139	addopts = 2;
4140	break;
4141
4142	case TO_QUEUERETURN_NORMAL:
4143	toval = convtime(val, 'd');
4144	TimeOuts.to_q_return[TOC_NORMAL] = toval;
4145	break;
4146
4147	case TO_QUEUERETURN_URGENT:
4148	toval = convtime(val, 'd');
4149	TimeOuts.to_q_return[TOC_URGENT] = toval;
4150	break;
4151
4152	case TO_QUEUERETURN_NON_URGENT:
4153	toval = convtime(val, 'd');
4154	TimeOuts.to_q_return[TOC_NONURGENT] = toval;
4155	break;
4156
4157	#if _FFR_QUEUERETURN_DSN
4158	case TO_QUEUERETURN_DSN:
4159	toval = convtime(val, 'd');
4160	TimeOuts.to_q_return[TOC_DSN] = toval;
4161	break;
4162	#endif /* _FFR_QUEUERETURN_DSN */
4163
4164	case TO_HOSTSTATUS:
4165	MciInfoTimeout = toval;
4166	break;
4167
4168	case TO_RESOLVER_RETRANS:
4169	toval = convtime(val, 's');
4170	TimeOuts.res_retrans[RES_TO_DEFAULT] = toval;
4171	TimeOuts.res_retrans[RES_TO_FIRST] = toval;
4172	TimeOuts.res_retrans[RES_TO_NORMAL] = toval;
4173	addopts = 2;
4174	break;
4175
4176	case TO_RESOLVER_RETRY:
4177	i = atoi(val);
4178	TimeOuts.res_retry[RES_TO_DEFAULT] = i;
4179	TimeOuts.res_retry[RES_TO_FIRST] = i;
4180	TimeOuts.res_retry[RES_TO_NORMAL] = i;
4181	addopts = 2;
4182	break;
4183
4184	case TO_RESOLVER_RETRANS_NORMAL:
4185	TimeOuts.res_retrans[RES_TO_NORMAL] = convtime(val, 's');
4186	break;
4187
4188	case TO_RESOLVER_RETRY_NORMAL:
4189	TimeOuts.res_retry[RES_TO_NORMAL] = atoi(val);
4190	break;
4191
4192	case TO_RESOLVER_RETRANS_FIRST:
4193	TimeOuts.res_retrans[RES_TO_FIRST] = convtime(val, 's');
4194	break;
4195
4196	case TO_RESOLVER_RETRY_FIRST:
4197	TimeOuts.res_retry[RES_TO_FIRST] = atoi(val);
4198	break;
4199
4200	case TO_CONTROL:
4201	TimeOuts.to_control = toval;
4202	break;
4203
4204	case TO_LHLO:
4205	TimeOuts.to_lhlo = toval;
4206	break;
4207
4208	#if SASL
4209	case TO_AUTH:
4210	TimeOuts.to_auth = toval;
4211	break;
4212	#endif /* SASL */
4213
4214	#if STARTTLS
4215	case TO_STARTTLS:
4216	TimeOuts.to_starttls = toval;
4217	break;
4218	#endif /* STARTTLS */
4219
4220	default:
4221	syserr("settimeout: invalid timeout %s", name);
4222	break;
4223	}
4224
4225	if (sticky)
4226	{
4227	for (i = 0; i <= addopts; i++)
4228	setbitn(to->to_code + i, StickyTimeoutOpt);
4229	}
4230	}
4231	/*
4232	** INITTIMEOUTS -- parse and set timeout values
4233	**
4234	** Parameters:
4235	** val -- a pointer to the values. If NULL, do initial
4236	** settings.
4237	** sticky -- if set, don't let other setoptions override
4238	** this suboption value.
4239	**
4240	** Returns:
4241	** none.
4242	**
4243	** Side Effects:
4244	** Initializes the TimeOuts structure
4245	*/
4246
4247	void
4248	inittimeouts(val, sticky)
4249	register char *val;
4250	bool sticky;
4251	{
4252	register char *p;
4253
4254	if (tTd(37, 2))
4255	sm_dprintf("inittimeouts(%s)\n", val == NULL ? "<NULL>" : val);
4256	if (val == NULL)
4257	{
4258	TimeOuts.to_connect = (time_t) 0 SECONDS;
4259	TimeOuts.to_aconnect = (time_t) 0 SECONDS;
4260	TimeOuts.to_iconnect = (time_t) 0 SECONDS;
4261	TimeOuts.to_initial = (time_t) 5 MINUTES;
4262	TimeOuts.to_helo = (time_t) 5 MINUTES;
4263	TimeOuts.to_mail = (time_t) 10 MINUTES;
4264	TimeOuts.to_rcpt = (time_t) 1 HOUR;
4265	TimeOuts.to_datainit = (time_t) 5 MINUTES;
4266	TimeOuts.to_datablock = (time_t) 1 HOUR;
4267	TimeOuts.to_datafinal = (time_t) 1 HOUR;
4268	TimeOuts.to_rset = (time_t) 5 MINUTES;
4269	TimeOuts.to_quit = (time_t) 2 MINUTES;
4270	TimeOuts.to_nextcommand = (time_t) 1 HOUR;
4271	TimeOuts.to_miscshort = (time_t) 2 MINUTES;
4272	#if IDENTPROTO
4273	TimeOuts.to_ident = (time_t) 5 SECONDS;
4274	#else /* IDENTPROTO */
4275	TimeOuts.to_ident = (time_t) 0 SECONDS;
4276	#endif /* IDENTPROTO */
4277	TimeOuts.to_fileopen = (time_t) 60 SECONDS;
4278	TimeOuts.to_control = (time_t) 2 MINUTES;
4279	TimeOuts.to_lhlo = (time_t) 2 MINUTES;
4280	#if SASL
4281	TimeOuts.to_auth = (time_t) 10 MINUTES;
4282	#endif /* SASL */
4283	#if STARTTLS
4284	TimeOuts.to_starttls = (time_t) 1 HOUR;
4285	#endif /* STARTTLS */
4286	if (tTd(37, 5))
4287	{
4288	sm_dprintf("Timeouts:\n");
4289	sm_dprintf(" connect = %ld\n",
4290	(long) TimeOuts.to_connect);
4291	sm_dprintf(" aconnect = %ld\n",
4292	(long) TimeOuts.to_aconnect);
4293	sm_dprintf(" initial = %ld\n",
4294	(long) TimeOuts.to_initial);
4295	sm_dprintf(" helo = %ld\n", (long) TimeOuts.to_helo);
4296	sm_dprintf(" mail = %ld\n", (long) TimeOuts.to_mail);
4297	sm_dprintf(" rcpt = %ld\n", (long) TimeOuts.to_rcpt);
4298	sm_dprintf(" datainit = %ld\n",
4299	(long) TimeOuts.to_datainit);
4300	sm_dprintf(" datablock = %ld\n",
4301	(long) TimeOuts.to_datablock);
4302	sm_dprintf(" datafinal = %ld\n",
4303	(long) TimeOuts.to_datafinal);
4304	sm_dprintf(" rset = %ld\n", (long) TimeOuts.to_rset);
4305	sm_dprintf(" quit = %ld\n", (long) TimeOuts.to_quit);
4306	sm_dprintf(" nextcommand = %ld\n",
4307	(long) TimeOuts.to_nextcommand);
4308	sm_dprintf(" miscshort = %ld\n",
4309	(long) TimeOuts.to_miscshort);
4310	sm_dprintf(" ident = %ld\n", (long) TimeOuts.to_ident);
4311	sm_dprintf(" fileopen = %ld\n",
4312	(long) TimeOuts.to_fileopen);
4313	sm_dprintf(" lhlo = %ld\n",
4314	(long) TimeOuts.to_lhlo);
4315	sm_dprintf(" control = %ld\n",
4316	(long) TimeOuts.to_control);
4317	}
4318	return;
4319	}
4320
4321	for (;; val = p)
4322	{
4323	while (isascii(val) && isspace(val))
4324	val++;
4325	if (*val == '\0')
4326	break;
4327	for (p = val; p != '\0' && p != ','; p++)
4328	continue;
4329	if (*p != '\0')
4330	*p++ = '\0';
4331
4332	if (isascii(val) && isdigit(val))
4333	{
4334	/* old syntax -- set everything */
4335	TimeOuts.to_mail = convtime(val, 'm');
4336	TimeOuts.to_rcpt = TimeOuts.to_mail;
4337	TimeOuts.to_datainit = TimeOuts.to_mail;
4338	TimeOuts.to_datablock = TimeOuts.to_mail;
4339	TimeOuts.to_datafinal = TimeOuts.to_mail;
4340	TimeOuts.to_nextcommand = TimeOuts.to_mail;
4341	if (sticky)
4342	{
4343	setbitn(TO_MAIL, StickyTimeoutOpt);
4344	setbitn(TO_RCPT, StickyTimeoutOpt);
4345	setbitn(TO_DATAINIT, StickyTimeoutOpt);
4346	setbitn(TO_DATABLOCK, StickyTimeoutOpt);
4347	setbitn(TO_DATAFINAL, StickyTimeoutOpt);
4348	setbitn(TO_COMMAND, StickyTimeoutOpt);
4349	}
4350	continue;
4351	}
4352	else
4353	{
4354	register char *q = strchr(val, ':');
4355
4356	if (q == NULL && (q = strchr(val, '=')) == NULL)
4357	{
4358	/* syntax error */
4359	continue;
4360	}
4361	*q++ = '\0';
4362	settimeout(val, q, sticky);
4363	}
4364	}
4365	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/third/sendmail/sendmail/readcf.c @ 19204

Download in other formats: