xref: /netbsd/usr.sbin/mrouted/cfparse.y (revision d8302e2d) 
1 %{
2 /*	$NetBSD: cfparse.y,v 1.6 2000/10/11 20:23:53 is Exp $	*/
3 
4 /*
5  * Configuration file parser for mrouted.
6  *
7  * Written by Bill Fenner, NRL, 1994
8  */
9 #include <stdio.h>
10 #ifdef __STDC__
11 #include <stdarg.h>
12 #else
13 #include <string.h>
14 #include <varargs.h>
15 #endif
16 #include "defs.h"
17 #include <netdb.h>
18 
19 /*
20  * Local function declarations
21  */
22 static void		fatal __P((char *fmt, ...))
23     __attribute__((__format__(__printf__, 1, 2)));
24 static void		warn __P((char *fmt, ...))
25         __attribute__((__format__(__printf__, 1, 2)));
26 static void		yyerror __P((char *s));
27 static char *		next_word __P((void));
28 static int		yylex __P((void));
29 static u_int32_t	valid_if __P((char *s));
30 static struct ifreq *	ifconfaddr __P((struct ifconf *ifcp, u_int32_t a));
31 int			yyparse __P((void));
32 
33 static FILE *f __attribute__((__unused__));	/* XXX egcs */
34 extern int udp_socket;
35 char *configfilename = _PATH_MROUTED_CONF;
36 
37 extern int cache_lifetime;
38 extern int max_prune_lifetime;
39 
40 static int lineno;
41 static struct ifreq ifbuf[32];
42 static struct ifconf ifc;
43 
44 static struct uvif *v;
45 
46 static int order;
47 
48 struct addrmask {
49 	u_int32_t	addr;
50 	int	mask;
51 };
52 
53 struct boundnam {
54 	char		*name;
55 	struct addrmask	 bound;
56 };
57 
58 #define MAXBOUNDS 20
59 
60 struct boundnam boundlist[MAXBOUNDS];	/* Max. of 20 named boundaries */
61 int numbounds = 0;			/* Number of named boundaries */
62 
63 %}
64 
65 %union
66 {
67 	int num;
68 	char *ptr;
69 	struct addrmask addrmask;
70 	u_int32_t addr;
71 };
72 
73 %token CACHE_LIFETIME PRUNING
74 %token PHYINT TUNNEL NAME
75 %token DISABLE IGMPV1 SRCRT
76 %token METRIC THRESHOLD RATE_LIMIT BOUNDARY NETMASK ALTNET
77 %token SYSNAM SYSCONTACT SYSVERSION SYSLOCATION
78 %token <num> BOOLEAN
79 %token <num> NUMBER
80 %token <ptr> STRING
81 %token <addrmask> ADDRMASK
82 %token <addr> ADDR
83 
84 %type <addr> interface addrname
85 %type <addrmask> bound boundary addrmask
86 
87 %start conf
88 
89 %%
90 
91 conf	: stmts
92 	;
93 
94 stmts	: /* Empty */
95 	| stmts stmt
96 	;
97 
98 stmt	: error
99 	| PHYINT interface 		{
100 
101 			vifi_t vifi;
102 
103 			if (order)
104 			    fatal("phyints must appear before tunnels");
105 
106 			for (vifi = 0, v = uvifs;
107 			     vifi < numvifs;
108 			     ++vifi, ++v)
109 			    if (!(v->uv_flags & VIFF_TUNNEL) &&
110 				$2 == v->uv_lcl_addr)
111 				break;
112 
113 			if (vifi == numvifs)
114 			    fatal("%s is not a configured interface",
115 				inet_fmt($2,s1));
116 
117 					}
118 		ifmods
119 	| TUNNEL interface addrname	{
120 
121 			struct ifreq *ifr;
122 			struct ifreq ffr;
123 			vifi_t vifi;
124 
125 			order++;
126 
127 			ifr = ifconfaddr(&ifc, $2);
128 			if (ifr == 0)
129 			    fatal("Tunnel local address %s is not mine",
130 				inet_fmt($2, s1));
131 
132 			strncpy(ffr.ifr_name, ifr->ifr_name, IFNAMSIZ);
133 			if (ioctl(udp_socket, SIOCGIFFLAGS, (char *)&ffr)<0)
134 			    fatal("ioctl SIOCGIFFLAGS on %s",ffr.ifr_name);
135 			if (ffr.ifr_flags & IFF_LOOPBACK)
136 			    fatal("Tunnel local address %s is a loopback interface",
137 				inet_fmt($2, s1));
138 
139 			if (ifconfaddr(&ifc, $3) != 0)
140 			    fatal("Tunnel remote address %s is one of mine",
141 				inet_fmt($3, s1));
142 
143 			for (vifi = 0, v = uvifs;
144 			     vifi < numvifs;
145 			     ++vifi, ++v)
146 			    if (v->uv_flags & VIFF_TUNNEL) {
147 				if ($3 == v->uv_rmt_addr)
148 				    fatal("Duplicate tunnel to %s",
149 					inet_fmt($3, s1));
150 			    } else if (!(v->uv_flags & VIFF_DISABLED)) {
151 				if (($3 & v->uv_subnetmask) == v->uv_subnet)
152 				    fatal("Unnecessary tunnel to %s",
153 					inet_fmt($3,s1));
154 			    }
155 
156 			if (numvifs == MAXVIFS)
157 			    fatal("too many vifs");
158 
159 			v = &uvifs[numvifs];
160 			v->uv_flags	= VIFF_TUNNEL;
161 			v->uv_metric	= DEFAULT_METRIC;
162 			v->uv_rate_limit= DEFAULT_TUN_RATE_LIMIT;
163 			v->uv_threshold	= DEFAULT_THRESHOLD;
164 			v->uv_lcl_addr	= $2;
165 			v->uv_rmt_addr	= $3;
166 			v->uv_subnet	= 0;
167 			v->uv_subnetmask= 0;
168 			v->uv_subnetbcast= 0;
169 			strncpy(v->uv_name, ffr.ifr_name, IFNAMSIZ);
170 			v->uv_groups	= NULL;
171 			v->uv_neighbors	= NULL;
172 			v->uv_acl	= NULL;
173 			v->uv_addrs	= NULL;
174 
175 			if (!(ffr.ifr_flags & IFF_UP)) {
176 			    v->uv_flags |= VIFF_DOWN;
177 			    vifs_down = TRUE;
178 			}
179 					}
180 		tunnelmods
181 					{
182 			log(LOG_INFO, 0,
183 			    "installing tunnel from %s to %s as vif #%u - rate=%d",
184 			    inet_fmt($2, s1), inet_fmt($3, s2),
185 			    numvifs, v->uv_rate_limit);
186 
187 			++numvifs;
188 					}
189 	| PRUNING BOOLEAN	    { pruning = $2; }
190 	| CACHE_LIFETIME NUMBER     { cache_lifetime = $2;
191 				      max_prune_lifetime = cache_lifetime * 2;
192 				    }
193 	| NAME STRING boundary	    { if (numbounds >= MAXBOUNDS) {
194 					fatal("Too many named boundaries (max %d)", MAXBOUNDS);
195 				      }
196 
197 				      boundlist[numbounds].name = malloc(strlen($2) + 1);
198 				      strcpy(boundlist[numbounds].name, $2);
199 				      boundlist[numbounds++].bound = $3;
200 				    }
201 	| SYSNAM STRING    {
202 #ifdef SNMP
203 			    set_sysName($2);
204 #endif /* SNMP */
205 			    }
206 	| SYSCONTACT STRING {
207 #ifdef SNMP
208 			    set_sysContact($2);
209 #endif /* SNMP */
210 			    }
211         | SYSVERSION STRING {
212 #ifdef SNMP
213 			    set_sysVersion($2);
214 #endif /* SNMP */
215 			    }
216 	| SYSLOCATION STRING {
217 #ifdef SNMP
218 			    set_sysLocation($2);
219 #endif /* SNMP */
220 			    }
221 	;
222 
223 tunnelmods	: /* empty */
224 	| tunnelmods tunnelmod
225 	;
226 
227 tunnelmod	: mod
228 	| SRCRT			{ fatal("Source-route tunnels not supported"); }
229 	;
230 
231 ifmods	: /* empty */
232 	| ifmods ifmod
233 	;
234 
235 ifmod	: mod
236 	| DISABLE		{ v->uv_flags |= VIFF_DISABLED; }
237 	| IGMPV1		{ v->uv_flags |= VIFF_IGMPV1; }
238 	| NETMASK addrname	{
239 				  u_int32_t subnet, mask;
240 
241 				  mask = $2;
242 				  subnet = v->uv_lcl_addr & mask;
243 				  if (!inet_valid_subnet(subnet, mask))
244 					fatal("Invalid netmask");
245 				  v->uv_subnet = subnet;
246 				  v->uv_subnetmask = mask;
247 				  v->uv_subnetbcast = subnet | ~mask;
248 				}
249 	| NETMASK		{
250 
251 		    warn("Expected address after netmask keyword, ignored");
252 
253 				}
254 	| ALTNET addrmask	{
255 
256 		    struct phaddr *ph;
257 
258 		    ph = (struct phaddr *)malloc(sizeof(struct phaddr));
259 		    if (ph == NULL)
260 			fatal("out of memory");
261 		    if ($2.mask) {
262 			VAL_TO_MASK(ph->pa_subnetmask, $2.mask);
263 		    } else
264 			ph->pa_subnetmask = v->uv_subnetmask;
265 		    ph->pa_subnet = $2.addr & ph->pa_subnetmask;
266 		    ph->pa_subnetbcast = ph->pa_subnet | ~ph->pa_subnetmask;
267 		    if ($2.addr & ~ph->pa_subnetmask)
268 			warn("Extra subnet %s/%d has host bits set",
269 				inet_fmt($2.addr,s1), $2.mask);
270 		    ph->pa_next = v->uv_addrs;
271 		    v->uv_addrs = ph;
272 
273 				}
274 	| ALTNET		{
275 
276 		    warn("Expected address after altnet keyword, ignored");
277 
278 				}
279 	;
280 
281 mod	: THRESHOLD NUMBER	{ if ($2 < 1 || $2 > 255)
282 				    fatal("Invalid threshold %d",$2);
283 				  v->uv_threshold = $2;
284 				}
285 	| THRESHOLD		{
286 
287 		    warn("Expected number after threshold keyword, ignored");
288 
289 				}
290 	| METRIC NUMBER		{ if ($2 < 1 || $2 > UNREACHABLE)
291 				    fatal("Invalid metric %d",$2);
292 				  v->uv_metric = $2;
293 				}
294 	| METRIC		{
295 
296 		    warn("Expected number after metric keyword, ignored");
297 
298 				}
299 	| RATE_LIMIT NUMBER	{ if ($2 > MAX_RATE_LIMIT)
300 				    fatal("Invalid rate_limit %d",$2);
301 				  v->uv_rate_limit = $2;
302 				}
303 	| RATE_LIMIT		{
304 
305 		    warn("Expected number after rate_limit keyword, ignored");
306 
307 				}
308 	| BOUNDARY bound	{
309 
310 		    struct vif_acl *v_acl;
311 
312 		    v_acl = (struct vif_acl *)malloc(sizeof(struct vif_acl));
313 		    if (v_acl == NULL)
314 			fatal("out of memory");
315 		    VAL_TO_MASK(v_acl->acl_mask, $2.mask);
316 		    v_acl->acl_addr = $2.addr & v_acl->acl_mask;
317 		    if ($2.addr & ~v_acl->acl_mask)
318 			warn("Boundary spec %s/%d has host bits set",
319 				inet_fmt($2.addr,s1),$2.mask);
320 		    v_acl->acl_next = v->uv_acl;
321 		    v->uv_acl = v_acl;
322 
323 				}
324 	| BOUNDARY		{
325 
326 		warn("Expected boundary spec after boundary keyword, ignored");
327 
328 				}
329 	;
330 
331 interface	: ADDR		{ $$ = $1; }
332 	| STRING		{
333 				  $$ = valid_if($1);
334 				  if ($$ == 0)
335 					fatal("Invalid interface name %s",$1);
336 				}
337 	;
338 
339 addrname	: ADDR		{ $$ = $1; }
340 	| STRING		{ struct hostent *hp;
341 
342 				  if ((hp = gethostbyname($1)) == NULL)
343 				    fatal("No such host %s", $1);
344 
345 				  if (hp->h_addr_list[1])
346 				    fatal("Hostname %s does not %s",
347 					$1, "map to a unique address");
348 
349 				  bcopy(hp->h_addr_list[0], &$$,
350 					    hp->h_length);
351 				}
352 
353 bound	: boundary		{ $$ = $1; }
354 	| STRING		{ int i;
355 
356 				  for (i=0; i < numbounds; i++) {
357 				    if (!strcmp(boundlist[i].name, $1)) {
358 					$$ = boundlist[i].bound;
359 					break;
360 				    }
361 				  }
362 				  if (i == numbounds) {
363 				    fatal("Invalid boundary name %s",$1);
364 				  }
365 				}
366 	;
367 
368 boundary	: ADDRMASK	{
369 
370 			if ((ntohl($1.addr) & 0xff000000) != 0xef000000) {
371 			    fatal("Boundaries must be 239.x.x.x, not %s/%d",
372 				inet_fmt($1.addr, s1), $1.mask);
373 			}
374 			$$ = $1;
375 
376 				}
377 	;
378 
379 addrmask	: ADDRMASK	{ $$ = $1; }
380 	| ADDR			{ $$.addr = $1; $$.mask = 0; }
381 	;
382 %%
383 #ifdef __STDC__
384 static void
385 fatal(char *fmt, ...)
386 {
387 	va_list ap;
388 	char buf[200];
389 
390 	va_start(ap, fmt);
391 #else
392 /*VARARGS1*/
393 static void
394 fatal(fmt, va_alist)
395 char *fmt;
396 va_dcl
397 {
398 	va_list ap;
399 	char buf[200];
400 
401 	va_start(ap);
402 #endif
403 	vsprintf(buf, fmt, ap);
404 	va_end(ap);
405 
406 	log(LOG_ERR,0,"%s: %s near line %d", configfilename, buf, lineno);
407 }
408 
409 #ifdef __STDC__
410 static void
411 warn(char *fmt, ...)
412 {
413 	va_list ap;
414 	char buf[200];
415 
416 	va_start(ap, fmt);
417 #else
418 /*VARARGS1*/
419 static void
420 warn(fmt, va_alist)
421 char *fmt;
422 va_dcl
423 {
424 	va_list ap;
425 	char buf[200];
426 
427 	va_start(ap);
428 #endif
429 	vsprintf(buf, fmt, ap);
430 	va_end(ap);
431 
432 	log(LOG_WARNING,0,"%s: %s near line %d", configfilename, buf, lineno);
433 }
434 
435 static void
436 yyerror(s)
437 char *s;
438 {
439 	log(LOG_ERR, 0, "%s: %s near line %d", configfilename, s, lineno);
440 }
441 
442 static char *
443 next_word()
444 {
445 	static char buf[1024];
446 	static char *p=NULL;
447 	extern FILE *f;
448 	char *q;
449 
450 	while (1) {
451 	    if (!p || !*p) {
452 		lineno++;
453 		if (fgets(buf, sizeof(buf), f) == NULL)
454 		    return NULL;
455 		p = buf;
456 	    }
457 	    while (*p && (*p == ' ' || *p == '\t'))	/* skip whitespace */
458 		p++;
459 	    if (*p == '#') {
460 		p = NULL;		/* skip comments */
461 		continue;
462 	    }
463 	    q = p;
464 #ifdef SNMP
465        if (*p == '"') {
466           p++;
467 	       while (*p && *p != '"' && *p != '\n')
468 		      p++;		/* find next whitespace */
469           if (*p == '"')
470              p++;
471        } else
472 #endif
473 	    while (*p && *p != ' ' && *p != '\t' && *p != '\n')
474 		p++;		/* find next whitespace */
475 	    *p++ = '\0';	/* null-terminate string */
476 
477 	    if (!*q) {
478 		p = NULL;
479 		continue;	/* if 0-length string, read another line */
480 	    }
481 
482 	    return q;
483 	}
484 }
485 
486 static int
487 yylex()
488 {
489 	int n;
490 	u_int32_t addr;
491 	char *q;
492 
493 	if ((q = next_word()) == NULL) {
494 		return 0;
495 	}
496 
497 	if (!strcmp(q,"cache_lifetime"))
498 		return CACHE_LIFETIME;
499 	if (!strcmp(q,"pruning"))
500 		return PRUNING;
501 	if (!strcmp(q,"phyint"))
502 		return PHYINT;
503 	if (!strcmp(q,"tunnel"))
504 		return TUNNEL;
505 	if (!strcmp(q,"disable"))
506 		return DISABLE;
507 	if (!strcmp(q,"metric"))
508 		return METRIC;
509 	if (!strcmp(q,"threshold"))
510 		return THRESHOLD;
511 	if (!strcmp(q,"rate_limit"))
512 		return RATE_LIMIT;
513 	if (!strcmp(q,"srcrt") || !strcmp(q,"sourceroute"))
514 		return SRCRT;
515 	if (!strcmp(q,"boundary"))
516 		return BOUNDARY;
517 	if (!strcmp(q,"netmask"))
518 		return NETMASK;
519 	if (!strcmp(q,"igmpv1"))
520 		return IGMPV1;
521 	if (!strcmp(q,"altnet"))
522 		return ALTNET;
523 	if (!strcmp(q,"name"))
524 		return NAME;
525 	if (!strcmp(q,"on") || !strcmp(q,"yes")) {
526 		yylval.num = 1;
527 		return BOOLEAN;
528 	}
529 	if (!strcmp(q,"off") || !strcmp(q,"no")) {
530 		yylval.num = 0;
531 		return BOOLEAN;
532 	}
533 	if (sscanf(q,"%[.0-9]/%d%c",s1,&n,s2) == 2) {
534 		if ((addr = inet_parse(s1)) != 0xffffffff) {
535 			yylval.addrmask.mask = n;
536 			yylval.addrmask.addr = addr;
537 			return ADDRMASK;
538 		}
539 		/* fall through to returning STRING */
540 	}
541 	if (sscanf(q,"%[.0-9]%c",s1,s2) == 1) {
542 		if ((addr = inet_parse(s1)) != 0xffffffff &&
543 		    inet_valid_host(addr)) {
544 			yylval.addr = addr;
545 			return ADDR;
546 		}
547 	}
548 	if (sscanf(q,"0x%8x%c",&n,s1) == 1) {
549 		yylval.addr = n;
550 		return ADDR;
551 	}
552 	if (sscanf(q,"%d%c",&n,s1) == 1) {
553 		yylval.num = n;
554 		return NUMBER;
555 	}
556 #ifdef SNMP
557 	if (!strcmp(q,"sysName"))
558 		return SYSNAM;
559 	if (!strcmp(q,"sysContact"))
560 		return SYSCONTACT;
561 	if (!strcmp(q,"sysVersion"))
562 		return SYSVERSION;
563 	if (!strcmp(q,"sysLocation"))
564 		return SYSLOCATION;
565    if (*q=='"') {
566       if (q[ strlen(q)-1 ]=='"')
567          q[ strlen(q)-1 ]='\0'; /* trash trailing quote */
568       yylval.ptr = q+1;
569       return STRING;
570    }
571 #endif
572 	yylval.ptr = q;
573 	return STRING;
574 }
575 
576 void
577 config_vifs_from_file()
578 {
579 	extern FILE *f;
580 
581 	order = 0;
582 	numbounds = 0;
583 	lineno = 0;
584 
585 	if ((f = fopen(configfilename, "r")) == NULL) {
586 	    if (errno != ENOENT)
587 		log(LOG_ERR, errno, "can't open %s", configfilename);
588 	    return;
589 	}
590 
591 	ifc.ifc_buf = (char *)ifbuf;
592 	ifc.ifc_len = sizeof(ifbuf);
593 	if (ioctl(udp_socket, SIOCGIFCONF, (char *)&ifc) < 0)
594 	    log(LOG_ERR, errno, "ioctl SIOCGIFCONF");
595 
596 	yyparse();
597 
598 	fclose(f);
599 }
600 
601 static u_int32_t
602 valid_if(s)
603 char *s;
604 {
605 	register vifi_t vifi;
606 	register struct uvif *v;
607 
608 	for (vifi=0, v=uvifs; vifi<numvifs; vifi++, v++)
609 	    if (!strcmp(v->uv_name, s))
610 		return v->uv_lcl_addr;
611 
612 	return 0;
613 }
614 
615 static struct ifreq *
616 ifconfaddr(ifcp, a)
617     struct ifconf *ifcp;
618     u_int32_t a;
619 {
620     int n;
621     struct ifreq *ifrp = (struct ifreq *)ifcp->ifc_buf;
622     struct ifreq *ifend = (struct ifreq *)((char *)ifrp + ifcp->ifc_len);
623 
624     while (ifrp < ifend) {
625 	    if (ifrp->ifr_addr.sa_family == AF_INET &&
626 		((struct sockaddr_in *)&ifrp->ifr_addr)->sin_addr.s_addr == a)
627 		    return (ifrp);
628 #if (defined(BSD) && (BSD >= 199006))
629 		n = ifrp->ifr_addr.sa_len + sizeof(ifrp->ifr_name);
630 		if (n < sizeof(*ifrp))
631 			++ifrp;
632 		else
633 			ifrp = (struct ifreq *)((char *)ifrp + n);
634 #else
635 		++ifrp;
636 #endif
637     }
638     return (0);
639 }
640