![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cfparse.y CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mrouted|
Return to cfparse.y CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mrouted |
1.1 misho 1: %{
2: /*
3: * Configuration file parser for mrouted.
4: *
5: * Written by Bill Fenner, NRL, 1994
6: *
7: * cfparse.y,v 3.8.4.30 1998/03/01 01:48:58 fenner Exp
8: */
9: #include <stdio.h>
10: #include <stdarg.h>
11: #include "defs.h"
12: #include <netdb.h>
13: #include <ifaddrs.h>
14:
15: /*
16: * Local function declarations
17: */
18: static void fatal(char *fmt, ...);
19: static void warn(char *fmt, ...);
20: static void yyerror(char *s);
21: static char * next_word(void);
22: static int yylex(void);
23: static u_int32 valid_if(char *s);
24: static const char * ifconfaddr(u_int32_t a);
25: int yyparse(void);
26:
27: static FILE *f;
28:
29: char *configfilename = _PATH_MROUTED_CONF;
30:
31: extern int cache_lifetime;
32: extern int prune_lifetime;
33:
34: int allow_black_holes = 0;
35:
36: static int lineno;
37:
38: static struct uvif *v;
39:
40: static int order, state;
41: static int noflood = 0;
42: static int rexmit = VIFF_REXMIT_PRUNES;
43:
44: struct addrmask {
45: u_int32 addr;
46: int mask;
47: };
48:
49: struct boundnam {
50: char *name;
51: struct addrmask bound;
52: };
53:
54: #define MAXBOUNDS 20
55:
56: struct boundnam boundlist[MAXBOUNDS]; /* Max. of 20 named boundaries */
57: int numbounds = 0; /* Number of named boundaries */
58:
59: %}
60:
61: %union
62: {
63: int num;
64: char *ptr;
65: struct addrmask addrmask;
66: u_int32 addr;
67: struct vf_element *filterelem;
68: };
69:
70: %token CACHE_LIFETIME PRUNE_LIFETIME PRUNING BLACK_HOLE NOFLOOD
71: %token PHYINT TUNNEL NAME
72: %token DISABLE IGMPV1 SRCRT BESIDE
73: %token METRIC THRESHOLD RATE_LIMIT BOUNDARY NETMASK ALTNET ADVERT_METRIC
74: %token FILTER ACCEPT DENY EXACT BIDIR REXMIT_PRUNES REXMIT_PRUNES2
75: %token PASSIVE ALLOW_NONPRUNERS
76: %token NOTRANSIT BLASTER FORCE_LEAF
77: %token PRUNE_LIFETIME2 NOFLOOD2
78: %token SYSNAM SYSCONTACT SYSVERSION SYSLOCATION
79: %token <num> BOOLEAN
80: %token <num> NUMBER
81: %token <ptr> STRING
82: %token <addrmask> ADDRMASK
83: %token <addr> ADDR
84:
85: %type <addr> interface addrname
86: %type <addrmask> bound boundary addrmask
87: %type <filterelem> filter filtlist filtelement filtelem
88:
89: %start conf
90:
91: %%
92:
93: conf : stmts
94: ;
95:
96: stmts : /* Empty */
97: | stmts stmt
98: ;
99:
100: stmt : error
101: | PHYINT interface
102: {
103: vifi_t vifi;
104:
105: state++;
106:
107: if (order)
108: fatal("phyints must appear before tunnels");
109:
110: for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
111: if (!(v->uv_flags & VIFF_TUNNEL) && $2 == v->uv_lcl_addr)
112: break;
113: }
114:
115: if (vifi == numvifs)
116: fatal("%s is not a configured interface", inet_fmt($2, s1, sizeof(s1)));
117: }
118: ifmods
119: | TUNNEL interface addrname
120: {
121: const char *ifname;
122: struct ifreq ffr;
123: vifi_t vifi;
124:
125: order++;
126:
127: ifname = ifconfaddr($2);
128: if (ifname == 0)
129: fatal("Tunnel local address %s is not mine", inet_fmt($2, s1, sizeof(s1)));
130:
131: if (((ntohl($2) & IN_CLASSA_NET) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET)
132: fatal("Tunnel local address %s is a loopback address", inet_fmt($2, s1, sizeof(s1)));
133:
134: if (ifconfaddr($3) != NULL)
135: fatal("Tunnel remote address %s is one of mine", inet_fmt($3, s1, sizeof(s1)));
136:
137: for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
138: if (v->uv_flags & VIFF_TUNNEL) {
139: if ($3 == v->uv_rmt_addr)
140: fatal("Duplicate tunnel to %s",
141: inet_fmt($3, s1, sizeof(s1)));
142: } else if (!(v->uv_flags & VIFF_DISABLED)) {
143: if (($3 & v->uv_subnetmask) == v->uv_subnet)
144: fatal("Unnecessary tunnel to %s, same subnet as vif %d (%s)",
145: inet_fmt($3, s1, sizeof(s1)), vifi, v->uv_name);
146: }
147: }
148:
149: if (numvifs == MAXVIFS)
150: fatal("too many vifs");
151:
152: strlcpy(ffr.ifr_name, ifname, sizeof(ffr.ifr_name));
153: if (ioctl(udp_socket, SIOCGIFFLAGS, (char *)&ffr)<0)
154: fatal("ioctl SIOCGIFFLAGS on %s", ffr.ifr_name);
155:
156: v = &uvifs[numvifs];
157: zero_vif(v, 1);
158: v->uv_flags = VIFF_TUNNEL | rexmit | noflood;
159: v->uv_flags |= VIFF_OTUNNEL; /*XXX*/
160: v->uv_lcl_addr = $2;
161: v->uv_rmt_addr = $3;
162: v->uv_dst_addr = $3;
163: strlcpy(v->uv_name, ffr.ifr_name, sizeof(v->uv_name));
164:
165: if (!(ffr.ifr_flags & IFF_UP)) {
166: v->uv_flags |= VIFF_DOWN;
167: vifs_down = TRUE;
168: }
169: }
170: tunnelmods
171: {
172: if (!(v->uv_flags & VIFF_OTUNNEL))
173: init_ipip_on_vif(v);
174:
175: logit(LOG_INFO, 0, "installing tunnel from %s to %s as vif #%u - rate=%d",
176: inet_fmt($2, s1, sizeof(s1)), inet_fmt($3, s2, sizeof(s2)),
177: numvifs, v->uv_rate_limit);
178:
179: ++numvifs;
180:
181: }
182: | CACHE_LIFETIME NUMBER
183: {
184: if ($2 < MIN_CACHE_LIFETIME)
185: warn("cache_lifetime %d must be at least %d", $2, MIN_CACHE_LIFETIME);
186: else
187: cache_lifetime = $2;
188: }
189: | PRUNE_LIFETIME NUMBER
190: {
191: if ($2 < MIN_PRUNE_LIFETIME)
192: warn("prune_lifetime %d must be at least %d", $2, MIN_PRUNE_LIFETIME);
193: else
194: prune_lifetime = $2;
195: }
196: | PRUNING BOOLEAN
197: {
198: if ($2 != 1)
199: warn("Disabling pruning is no longer supported");
200: }
201: | BLACK_HOLE
202: {
203: #ifdef ALLOW_BLACK_HOLES
204: allow_black_holes = 1;
205: #endif
206: }
207: /*
208: * Turn off initial flooding (until subordinateness is learned
209: * via route exchange) on all phyints and set the default for
210: * all further tunnels.
211: */
212: | NOFLOOD
213: {
214: vifi_t vifi;
215:
216: noflood = VIFF_NOFLOOD;
217: for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v)
218: v->uv_flags |= VIFF_NOFLOOD;
219: }
220: /*
221: * Turn on prune retransmission on all interfaces.
222: * Tunnels default to retransmitting, so this just
223: * needs to turn on phyints.
224: */
225: | REXMIT_PRUNES
226: {
227: vifi_t vifi;
228:
229: for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v)
230: v->uv_flags |= VIFF_REXMIT_PRUNES;
231: }
232: /*
233: * If true, do as above. If false, no need to turn
234: * it off for phyints since they default to not
235: * rexmit; need to set flag to not rexmit on tunnels.
236: */
237: | REXMIT_PRUNES BOOLEAN
238: {
239: if ($2) {
240: vifi_t vifi;
241:
242: for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v)
243: v->uv_flags |= VIFF_REXMIT_PRUNES;
244: } else {
245: rexmit = 0;
246: }
247: }
248: | NAME STRING boundary
249: {
250: size_t len = strlen($2) + 1;
251: if (numbounds >= MAXBOUNDS) {
252: fatal("Too many named boundaries (max %d)", MAXBOUNDS);
253: }
254:
255: boundlist[numbounds].name = malloc(len);
256: strlcpy(boundlist[numbounds].name, $2, len);
257: boundlist[numbounds++].bound = $3;
258: }
259: | SYSNAM STRING
260: {
261: #ifdef SNMP
262: set_sysName($2);
263: #endif /* SNMP */
264: }
265: | SYSCONTACT STRING
266: {
267: #ifdef SNMP
268: set_sysContact($2);
269: #endif /* SNMP */
270: }
271: | SYSVERSION STRING
272: {
273: #ifdef SNMP
274: set_sysVersion($2);
275: #endif /* SNMP */
276: }
277: | SYSLOCATION STRING
278: {
279: #ifdef SNMP
280: set_sysLocation($2);
281: #endif /* SNMP */
282: }
283: ;
284:
285: tunnelmods : /* empty */
286: | tunnelmods tunnelmod
287: ;
288:
289: tunnelmod : mod
290: | BESIDE
291: {
292: v->uv_flags |= VIFF_OTUNNEL;
293: }
294: | BESIDE BOOLEAN
295: {
296: if ($2)
297: v->uv_flags |= VIFF_OTUNNEL;
298: else
299: v->uv_flags &= ~VIFF_OTUNNEL;
300: }
301: | SRCRT
302: {
303: fatal("Source-route tunnels not supported");
304: }
305: ;
306:
307: ifmods : /* empty */
308: | ifmods ifmod
309: ;
310:
311: ifmod : mod
312: | DISABLE { v->uv_flags |= VIFF_DISABLED; }
313: | IGMPV1 { v->uv_flags |= VIFF_IGMPV1; }
314: | NETMASK addrname
315: {
316: u_int32 subnet, mask;
317:
318: mask = $2;
319: subnet = v->uv_lcl_addr & mask;
320: if (!inet_valid_subnet(subnet, mask))
321: fatal("Invalid netmask");
322: v->uv_subnet = subnet;
323: v->uv_subnetmask = mask;
324: v->uv_subnetbcast = subnet | ~mask;
325: }
326: | NETMASK
327: {
328: warn("Expected address after netmask keyword, ignored");
329: }
330: | ALTNET addrmask
331: {
332: struct phaddr *ph;
333:
334: ph = (struct phaddr *)malloc(sizeof(struct phaddr));
335: if (ph == NULL)
336: fatal("out of memory");
337:
338: if ($2.mask) {
339: VAL_TO_MASK(ph->pa_subnetmask, $2.mask);
340: } else {
341: ph->pa_subnetmask = v->uv_subnetmask;
342: }
343:
344: ph->pa_subnet = $2.addr & ph->pa_subnetmask;
345: ph->pa_subnetbcast = ph->pa_subnet | ~ph->pa_subnetmask;
346:
347: if ($2.addr & ~ph->pa_subnetmask)
348: warn("Extra subnet %s/%d has host bits set",
349: inet_fmt($2.addr, s1, sizeof(s1)), $2.mask);
350:
351: ph->pa_next = v->uv_addrs;
352: v->uv_addrs = ph;
353: }
354: | ALTNET
355: {
356: warn("Expected address after altnet keyword, ignored");
357: }
358: | FORCE_LEAF
359: {
360: v->uv_flags |= VIFF_FORCE_LEAF;
361: }
362: | FORCE_LEAF BOOLEAN
363: {
364: if ($2)
365: v->uv_flags |= VIFF_FORCE_LEAF;
366: else
367: v->uv_flags &= ~VIFF_FORCE_LEAF;
368: }
369: ;
370:
371: mod : THRESHOLD NUMBER
372: {
373: if ($2 < 1 || $2 > 255)
374: fatal("Invalid threshold %d",$2);
375: v->uv_threshold = $2;
376: }
377: | THRESHOLD
378: {
379: warn("Expected number after threshold keyword, ignored");
380: }
381: | METRIC NUMBER
382: {
383: if ($2 < 1 || $2 > UNREACHABLE)
384: fatal("Invalid metric %d",$2);
385: v->uv_metric = $2;
386: }
387: | METRIC
388: {
389: warn("Expected number after metric keyword, ignored");
390: }
391: | ADVERT_METRIC NUMBER
392: {
393: if ($2 < 0 || $2 > UNREACHABLE - 1)
394: fatal("Invalid advert_metric %d", $2);
395: v->uv_admetric = $2;
396: }
397: | ADVERT_METRIC
398: {
399: warn("Expected number after advert_metric keyword, ignored");
400: }
401: | RATE_LIMIT NUMBER
402: {
403: if ($2 > MAX_RATE_LIMIT)
404: fatal("Invalid rate_limit %d",$2);
405: v->uv_rate_limit = $2;
406: }
407: | RATE_LIMIT
408: {
409: warn("Expected number after rate_limit keyword, ignored");
410: }
411: | BOUNDARY bound
412: {
413: struct vif_acl *v_acl;
414:
415: v_acl = (struct vif_acl *)malloc(sizeof(struct vif_acl));
416: if (v_acl == NULL)
417: fatal("out of memory");
418:
419: VAL_TO_MASK(v_acl->acl_mask, $2.mask);
420: v_acl->acl_addr = $2.addr & v_acl->acl_mask;
421: if ($2.addr & ~v_acl->acl_mask)
422: warn("Boundary spec %s/%d has host bits set",
423: inet_fmt($2.addr, s1, sizeof(s1)), $2.mask);
424: v_acl->acl_next = v->uv_acl;
425: v->uv_acl = v_acl;
426: }
427: | BOUNDARY
428: {
429: warn("Expected boundary spec after boundary keyword, ignored");
430: }
431: | REXMIT_PRUNES2
432: {
433: v->uv_flags |= VIFF_REXMIT_PRUNES;
434: }
435: | REXMIT_PRUNES2 BOOLEAN
436: {
437: if ($2)
438: v->uv_flags |= VIFF_REXMIT_PRUNES;
439: else
440: v->uv_flags &= ~VIFF_REXMIT_PRUNES;
441: }
442: | PASSIVE
443: {
444: v->uv_flags |= VIFF_PASSIVE;
445: }
446: | NOFLOOD2
447: {
448: v->uv_flags |= VIFF_NOFLOOD;
449: }
450: | NOTRANSIT
451: {
452: v->uv_flags |= VIFF_NOTRANSIT;
453: }
454: | BLASTER
455: {
456: v->uv_flags |= VIFF_BLASTER;
457: blaster_alloc(v - uvifs);
458: }
459: | ALLOW_NONPRUNERS
460: {
461: v->uv_flags |= VIFF_ALLOW_NONPRUNERS;
462: }
463: | PRUNE_LIFETIME2 NUMBER
464: {
465: if ($2 < MIN_PRUNE_LIFETIME)
466: warn("prune_lifetime %d must be at least %d", $2, MIN_PRUNE_LIFETIME);
467: else
468: v->uv_prune_lifetime = $2;
469: }
470: | ACCEPT filter
471: {
472: if (v->uv_filter == NULL) {
473: struct vif_filter *v_filter;
474:
475: v_filter = (struct vif_filter *)malloc(sizeof(struct vif_filter));
476: if (v_filter == NULL)
477: fatal("out of memory");
478:
479: v_filter->vf_flags = 0;
480: v_filter->vf_type = VFT_ACCEPT;
481: v_filter->vf_filter = $2;
482: v->uv_filter = v_filter;
483: } else if (v->uv_filter->vf_type != VFT_ACCEPT) {
484: fatal("Cannot accept and deny");
485: } else {
486: struct vf_element *p;
487:
488: p = v->uv_filter->vf_filter;
489: while (p->vfe_next)
490: p = p->vfe_next;
491: p->vfe_next = $2;
492: }
493: }
494: | ACCEPT
495: {
496: warn("Expected filter spec after accept keyword, ignored");
497: }
498: | DENY filter
499: {
500: if (v->uv_filter == NULL) {
501: struct vif_filter *v_filter;
502:
503: v_filter = (struct vif_filter *)malloc(sizeof(struct vif_filter));
504: if (v_filter == NULL)
505: fatal("out of memory");
506:
507: v_filter->vf_flags = 0;
508: v_filter->vf_type = VFT_DENY;
509: v_filter->vf_filter = $2;
510: v->uv_filter = v_filter;
511: } else if (v->uv_filter->vf_type != VFT_DENY) {
512: fatal("Cannot accept and deny");
513: } else {
514: struct vf_element *p;
515:
516: p = v->uv_filter->vf_filter;
517: while (p->vfe_next)
518: p = p->vfe_next;
519: p->vfe_next = $2;
520: }
521: }
522: | DENY
523: {
524: warn("Expected filter spec after deny keyword, ignored");
525: }
526: | BIDIR
527: {
528: if (v->uv_filter == NULL)
529: fatal("bidir goes after filters");
530: v->uv_filter->vf_flags |= VFF_BIDIR;
531: }
532: ;
533:
534: interface: ADDR
535: {
536: $$ = $1;
537: }
538: | STRING
539: {
540: $$ = valid_if($1);
541: if ($$ == 0)
542: fatal("Invalid interface name %s",$1);
543: }
544: ;
545:
546: addrname: ADDR
547: {
548: $$ = $1;
549: }
550: | STRING
551: {
552: struct hostent *hp;
553:
554: if ((hp = gethostbyname($1)) == NULL || hp->h_length != sizeof($$))
555: fatal("No such host %s", $1);
556:
557: if (hp->h_addr_list[1])
558: fatal("Hostname %s does not %s", $1, "map to a unique address");
559:
560: memmove (&$$, hp->h_addr_list[0], hp->h_length);
561: }
562:
563: bound : boundary
564: {
565: $$ = $1;
566: }
567: | STRING
568: {
569: int i;
570:
571: for (i=0; i < numbounds; i++) {
572: if (!strcmp(boundlist[i].name, $1)) {
573: $$ = boundlist[i].bound;
574: break;
575: }
576: }
577:
578: if (i == numbounds)
579: fatal("Invalid boundary name %s",$1);
580: }
581: ;
582:
583: boundary: ADDRMASK
584: {
585: #ifdef ALLOW_BLACK_HOLES
586: if (!allow_black_holes)
587: #endif
588: if ((ntohl($1.addr) & 0xff000000) != 0xef000000) {
589: fatal("Boundaries must be 239.x.x.x, not %s/%d",
590: inet_fmt($1.addr, s1, sizeof(s1)), $1.mask);
591: }
592: $$ = $1;
593: }
594: ;
595:
596: addrmask: ADDRMASK { $$ = $1; }
597: | ADDR { $$.addr = $1; $$.mask = 0; }
598: ;
599:
600: filter : filtlist { $$ = $1; }
601: | STRING { fatal("named filters no implemented yet"); }
602: ;
603:
604: filtlist : filtelement { $$ = $1; }
605: | filtelement filtlist { $1->vfe_next = $2; $$ = $1; }
606: ;
607:
608: filtelement : filtelem { $$ = $1; }
609: | filtelem EXACT { $1->vfe_flags |= VFEF_EXACT; $$ = $1; }
610: ;
611:
612: filtelem : ADDRMASK
613: {
614: struct vf_element *vfe;
615:
616: vfe = (struct vf_element *)malloc(sizeof(struct vf_element));
617: if (vfe == NULL)
618: fatal("out of memory");
619:
620: vfe->vfe_addr = $1.addr;
621: VAL_TO_MASK(vfe->vfe_mask, $1.mask);
622: vfe->vfe_flags = 0;
623: vfe->vfe_next = NULL;
624:
625: $$ = vfe;
626: }
627: %%
628: static void fatal(char *fmt, ...)
629: {
630: va_list ap;
631: char buf[MAXHOSTNAMELEN + 100];
632:
633: va_start(ap, fmt);
634: vsnprintf(buf, sizeof(buf), fmt, ap);
635: va_end(ap);
636:
637: logit(LOG_ERR, 0, "%s: %s near line %d", configfilename, buf, lineno);
638: }
639:
640: static void warn(char *fmt, ...)
641: {
642: va_list ap;
643: char buf[200];
644:
645: va_start(ap, fmt);
646: vsnprintf(buf, sizeof(buf), fmt, ap);
647: va_end(ap);
648:
649: logit(LOG_WARNING, 0, "%s: %s near line %d", configfilename, buf, lineno);
650: }
651:
652: static void yyerror(char *s)
653: {
654: logit(LOG_ERR, 0, "%s: %s near line %d", configfilename, s, lineno);
655: }
656:
657: static char *next_word(void)
658: {
659: static char buf[1024];
660: static char *p=NULL;
661: char *q;
662:
663: while (1) {
664: if (!p || !*p) {
665: lineno++;
666: if (fgets(buf, sizeof(buf), f) == NULL)
667: return NULL;
668: p = buf;
669: }
670: while (*p && (*p == ' ' || *p == '\t')) /* skip whitespace */
671: p++;
672: if (*p == '#') {
673: p = NULL; /* skip comments */
674: continue;
675: }
676: q = p;
677: #ifdef SNMP
678: if (*p == '"') {
679: p++;
680: while (*p && *p != '"' && *p != '\n')
681: p++; /* find next whitespace */
682: if (*p == '"')
683: p++;
684: } else
685: #endif
686: while (*p && *p != ' ' && *p != '\t' && *p != '\n')
687: p++; /* find next whitespace */
688: *p++ = '\0'; /* null-terminate string */
689:
690: if (!*q) {
691: p = NULL;
692: continue; /* if 0-length string, read another line */
693: }
694:
695: return q;
696: }
697: }
698:
699: /*
700: * List of keywords. Must have an empty record at the end to terminate
701: * list. If a second value is specified, the first is used at the beginning
702: * of the file and the second is used while parsing interfaces (e.g. after
703: * the first "phyint" or "tunnel" keyword).
704: */
705: static struct keyword {
706: char *word;
707: int val1;
708: int val2;
709: } words[] = {
710: { "cache_lifetime", CACHE_LIFETIME, 0 },
711: { "prune_lifetime", PRUNE_LIFETIME, PRUNE_LIFETIME2 },
712: { "pruning", PRUNING, 0 },
713: { "phyint", PHYINT, 0 },
714: { "tunnel", TUNNEL, 0 },
715: { "disable", DISABLE, 0 },
716: { "metric", METRIC, 0 },
717: { "advert_metric", ADVERT_METRIC, 0 },
718: { "threshold", THRESHOLD, 0 },
719: { "rate_limit", RATE_LIMIT, 0 },
720: { "force_leaf", FORCE_LEAF, 0 },
721: { "srcrt", SRCRT, 0 },
722: { "sourceroute", SRCRT, 0 },
723: { "boundary", BOUNDARY, 0 },
724: { "netmask", NETMASK, 0 },
725: { "igmpv1", IGMPV1, 0 },
726: { "altnet", ALTNET, 0 },
727: { "name", NAME, 0 },
728: { "accept", ACCEPT, 0 },
729: { "deny", DENY, 0 },
730: { "exact", EXACT, 0 },
731: { "bidir", BIDIR, 0 },
732: { "allow_nonpruners", ALLOW_NONPRUNERS, 0 },
733: #ifdef ALLOW_BLACK_HOLES
734: { "allow_black_holes", BLACK_HOLE, 0 },
735: #endif
736: { "noflood", NOFLOOD, NOFLOOD2 },
737: { "notransit", NOTRANSIT, 0 },
738: { "blaster", BLASTER, 0 },
739: { "rexmit_prunes", REXMIT_PRUNES, REXMIT_PRUNES2 },
740: { "passive", PASSIVE, 0 },
741: { "beside", BESIDE, 0 },
742: #ifdef SNMP
743: { "sysName", SYSNAM, 0 },
744: { "sysContact", SYSCONTACT, 0 },
745: { "sysVersion", SYSVERSION, 0 },
746: { "sysLocation", SYSLOCATION, 0 },
747: #endif
748: { NULL, 0, 0 }
749: };
750:
751:
752: static int yylex(void)
753: {
754: u_int32 addr, n;
755: char *q;
756: struct keyword *w;
757:
758: if ((q = next_word()) == NULL) {
759: return 0;
760: }
761:
762: for (w = words; w->word; w++)
763: if (!strcmp(q, w->word))
764: return (state && w->val2) ? w->val2 : w->val1;
765:
766: if (!strcmp(q,"on") || !strcmp(q,"yes")) {
767: yylval.num = 1;
768: return BOOLEAN;
769: }
770: if (!strcmp(q,"off") || !strcmp(q,"no")) {
771: yylval.num = 0;
772: return BOOLEAN;
773: }
774: if (!strcmp(q,"default")) {
775: yylval.addrmask.mask = 0;
776: yylval.addrmask.addr = 0;
777: return ADDRMASK;
778: }
779: if (sscanf(q,"%[.0-9]/%u%c",s1,&n,s2) == 2) {
780: if ((addr = inet_parse(s1,1)) != 0xffffffff) {
781: yylval.addrmask.mask = n;
782: yylval.addrmask.addr = addr;
783: return ADDRMASK;
784: }
785: /* fall through to returning STRING */
786: }
787: if (sscanf(q,"%[.0-9]%c",s1,s2) == 1) {
788: if ((addr = inet_parse(s1,4)) != 0xffffffff &&
789: inet_valid_host(addr)) {
790: yylval.addr = addr;
791: return ADDR;
792: }
793: }
794: if (sscanf(q,"0x%8x%c", &n, s1) == 1) {
795: yylval.addr = n;
796: return ADDR;
797: }
798: if (sscanf(q,"%u%c",&n,s1) == 1) {
799: yylval.num = n;
800: return NUMBER;
801: }
802: #ifdef SNMP
803: if (*q=='"') {
804: if (q[ strlen(q)-1 ]=='"')
805: q[ strlen(q)-1 ]='\0'; /* trash trailing quote */
806: yylval.ptr = q+1;
807: return STRING;
808: }
809: #endif
810: yylval.ptr = q;
811: return STRING;
812: }
813:
814: void config_vifs_from_file(void)
815: {
816: order = 0;
817: state = 0;
818: numbounds = 0;
819: lineno = 0;
820:
821: if ((f = fopen(configfilename, "r")) == NULL) {
822: if (errno != ENOENT)
823: logit(LOG_ERR, errno, "Cannot open %s", configfilename);
824: return;
825: }
826:
827: yyparse();
828:
829: fclose(f);
830: }
831:
832: static u_int32 valid_if(char *s)
833: {
834: vifi_t vifi;
835: struct uvif *v;
836:
837: for (vifi=0, v=uvifs; vifi<numvifs; vifi++, v++) {
838: if (!strcmp(v->uv_name, s))
839: return v->uv_lcl_addr;
840: }
841:
842: return 0;
843: }
844:
845: static const char *ifconfaddr(u_int32_t a)
846: {
847: static char ifname[IFNAMSIZ];
848: struct ifaddrs *ifap, *ifa;
849:
850: if (getifaddrs(&ifap) != 0)
851: return NULL;
852:
853: for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
854: if (ifa->ifa_addr &&
855: ifa->ifa_addr->sa_family == AF_INET &&
856: ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr == a) {
857: strlcpy(ifname, ifa->ifa_name, sizeof(ifname));
858: freeifaddrs(ifap);
859:
860: return ifname;
861: }
862: }
863:
864: freeifaddrs(ifap);
865:
866: return NULL;
867: }
868:
869: /**
870: * Local Variables:
871: * version-control: t
872: * indent-tabs-mode: t
873: * c-file-style: "ellemtel"
874: * c-basic-offset: 4
875: * End:
876: */