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