Return to readcf.c CVS log

Up to [CSRG BSD Unix] / 42BSD / usr.lib / sendmail / src

Annotation of 42BSD/usr.lib/sendmail/src/readcf.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.