![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to readcf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / sendmail / src|
Return to readcf.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / sendmail / src |
1.1 ! root 1: /* ! 2: * Copyright (c) 1983 Eric P. Allman ! 3: * Copyright (c) 1988 Regents of the University of California. ! 4: * All rights reserved. ! 5: * ! 6: * Redistribution and use in source and binary forms are permitted provided ! 7: * that: (1) source distributions retain this entire copyright notice and ! 8: * comment, and (2) distributions including binaries display the following ! 9: * acknowledgement: ``This product includes software developed by the ! 10: * University of California, Berkeley and its contributors'' in the ! 11: * documentation or other materials provided with the distribution and in ! 12: * all advertising materials mentioning features or use of this software. ! 13: * Neither the name of the University nor the names of its contributors may ! 14: * be used to endorse or promote products derived from this software without ! 15: * specific prior written permission. ! 16: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 19: */ ! 20: ! 21: #ifndef lint ! 22: static char sccsid[] = "@(#)readcf.c 5.21 (Berkeley) 6/1/90"; ! 23: #endif /* not lint */ ! 24: ! 25: # include "sendmail.h" ! 26: ! 27: /* ! 28: ** READCF -- read control file. ! 29: ** ! 30: ** This routine reads the control file and builds the internal ! 31: ** form. ! 32: ** ! 33: ** The file is formatted as a sequence of lines, each taken ! 34: ** atomically. The first character of each line describes how ! 35: ** the line is to be interpreted. The lines are: ! 36: ** Dxval Define macro x to have value val. ! 37: ** Cxword Put word into class x. ! 38: ** Fxfile [fmt] Read file for lines to put into ! 39: ** class x. Use scanf string 'fmt' ! 40: ** or "%s" if not present. Fmt should ! 41: ** only produce one string-valued result. ! 42: ** Hname: value Define header with field-name 'name' ! 43: ** and value as specified; this will be ! 44: ** macro expanded immediately before ! 45: ** use. ! 46: ** Sn Use rewriting set n. ! 47: ** Rlhs rhs Rewrite addresses that match lhs to ! 48: ** be rhs. ! 49: ** Mn arg=val... Define mailer. n is the internal name. ! 50: ** Args specify mailer parameters. ! 51: ** Oxvalue Set option x to value. ! 52: ** Pname=value Set precedence name to value. ! 53: ** ! 54: ** Parameters: ! 55: ** cfname -- control file name. ! 56: ** ! 57: ** Returns: ! 58: ** none. ! 59: ** ! 60: ** Side Effects: ! 61: ** Builds several internal tables. ! 62: */ ! 63: ! 64: readcf(cfname) ! 65: char *cfname; ! 66: { ! 67: FILE *cf; ! 68: int ruleset = 0; ! 69: char *q; ! 70: char **pv; ! 71: struct rewrite *rwp = NULL; ! 72: char buf[MAXLINE]; ! 73: register char *p; ! 74: extern char **prescan(); ! 75: extern char **copyplist(); ! 76: char exbuf[MAXLINE]; ! 77: char pvpbuf[PSBUFSIZE]; ! 78: extern char *fgetfolded(); ! 79: extern char *munchstring(); ! 80: ! 81: cf = fopen(cfname, "r"); ! 82: if (cf == NULL) ! 83: { ! 84: syserr("cannot open %s", cfname); ! 85: exit(EX_OSFILE); ! 86: } ! 87: ! 88: FileName = cfname; ! 89: LineNumber = 0; ! 90: while (fgetfolded(buf, sizeof buf, cf) != NULL) ! 91: { ! 92: /* map $ into \001 (ASCII SOH) for macro expansion */ ! 93: for (p = buf; *p != '\0'; p++) ! 94: { ! 95: if (*p != '$') ! 96: continue; ! 97: ! 98: if (p[1] == '$') ! 99: { ! 100: /* actual dollar sign.... */ ! 101: (void) strcpy(p, p + 1); ! 102: continue; ! 103: } ! 104: ! 105: /* convert to macro expansion character */ ! 106: *p = '\001'; ! 107: } ! 108: ! 109: /* interpret this line */ ! 110: switch (buf[0]) ! 111: { ! 112: case '\0': ! 113: case '#': /* comment */ ! 114: break; ! 115: ! 116: case 'R': /* rewriting rule */ ! 117: for (p = &buf[1]; *p != '\0' && *p != '\t'; p++) ! 118: continue; ! 119: ! 120: if (*p == '\0') ! 121: { ! 122: syserr("invalid rewrite line \"%s\"", buf); ! 123: break; ! 124: } ! 125: ! 126: /* allocate space for the rule header */ ! 127: if (rwp == NULL) ! 128: { ! 129: RewriteRules[ruleset] = rwp = ! 130: (struct rewrite *) xalloc(sizeof *rwp); ! 131: } ! 132: else ! 133: { ! 134: rwp->r_next = (struct rewrite *) xalloc(sizeof *rwp); ! 135: rwp = rwp->r_next; ! 136: } ! 137: rwp->r_next = NULL; ! 138: ! 139: /* expand and save the LHS */ ! 140: *p = '\0'; ! 141: expand(&buf[1], exbuf, &exbuf[sizeof exbuf], CurEnv); ! 142: rwp->r_lhs = prescan(exbuf, '\t', pvpbuf); ! 143: if (rwp->r_lhs != NULL) ! 144: rwp->r_lhs = copyplist(rwp->r_lhs, TRUE); ! 145: ! 146: /* expand and save the RHS */ ! 147: while (*++p == '\t') ! 148: continue; ! 149: q = p; ! 150: while (*p != '\0' && *p != '\t') ! 151: p++; ! 152: *p = '\0'; ! 153: expand(q, exbuf, &exbuf[sizeof exbuf], CurEnv); ! 154: rwp->r_rhs = prescan(exbuf, '\t', pvpbuf); ! 155: if (rwp->r_rhs != NULL) ! 156: rwp->r_rhs = copyplist(rwp->r_rhs, TRUE); ! 157: break; ! 158: ! 159: case 'S': /* select rewriting set */ ! 160: ruleset = atoi(&buf[1]); ! 161: if (ruleset >= MAXRWSETS || ruleset < 0) ! 162: { ! 163: syserr("bad ruleset %d (%d max)", ruleset, MAXRWSETS); ! 164: ruleset = 0; ! 165: } ! 166: rwp = NULL; ! 167: break; ! 168: ! 169: case 'D': /* macro definition */ ! 170: define(buf[1], newstr(munchstring(&buf[2])), CurEnv); ! 171: break; ! 172: ! 173: case 'H': /* required header line */ ! 174: (void) chompheader(&buf[1], TRUE); ! 175: break; ! 176: ! 177: case 'C': /* word class */ ! 178: case 'F': /* word class from file */ ! 179: /* read list of words from argument or file */ ! 180: if (buf[0] == 'F') ! 181: { ! 182: /* read from file */ ! 183: for (p = &buf[2]; *p != '\0' && !isspace(*p); p++) ! 184: continue; ! 185: if (*p == '\0') ! 186: p = "%s"; ! 187: else ! 188: { ! 189: *p = '\0'; ! 190: while (isspace(*++p)) ! 191: continue; ! 192: } ! 193: fileclass(buf[1], &buf[2], p); ! 194: break; ! 195: } ! 196: ! 197: /* scan the list of words and set class for all */ ! 198: for (p = &buf[2]; *p != '\0'; ) ! 199: { ! 200: register char *wd; ! 201: char delim; ! 202: ! 203: while (*p != '\0' && isspace(*p)) ! 204: p++; ! 205: wd = p; ! 206: while (*p != '\0' && !isspace(*p)) ! 207: p++; ! 208: delim = *p; ! 209: *p = '\0'; ! 210: if (wd[0] != '\0') ! 211: setclass(buf[1], wd); ! 212: *p = delim; ! 213: } ! 214: break; ! 215: ! 216: case 'M': /* define mailer */ ! 217: makemailer(&buf[1]); ! 218: break; ! 219: ! 220: case 'O': /* set option */ ! 221: setoption(buf[1], &buf[2], TRUE, FALSE); ! 222: break; ! 223: ! 224: case 'P': /* set precedence */ ! 225: if (NumPriorities >= MAXPRIORITIES) ! 226: { ! 227: toomany('P', MAXPRIORITIES); ! 228: break; ! 229: } ! 230: for (p = &buf[1]; *p != '\0' && *p != '=' && *p != '\t'; p++) ! 231: continue; ! 232: if (*p == '\0') ! 233: goto badline; ! 234: *p = '\0'; ! 235: Priorities[NumPriorities].pri_name = newstr(&buf[1]); ! 236: Priorities[NumPriorities].pri_val = atoi(++p); ! 237: NumPriorities++; ! 238: break; ! 239: ! 240: case 'T': /* trusted user(s) */ ! 241: p = &buf[1]; ! 242: while (*p != '\0') ! 243: { ! 244: while (isspace(*p)) ! 245: p++; ! 246: q = p; ! 247: while (*p != '\0' && !isspace(*p)) ! 248: p++; ! 249: if (*p != '\0') ! 250: *p++ = '\0'; ! 251: if (*q == '\0') ! 252: continue; ! 253: for (pv = TrustedUsers; *pv != NULL; pv++) ! 254: continue; ! 255: if (pv >= &TrustedUsers[MAXTRUST]) ! 256: { ! 257: toomany('T', MAXTRUST); ! 258: break; ! 259: } ! 260: *pv = newstr(q); ! 261: } ! 262: break; ! 263: ! 264: default: ! 265: badline: ! 266: syserr("unknown control line \"%s\"", buf); ! 267: } ! 268: } ! 269: FileName = NULL; ! 270: } ! 271: /* ! 272: ** TOOMANY -- signal too many of some option ! 273: ** ! 274: ** Parameters: ! 275: ** id -- the id of the error line ! 276: ** maxcnt -- the maximum possible values ! 277: ** ! 278: ** Returns: ! 279: ** none. ! 280: ** ! 281: ** Side Effects: ! 282: ** gives a syserr. ! 283: */ ! 284: ! 285: toomany(id, maxcnt) ! 286: char id; ! 287: int maxcnt; ! 288: { ! 289: syserr("too many %c lines, %d max", id, maxcnt); ! 290: } ! 291: /* ! 292: ** FILECLASS -- read members of a class from a file ! 293: ** ! 294: ** Parameters: ! 295: ** class -- class to define. ! 296: ** filename -- name of file to read. ! 297: ** fmt -- scanf string to use for match. ! 298: ** ! 299: ** Returns: ! 300: ** none ! 301: ** ! 302: ** Side Effects: ! 303: ** ! 304: ** puts all lines in filename that match a scanf into ! 305: ** the named class. ! 306: */ ! 307: ! 308: fileclass(class, filename, fmt) ! 309: int class; ! 310: char *filename; ! 311: char *fmt; ! 312: { ! 313: FILE *f; ! 314: char buf[MAXLINE]; ! 315: ! 316: f = fopen(filename, "r"); ! 317: if (f == NULL) ! 318: { ! 319: syserr("cannot open %s", filename); ! 320: return; ! 321: } ! 322: ! 323: while (fgets(buf, sizeof buf, f) != NULL) ! 324: { ! 325: register STAB *s; ! 326: register char *p; ! 327: # ifdef SCANF ! 328: char wordbuf[MAXNAME+1]; ! 329: ! 330: if (sscanf(buf, fmt, wordbuf) != 1) ! 331: continue; ! 332: p = wordbuf; ! 333: # else SCANF ! 334: p = buf; ! 335: # endif SCANF ! 336: ! 337: /* ! 338: ** Break up the match into words. ! 339: */ ! 340: ! 341: while (*p != '\0') ! 342: { ! 343: register char *q; ! 344: ! 345: /* strip leading spaces */ ! 346: while (isspace(*p)) ! 347: p++; ! 348: if (*p == '\0') ! 349: break; ! 350: ! 351: /* find the end of the word */ ! 352: q = p; ! 353: while (*p != '\0' && !isspace(*p)) ! 354: p++; ! 355: if (*p != '\0') ! 356: *p++ = '\0'; ! 357: ! 358: /* enter the word in the symbol table */ ! 359: s = stab(q, ST_CLASS, ST_ENTER); ! 360: setbitn(class, s->s_class); ! 361: } ! 362: } ! 363: ! 364: (void) fclose(f); ! 365: } ! 366: /* ! 367: ** MAKEMAILER -- define a new mailer. ! 368: ** ! 369: ** Parameters: ! 370: ** line -- description of mailer. This is in labeled ! 371: ** fields. The fields are: ! 372: ** P -- the path to the mailer ! 373: ** F -- the flags associated with the mailer ! 374: ** A -- the argv for this mailer ! 375: ** S -- the sender rewriting set ! 376: ** R -- the recipient rewriting set ! 377: ** E -- the eol string ! 378: ** The first word is the canonical name of the mailer. ! 379: ** ! 380: ** Returns: ! 381: ** none. ! 382: ** ! 383: ** Side Effects: ! 384: ** enters the mailer into the mailer table. ! 385: */ ! 386: ! 387: makemailer(line) ! 388: char *line; ! 389: { ! 390: register char *p; ! 391: register struct mailer *m; ! 392: register STAB *s; ! 393: int i; ! 394: char fcode; ! 395: extern int NextMailer; ! 396: extern char **makeargv(); ! 397: extern char *munchstring(); ! 398: extern char *DelimChar; ! 399: extern long atol(); ! 400: ! 401: /* allocate a mailer and set up defaults */ ! 402: m = (struct mailer *) xalloc(sizeof *m); ! 403: bzero((char *) m, sizeof *m); ! 404: m->m_mno = NextMailer; ! 405: m->m_eol = "\n"; ! 406: ! 407: /* collect the mailer name */ ! 408: for (p = line; *p != '\0' && *p != ',' && !isspace(*p); p++) ! 409: continue; ! 410: if (*p != '\0') ! 411: *p++ = '\0'; ! 412: m->m_name = newstr(line); ! 413: ! 414: /* now scan through and assign info from the fields */ ! 415: while (*p != '\0') ! 416: { ! 417: while (*p != '\0' && (*p == ',' || isspace(*p))) ! 418: p++; ! 419: ! 420: /* p now points to field code */ ! 421: fcode = *p; ! 422: while (*p != '\0' && *p != '=' && *p != ',') ! 423: p++; ! 424: if (*p++ != '=') ! 425: { ! 426: syserr("`=' expected"); ! 427: return; ! 428: } ! 429: while (isspace(*p)) ! 430: p++; ! 431: ! 432: /* p now points to the field body */ ! 433: p = munchstring(p); ! 434: ! 435: /* install the field into the mailer struct */ ! 436: switch (fcode) ! 437: { ! 438: case 'P': /* pathname */ ! 439: m->m_mailer = newstr(p); ! 440: break; ! 441: ! 442: case 'F': /* flags */ ! 443: for (; *p != '\0'; p++) ! 444: setbitn(*p, m->m_flags); ! 445: break; ! 446: ! 447: case 'S': /* sender rewriting ruleset */ ! 448: case 'R': /* recipient rewriting ruleset */ ! 449: i = atoi(p); ! 450: if (i < 0 || i >= MAXRWSETS) ! 451: { ! 452: syserr("invalid rewrite set, %d max", MAXRWSETS); ! 453: return; ! 454: } ! 455: if (fcode == 'S') ! 456: m->m_s_rwset = i; ! 457: else ! 458: m->m_r_rwset = i; ! 459: break; ! 460: ! 461: case 'E': /* end of line string */ ! 462: m->m_eol = newstr(p); ! 463: break; ! 464: ! 465: case 'A': /* argument vector */ ! 466: m->m_argv = makeargv(p); ! 467: break; ! 468: ! 469: case 'M': /* maximum message size */ ! 470: m->m_maxsize = atol(p); ! 471: break; ! 472: } ! 473: ! 474: p = DelimChar; ! 475: } ! 476: ! 477: /* now store the mailer away */ ! 478: if (NextMailer >= MAXMAILERS) ! 479: { ! 480: syserr("too many mailers defined (%d max)", MAXMAILERS); ! 481: return; ! 482: } ! 483: Mailer[NextMailer++] = m; ! 484: s = stab(m->m_name, ST_MAILER, ST_ENTER); ! 485: s->s_mailer = m; ! 486: } ! 487: /* ! 488: ** MUNCHSTRING -- translate a string into internal form. ! 489: ** ! 490: ** Parameters: ! 491: ** p -- the string to munch. ! 492: ** ! 493: ** Returns: ! 494: ** the munched string. ! 495: ** ! 496: ** Side Effects: ! 497: ** Sets "DelimChar" to point to the string that caused us ! 498: ** to stop. ! 499: */ ! 500: ! 501: char * ! 502: munchstring(p) ! 503: register char *p; ! 504: { ! 505: register char *q; ! 506: bool backslash = FALSE; ! 507: bool quotemode = FALSE; ! 508: static char buf[MAXLINE]; ! 509: extern char *DelimChar; ! 510: ! 511: for (q = buf; *p != '\0'; p++) ! 512: { ! 513: if (backslash) ! 514: { ! 515: /* everything is roughly literal */ ! 516: backslash = FALSE; ! 517: switch (*p) ! 518: { ! 519: case 'r': /* carriage return */ ! 520: *q++ = '\r'; ! 521: continue; ! 522: ! 523: case 'n': /* newline */ ! 524: *q++ = '\n'; ! 525: continue; ! 526: ! 527: case 'f': /* form feed */ ! 528: *q++ = '\f'; ! 529: continue; ! 530: ! 531: case 'b': /* backspace */ ! 532: *q++ = '\b'; ! 533: continue; ! 534: } ! 535: *q++ = *p; ! 536: } ! 537: else ! 538: { ! 539: if (*p == '\\') ! 540: backslash = TRUE; ! 541: else if (*p == '"') ! 542: quotemode = !quotemode; ! 543: else if (quotemode || *p != ',') ! 544: *q++ = *p; ! 545: else ! 546: break; ! 547: } ! 548: } ! 549: ! 550: DelimChar = p; ! 551: *q++ = '\0'; ! 552: return (buf); ! 553: } ! 554: /* ! 555: ** MAKEARGV -- break up a string into words ! 556: ** ! 557: ** Parameters: ! 558: ** p -- the string to break up. ! 559: ** ! 560: ** Returns: ! 561: ** a char **argv (dynamically allocated) ! 562: ** ! 563: ** Side Effects: ! 564: ** munges p. ! 565: */ ! 566: ! 567: char ** ! 568: makeargv(p) ! 569: register char *p; ! 570: { ! 571: char *q; ! 572: int i; ! 573: char **avp; ! 574: char *argv[MAXPV + 1]; ! 575: ! 576: /* take apart the words */ ! 577: i = 0; ! 578: while (*p != '\0' && i < MAXPV) ! 579: { ! 580: q = p; ! 581: while (*p != '\0' && !isspace(*p)) ! 582: p++; ! 583: while (isspace(*p)) ! 584: *p++ = '\0'; ! 585: argv[i++] = newstr(q); ! 586: } ! 587: argv[i++] = NULL; ! 588: ! 589: /* now make a copy of the argv */ ! 590: avp = (char **) xalloc(sizeof *avp * i); ! 591: bcopy((char *) argv, (char *) avp, sizeof *avp * i); ! 592: ! 593: return (avp); ! 594: } ! 595: /* ! 596: ** PRINTRULES -- print rewrite rules (for debugging) ! 597: ** ! 598: ** Parameters: ! 599: ** none. ! 600: ** ! 601: ** Returns: ! 602: ** none. ! 603: ** ! 604: ** Side Effects: ! 605: ** prints rewrite rules. ! 606: */ ! 607: ! 608: printrules() ! 609: { ! 610: register struct rewrite *rwp; ! 611: register int ruleset; ! 612: ! 613: for (ruleset = 0; ruleset < 10; ruleset++) ! 614: { ! 615: if (RewriteRules[ruleset] == NULL) ! 616: continue; ! 617: printf("\n----Rule Set %d:", ruleset); ! 618: ! 619: for (rwp = RewriteRules[ruleset]; rwp != NULL; rwp = rwp->r_next) ! 620: { ! 621: printf("\nLHS:"); ! 622: printav(rwp->r_lhs); ! 623: printf("RHS:"); ! 624: printav(rwp->r_rhs); ! 625: } ! 626: } ! 627: } ! 628: ! 629: /* ! 630: ** SETOPTION -- set global processing option ! 631: ** ! 632: ** Parameters: ! 633: ** opt -- option name. ! 634: ** val -- option value (as a text string). ! 635: ** safe -- set if this came from a configuration file. ! 636: ** Some options (if set from the command line) will ! 637: ** reset the user id to avoid security problems. ! 638: ** sticky -- if set, don't let other setoptions override ! 639: ** this value. ! 640: ** ! 641: ** Returns: ! 642: ** none. ! 643: ** ! 644: ** Side Effects: ! 645: ** Sets options as implied by the arguments. ! 646: */ ! 647: ! 648: static BITMAP StickyOpt; /* set if option is stuck */ ! 649: extern char *NetName; /* name of home (local) network */ ! 650: ! 651: setoption(opt, val, safe, sticky) ! 652: char opt; ! 653: char *val; ! 654: bool safe; ! 655: bool sticky; ! 656: { ! 657: extern bool atobool(); ! 658: extern time_t convtime(); ! 659: extern int QueueLA; ! 660: extern int RefuseLA; ! 661: extern bool trusteduser(); ! 662: extern char *username(); ! 663: ! 664: if (tTd(37, 1)) ! 665: printf("setoption %c=%s", opt, val); ! 666: ! 667: /* ! 668: ** See if this option is preset for us. ! 669: */ ! 670: ! 671: if (bitnset(opt, StickyOpt)) ! 672: { ! 673: if (tTd(37, 1)) ! 674: printf(" (ignored)\n"); ! 675: return; ! 676: } ! 677: ! 678: /* ! 679: ** Check to see if this option can be specified by this user. ! 680: */ ! 681: ! 682: if (!safe && getuid() == 0) ! 683: safe = TRUE; ! 684: if (!safe && index("deiLmorsv", opt) == NULL) ! 685: { ! 686: if (opt != 'M' || (val[0] != 'r' && val[0] != 's')) ! 687: { ! 688: if (tTd(37, 1)) ! 689: printf(" (unsafe)"); ! 690: if (getuid() != geteuid()) ! 691: { ! 692: printf("(Resetting uid)\n"); ! 693: (void) setgid(getgid()); ! 694: (void) setuid(getuid()); ! 695: } ! 696: } ! 697: } ! 698: else if (tTd(37, 1)) ! 699: printf("\n"); ! 700: ! 701: switch (opt) ! 702: { ! 703: case 'A': /* set default alias file */ ! 704: if (val[0] == '\0') ! 705: AliasFile = "aliases"; ! 706: else ! 707: AliasFile = newstr(val); ! 708: break; ! 709: ! 710: case 'a': /* look N minutes for "@:@" in alias file */ ! 711: if (val[0] == '\0') ! 712: SafeAlias = 5; ! 713: else ! 714: SafeAlias = atoi(val); ! 715: break; ! 716: ! 717: case 'B': /* substitution for blank character */ ! 718: SpaceSub = val[0]; ! 719: if (SpaceSub == '\0') ! 720: SpaceSub = ' '; ! 721: break; ! 722: ! 723: case 'c': /* don't connect to "expensive" mailers */ ! 724: NoConnect = atobool(val); ! 725: break; ! 726: ! 727: case 'C': /* checkpoint after N connections */ ! 728: CheckPointLimit = atoi(val); ! 729: break; ! 730: ! 731: case 'd': /* delivery mode */ ! 732: switch (*val) ! 733: { ! 734: case '\0': ! 735: SendMode = SM_DELIVER; ! 736: break; ! 737: ! 738: case SM_QUEUE: /* queue only */ ! 739: #ifndef QUEUE ! 740: syserr("need QUEUE to set -odqueue"); ! 741: #endif QUEUE ! 742: /* fall through..... */ ! 743: ! 744: case SM_DELIVER: /* do everything */ ! 745: case SM_FORK: /* fork after verification */ ! 746: SendMode = *val; ! 747: break; ! 748: ! 749: default: ! 750: syserr("Unknown delivery mode %c", *val); ! 751: exit(EX_USAGE); ! 752: } ! 753: break; ! 754: ! 755: case 'D': /* rebuild alias database as needed */ ! 756: AutoRebuild = atobool(val); ! 757: break; ! 758: ! 759: case 'e': /* set error processing mode */ ! 760: switch (*val) ! 761: { ! 762: case EM_QUIET: /* be silent about it */ ! 763: case EM_MAIL: /* mail back */ ! 764: case EM_BERKNET: /* do berknet error processing */ ! 765: case EM_WRITE: /* write back (or mail) */ ! 766: HoldErrs = TRUE; ! 767: /* fall through... */ ! 768: ! 769: case EM_PRINT: /* print errors normally (default) */ ! 770: ErrorMode = *val; ! 771: break; ! 772: } ! 773: break; ! 774: ! 775: case 'F': /* file mode */ ! 776: FileMode = atooct(val) & 0777; ! 777: break; ! 778: ! 779: case 'f': /* save Unix-style From lines on front */ ! 780: SaveFrom = atobool(val); ! 781: break; ! 782: ! 783: case 'g': /* default gid */ ! 784: DefGid = atoi(val); ! 785: break; ! 786: ! 787: case 'H': /* help file */ ! 788: if (val[0] == '\0') ! 789: HelpFile = "sendmail.hf"; ! 790: else ! 791: HelpFile = newstr(val); ! 792: break; ! 793: ! 794: case 'I': /* use internet domain name server */ ! 795: UseNameServer = atobool(val); ! 796: break; ! 797: ! 798: case 'i': /* ignore dot lines in message */ ! 799: IgnrDot = atobool(val); ! 800: break; ! 801: ! 802: case 'L': /* log level */ ! 803: LogLevel = atoi(val); ! 804: break; ! 805: ! 806: case 'M': /* define macro */ ! 807: define(val[0], newstr(&val[1]), CurEnv); ! 808: sticky = FALSE; ! 809: break; ! 810: ! 811: case 'm': /* send to me too */ ! 812: MeToo = atobool(val); ! 813: break; ! 814: ! 815: case 'n': /* validate RHS in newaliases */ ! 816: CheckAliases = atobool(val); ! 817: break; ! 818: ! 819: # ifdef DAEMON ! 820: case 'N': /* home (local?) network name */ ! 821: NetName = newstr(val); ! 822: break; ! 823: # endif DAEMON ! 824: ! 825: case 'o': /* assume old style headers */ ! 826: if (atobool(val)) ! 827: CurEnv->e_flags |= EF_OLDSTYLE; ! 828: else ! 829: CurEnv->e_flags &= ~EF_OLDSTYLE; ! 830: break; ! 831: ! 832: case 'P': /* postmaster copy address for returned mail */ ! 833: PostMasterCopy = newstr(val); ! 834: break; ! 835: ! 836: case 'q': /* slope of queue only function */ ! 837: QueueFactor = atoi(val); ! 838: break; ! 839: ! 840: case 'Q': /* queue directory */ ! 841: if (val[0] == '\0') ! 842: QueueDir = "mqueue"; ! 843: else ! 844: QueueDir = newstr(val); ! 845: break; ! 846: ! 847: case 'r': /* read timeout */ ! 848: ReadTimeout = convtime(val); ! 849: break; ! 850: ! 851: case 'S': /* status file */ ! 852: if (val[0] == '\0') ! 853: StatFile = "sendmail.st"; ! 854: else ! 855: StatFile = newstr(val); ! 856: break; ! 857: ! 858: case 's': /* be super safe, even if expensive */ ! 859: SuperSafe = atobool(val); ! 860: break; ! 861: ! 862: case 'T': /* queue timeout */ ! 863: TimeOut = convtime(val); ! 864: /*FALLTHROUGH*/ ! 865: ! 866: case 't': /* time zone name */ ! 867: break; ! 868: ! 869: case 'u': /* set default uid */ ! 870: DefUid = atoi(val); ! 871: setdefuser(); ! 872: break; ! 873: ! 874: case 'v': /* run in verbose mode */ ! 875: Verbose = atobool(val); ! 876: break; ! 877: ! 878: case 'x': /* load avg at which to auto-queue msgs */ ! 879: QueueLA = atoi(val); ! 880: break; ! 881: ! 882: case 'X': /* load avg at which to auto-reject connections */ ! 883: RefuseLA = atoi(val); ! 884: break; ! 885: ! 886: case 'y': /* work recipient factor */ ! 887: WkRecipFact = atoi(val); ! 888: break; ! 889: ! 890: case 'Y': /* fork jobs during queue runs */ ! 891: ForkQueueRuns = atobool(val); ! 892: break; ! 893: ! 894: case 'z': /* work message class factor */ ! 895: WkClassFact = atoi(val); ! 896: break; ! 897: ! 898: case 'Z': /* work time factor */ ! 899: WkTimeFact = atoi(val); ! 900: break; ! 901: ! 902: default: ! 903: break; ! 904: } ! 905: if (sticky) ! 906: setbitn(opt, StickyOpt); ! 907: return; ! 908: } ! 909: /* ! 910: ** SETCLASS -- set a word into a class ! 911: ** ! 912: ** Parameters: ! 913: ** class -- the class to put the word in. ! 914: ** word -- the word to enter ! 915: ** ! 916: ** Returns: ! 917: ** none. ! 918: ** ! 919: ** Side Effects: ! 920: ** puts the word into the symbol table. ! 921: */ ! 922: ! 923: setclass(class, word) ! 924: int class; ! 925: char *word; ! 926: { ! 927: register STAB *s; ! 928: ! 929: s = stab(word, ST_CLASS, ST_ENTER); ! 930: setbitn(class, s->s_class); ! 931: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.