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