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