![[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.