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