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 } 4732
Indexes created Wed Feb 10 13:04:53 UTC 2010
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Site Map |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
© 2010, Oracle Corporation and/or its affiliates
