#include <stdlib.h>

#include <string.h>

#define YYBYACC 1

#define YYMAJOR 1

#define YYMINOR 9

#define YYLEX yylex()

#define YYEMPTY -1

#define yyclearin (yychar=(YYEMPTY))

#define yyerrok (yyerrflag=0)

#define YYRECOVERING() (yyerrflag!=0)

#define YYPREFIX "yy"

#line 2 "cfparse.y"

/*	$NetBSD: cfparse.y,v 1.4 1995/12/10 10:06:57 mycroft Exp $	*/

/*

 * Configuration file parser for mrouted.

 *

 * Written by Bill Fenner, NRL, 1994

 * Copyright (c) 1994

 * Naval Research Laboratory (NRL/CCS)

 *                    and the

 * Defense Advanced Research Projects Agency (DARPA)

 *

 * All Rights Reserved.

 *

 * Permission to use, copy, modify and distribute this software and its

 * documentation is hereby granted, provided that both the copyright notice and

 * this permission notice appear in all copies of the software, derivative

 * works or modified versions, and any portions thereof, and that both notices

 * appear in supporting documentation.

 *

 * NRL AND DARPA ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION AND

 * DISCLAIM ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM

 * THE USE OF THIS SOFTWARE.

 */

#include <stdio.h>

#include <string.h>

#include <stdarg.h>

#include "defs.h"

#include <netdb.h>

#include <ifaddrs.h>

/*

 * Local function declarations

 */

static void		fatal(const char *fmt, ...)

    __attribute__((__format__ (printf, 1, 2)))

    __attribute__((__nonnull__ (1)));

static void		warn(const char *fmt, ...)

    __attribute__((__format__ (printf, 1, 2)))

    __attribute__((__nonnull__ (1)));

static void		yyerror(char *s);

static char *		next_word(void);

static int		yylex(void);

static u_int32_t	valid_if(char *s);

static const char *	ifconfaddr(u_int32_t a);

int			yyparse(void);

static FILE *f;

extern int udp_socket;

char *configfilename = _PATH_MROUTED_CONF;

extern int cache_lifetime;

extern int max_prune_lifetime;

static int lineno;

static struct uvif *v;

static int order;

struct addrmask {

	u_int32_t	addr;

	int	mask;

};

struct boundnam {

	char		*name;

	struct addrmask	 bound;

};

#define MAXBOUNDS 20

struct boundnam boundlist[MAXBOUNDS];	/* Max. of 20 named boundaries */

int numbounds = 0;			/* Number of named boundaries */

#line 79 "cfparse.y"

#ifndef YYSTYPE_DEFINED

#define YYSTYPE_DEFINED

typedef union

{

	int num;

	char *ptr;

	struct addrmask addrmask;

	u_int32_t addr;

} YYSTYPE;

#endif /* YYSTYPE_DEFINED */

#line 100 "cfparse.c"

#define CACHE_LIFETIME 257

#define PRUNING 258

#define PHYINT 259

#define TUNNEL 260

#define NAME 261

#define DISABLE 262

#define IGMPV1 263

#define SRCRT 264

#define METRIC 265

#define THRESHOLD 266

#define RATE_LIMIT 267

#define BOUNDARY 268

#define NETMASK 269

#define ALTNET 270

#define BOOLEAN 271

#define NUMBER 272

#define ADDR 275

   14,   14,   14,   14,   13,   13,   13,   13,   13,   13,

   13,   13,    1,    1,    2,    2,    3,    3,    4,    5,

};

	{                                         2,

    1,    0,    2,    1,    0,    4,    0,    5,    2,    2,

    2,    1,    2,    1,    2,    1,    2,    1,    2,    1,

    2,    1,    1,    1,    1,    1,    1,    1,    1,    1,

};

const short yydefred[] =

    0,    0,    4,    0,    0,    0,    0,    0,    3,   10,

};

};

	{                                      0,

 -249, -245,    0,    0, -253,    0,    0,    0,    0,    0,

    0,    0,    6,    0,

};

	{                                      10,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

   28,   26,   26,   26,   26,   26,   26,   26,   26,   26,

   30,   30,   30,   30,   30,   30,   30,   30,   30,   30,

   22,   24,   24,   24,   24,   24,   24,   24,   24,    0,

};

const short yycheck[] =

  264,  265,  266,  267,  268,    0,  256,  257,  258,  259,

    0,  273,    0,  274,  272,  272,  272,   31,    7,   30,

   35,   -1,   -1,   -1,   -1,    0,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

    0,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,    0,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

  260,  261,  262,  263,  264,  265,  266,  267,  268,  269,

  265,  266,  267,  268,  269,  270,  256,  257,  258,  259,

  270,  256,  257,  258,  259,  260,  261,  262,  263,   -1,

  265,  266,  267,  268,  269,  270,  256,  257,  258,  259,

};

#define YYFINAL 1

#ifndef YYDEBUG

	{

"RATE_LIMIT","BOUNDARY","NETMASK","ALTNET","BOOLEAN","NUMBER","STRING",

"ADDRMASK","ADDR",

};

const char * const yyrule[] =

"conf : stmts",

"stmts :",

"stmt : error",

"stmt : TUNNEL interface addrname $$2 tunnelmods",

"stmt : CACHE_LIFETIME NUMBER",

"tunnelmods :",

"tunnelmods : tunnelmods tunnelmod",

"ifmods : ifmods ifmod",

"ifmod : DISABLE",

"ifmod : NETMASK addrname",

"ifmod : NETMASK",

"mod : THRESHOLD",

"mod : METRIC",

"mod : RATE_LIMIT",

"mod : BOUNDARY bound",

"interface : ADDR",

"interface : STRING",

"addrname : ADDR",

};

#define YYMAXDEPTH YYSTACKSIZE

#else

#define YYSTACKSIZE YYMAXDEPTH

#define YYSTACKSIZE 10000

#define YYMAXDEPTH 10000

#endif

int yychar;

short *yyssp;

YYSTYPE *yyvsp;

short *yyss;

unsigned int yystacksize;

fatal(const char *fmt, ...)

{

	char buf[200];

	va_end(ap);

}

static void

warn(const char *fmt, ...)

{

	vsnprintf(buf, sizeof buf, fmt, ap);

	va_end(ap);

}

char *s;

{

}

{

	static char buf[1024];

	static char *p=NULL;

	extern FILE *f;

	char *q;

	while (1) {

	    if (!p || !*p) {

		lineno++;

		if (fgets(buf, sizeof(buf), f) == NULL)

		    return NULL;

		p = buf;

	    }

	    while (*p && (*p == ' ' || *p == '\t'))	/* skip whitespace */

		p++;

	    if (*p == '#') {

		p = NULL;		/* skip comments */

		continue;

	    }

	    q = p;

	    while (*p && *p != ' ' && *p != '\t' && *p != '\n')

		p++;		/* find next whitespace */

	    *p++ = '\0';	/* null-terminate string */

	    if (!*q) {

		p = NULL;

		continue;	/* if 0-length string, read another line */

	    }

	    return q;

	}

}

static int

yylex()

{

	int n;

	u_int32_t addr;

	char *q;

	if ((q = next_word()) == NULL) {

		return 0;

	}

	if (!strcmp(q,"cache_lifetime"))

		return CACHE_LIFETIME;

	if (!strcmp(q,"pruning"))

		return PRUNING;

	if (!strcmp(q,"phyint"))

		return PHYINT;

	if (!strcmp(q,"tunnel"))

		return TUNNEL;

	if (!strcmp(q,"disable"))

		return DISABLE;

	if (!strcmp(q,"metric"))

		return METRIC;

	if (!strcmp(q,"threshold"))

		return THRESHOLD;

	if (!strcmp(q,"rate_limit"))

		return RATE_LIMIT;

	if (!strcmp(q,"srcrt") || !strcmp(q,"sourceroute"))

		return SRCRT;

	if (!strcmp(q,"boundary"))

		return BOUNDARY;

	if (!strcmp(q,"netmask"))

		return NETMASK;

	if (!strcmp(q,"igmpv1"))

		return IGMPV1;

	if (!strcmp(q,"altnet"))

		return ALTNET;

	if (!strcmp(q,"name"))

		return NAME;

	if (!strcmp(q,"on") || !strcmp(q,"yes")) {

		yylval.num = 1;

		return BOOLEAN;

	}

	if (!strcmp(q,"off") || !strcmp(q,"no")) {

		yylval.num = 0;

		return BOOLEAN;

	}

	if (sscanf(q,"%[.0-9]/%d%c",s1,&n,s2) == 2) {

		if ((addr = inet_parse(s1)) != 0xffffffff) {

			yylval.addrmask.mask = n;

			yylval.addrmask.addr = addr;

			return ADDRMASK;

		}

		/* fall through to returning STRING */

	}

	if (sscanf(q,"%[.0-9]%c",s1,s2) == 1) {

		if ((addr = inet_parse(s1)) != 0xffffffff &&

		    inet_valid_host(addr)) {

			yylval.addr = addr;

			return ADDR;

		}

	}

	if (sscanf(q,"0x%8x%c",&n,s1) == 1) {

		yylval.addr = n;

		return ADDR;

	}

	if (sscanf(q,"%d%c",&n,s1) == 1) {

		yylval.num = n;

		return NUMBER;

	}

	yylval.ptr = q;

	return STRING;

}

void

config_vifs_from_file()

{

	extern FILE *f;

	order = 0;

	numbounds = 0;

	lineno = 0;

	if ((f = fopen(configfilename, "r")) == NULL) {

	    if (errno != ENOENT)

		logit(LOG_ERR, errno, "can't open %s", configfilename);

	    return;

	}

	yyparse();

	fclose(f);

}

static u_int32_t

valid_if(s)

char *s;

{

	register vifi_t vifi;

	register struct uvif *v;

	for (vifi=0, v=uvifs; vifi<numvifs; vifi++, v++)

	    if (!strcmp(v->uv_name, s))

		return v->uv_lcl_addr;

	return 0;

}

static const char *

ifconfaddr(a)

    u_int32_t a;

{

    static char ifname[IFNAMSIZ];

    struct ifaddrs *ifap, *ifa;

    if (getifaddrs(&ifap) != 0)

	return (NULL);

    for (ifa = ifap; ifa; ifa = ifa->ifa_next) {

	    if (ifa->ifa_addr->sa_family == AF_INET &&

		((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr == a) {

		strlcpy(ifname, ifa->ifa_name, sizeof(ifname));

		freeifaddrs(ifap);

		return (ifname);

	    }

    }

    freeifaddrs(ifap);

    return (0);

}

#line 528 "cfparse.c"

{

    short *newss;

    if ((newsize = yystacksize) == 0)

        newsize = YYINITSTACKSIZE;

    else if (newsize >= YYMAXDEPTH)

        return -1;

        newsize = YYMAXDEPTH;

#else

        goto bail;

        goto bail;

      (YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */

            free(yyss);

    if (yyvs)

            free(yyvs);

    yyss = yyssp = NULL;

    yyvs = yyvsp = NULL;

    yystacksize = 0;

    return -1;

}

#define YYABORT goto yyabort

#define YYREJECT goto yyabort

#define YYACCEPT goto yyaccept

#define YYERROR goto yyerrlab

int

yyparse(void)

{

    int yym, yyn, yystate;

#if YYDEBUG

    const char *yys;

    {

        if (yyn >= '0' && yyn <= '9')

    }

    yynerrs = 0;

    yyerrflag = 0;

    if (yyss == NULL && yygrowstack()) goto yyoverflow;

    yyvsp = yyvs;

    *yyssp = yystate = 0;

yyloop:

    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;

    if (yychar < 0)

    {

        if ((yychar = yylex()) < 0) yychar = 0;

#if YYDEBUG

        if (yydebug)

        {

            if (!yys) yys = "illegal-symbol";

            printf("%sdebug: state %d, reading %d (%s)\n",

                    YYPREFIX, yystate, yychar, yys);

        }

#endif

    }

            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)

    {

#if YYDEBUG

        {

        }

        *++yyssp = yystate = yytable[yyn];

        if (yyerrflag > 0)  --yyerrflag;

    }

    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&

            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)

    {

        goto yyreduce;

    }

    if (yyerrflag) goto yyinrecovery;

#if defined(__GNUC__)

#endif

    yyerror("syntax error");

#endif

yyinrecovery:

    if (yyerrflag < 3)

    {

        yyerrflag = 3;

        for (;;)

        {

                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)

            {

#if YYDEBUG

#endif

                if (yyssp >= yysslim && yygrowstack())

                {

                    goto yyoverflow;

                }

                *++yyssp = yystate = yytable[yyn];

                *++yyvsp = yylval;

                goto yyloop;

            }

            else

            {

#if YYDEBUG

                if (yydebug)

                    printf("%sdebug: error recovery discarding state %d\n",

                            YYPREFIX, *yyssp);

#endif

                --yyssp;

                --yyvsp;

            }

        }

    }

    else

    {

        if (yychar == 0) goto yyabort;

#if YYDEBUG

        if (yydebug)

        {

            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];

            if (!yys) yys = "illegal-symbol";

            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",

                    YYPREFIX, yystate, yychar, yys);

        }

#endif

        yychar = (-1);

    }

#if YYDEBUG

                YYPREFIX, yystate, yyn, yyrule[yyn]);

#endif

    yym = yylen[yyn];

    if (yym)

        yyval = yyvsp[1-yym];

    else

        memset(&yyval, 0, sizeof yyval);

    switch (yyn)

    {

case 5:

#line 112 "cfparse.y"

{

			vifi_t vifi;

			if (order)

			    fatal("phyints must appear before tunnels");

			for (vifi = 0, v = uvifs;

			     vifi < numvifs;

			     ++vifi, ++v)

			    if (!(v->uv_flags & VIFF_TUNNEL) &&

				yyvsp[0].addr == v->uv_lcl_addr)

				break;

			if (vifi == numvifs)

			    fatal("%s is not a configured interface",

				inet_fmt(yyvsp[0].addr,s1));

					}

break;

case 7:

#line 132 "cfparse.y"

{

			const char *ifname;

			struct ifreq ffr;

			vifi_t vifi;

			order++;

			ifname = ifconfaddr(yyvsp[-1].addr);

			if (ifname == 0)

			    fatal("Tunnel local address %s is not mine",

				inet_fmt(yyvsp[-1].addr, s1));

			strlcpy(ffr.ifr_name, ifname, sizeof(ffr.ifr_name));

			if (ioctl(udp_socket, SIOCGIFFLAGS, (char *)&ffr)<0)

			    fatal("ioctl SIOCGIFFLAGS on %s",ffr.ifr_name);

			if (ffr.ifr_flags & IFF_LOOPBACK)

			    fatal("Tunnel local address %s is a loopback interface",

				inet_fmt(yyvsp[-1].addr, s1));

			if (ifconfaddr(yyvsp[0].addr) != 0)

			    fatal("Tunnel remote address %s is one of mine",

				inet_fmt(yyvsp[0].addr, s1));

			for (vifi = 0, v = uvifs;

			     vifi < numvifs;

			     ++vifi, ++v)

			    if (v->uv_flags & VIFF_TUNNEL) {

				if (yyvsp[0].addr == v->uv_rmt_addr)

				    fatal("Duplicate tunnel to %s",

					inet_fmt(yyvsp[0].addr, s1));

			    } else if (!(v->uv_flags & VIFF_DISABLED)) {

				if ((yyvsp[0].addr & v->uv_subnetmask) == v->uv_subnet)

				    fatal("Unnecessary tunnel to %s",

					inet_fmt(yyvsp[0].addr,s1));

			    }

			if (numvifs == MAXVIFS)

			    fatal("too many vifs");

			v = &uvifs[numvifs];

			v->uv_flags	= VIFF_TUNNEL;

			v->uv_metric	= DEFAULT_METRIC;

			v->uv_rate_limit= DEFAULT_TUN_RATE_LIMIT;

			v->uv_threshold	= DEFAULT_THRESHOLD;

			v->uv_lcl_addr	= yyvsp[-1].addr;

			v->uv_rmt_addr	= yyvsp[0].addr;

			v->uv_subnet	= 0;

			v->uv_subnetmask= 0;

			v->uv_subnetbcast= 0;

			strncpy(v->uv_name, ffr.ifr_name, IFNAMSIZ);

			v->uv_groups	= NULL;

			v->uv_neighbors	= NULL;

			v->uv_acl	= NULL;

			v->uv_addrs	= NULL;

			if (!(ffr.ifr_flags & IFF_UP)) {

			    v->uv_flags |= VIFF_DOWN;

			    vifs_down = TRUE;

			}

					}

break;

case 8:

#line 193 "cfparse.y"

{

			logit(LOG_INFO, 0,

			    "installing tunnel from %s to %s as vif #%u - rate=%d",

			    inet_fmt(yyvsp[-3].addr, s1), inet_fmt(yyvsp[-2].addr, s2),

			    numvifs, v->uv_rate_limit);

			++numvifs;

					}

break;

case 9:

#line 201 "cfparse.y"

{ pruning = yyvsp[0].num; }

break;

case 10:

#line 202 "cfparse.y"

{ cache_lifetime = yyvsp[0].num;

				      max_prune_lifetime = cache_lifetime * 2;

				    }

break;

case 11:

#line 205 "cfparse.y"

{ if (numbounds >= MAXBOUNDS) {

					fatal("Too many named boundaries (max %d)", MAXBOUNDS);

				      }

				      boundlist[numbounds].name = strdup(yyvsp[-1].ptr);

				      boundlist[numbounds++].bound = yyvsp[0].addrmask;

				    }

break;

case 15:

#line 219 "cfparse.y"

{ fatal("Source-route tunnels not supported"); }

break;

case 19:

#line 227 "cfparse.y"

{ v->uv_flags |= VIFF_DISABLED; }

break;

case 20:

#line 228 "cfparse.y"

{ v->uv_flags |= VIFF_IGMPV1; }

break;

case 21:

#line 229 "cfparse.y"

{

				  u_int32_t subnet, mask;

				  mask = yyvsp[0].addr;

				  subnet = v->uv_lcl_addr & mask;

				  if (!inet_valid_subnet(subnet, mask))

					fatal("Invalid netmask");

				  v->uv_subnet = subnet;

				  v->uv_subnetmask = mask;

				  v->uv_subnetbcast = subnet | ~mask;

				}

break;

case 22:

#line 240 "cfparse.y"

{

		    warn("Expected address after netmask keyword, ignored");

				}

break;

case 23:

#line 245 "cfparse.y"

{

		    struct phaddr *ph;

		    ph = malloc(sizeof(struct phaddr));

		    if (ph == NULL)

			fatal("out of memory");

		    if (yyvsp[0].addrmask.mask) {

			VAL_TO_MASK(ph->pa_subnetmask, yyvsp[0].addrmask.mask);

		    } else

			ph->pa_subnetmask = v->uv_subnetmask;

		    ph->pa_subnet = yyvsp[0].addrmask.addr & ph->pa_subnetmask;

		    ph->pa_subnetbcast = ph->pa_subnet | ~ph->pa_subnetmask;

		    if (yyvsp[0].addrmask.addr & ~ph->pa_subnetmask)

			warn("Extra subnet %s/%d has host bits set",

				inet_fmt(yyvsp[0].addrmask.addr,s1), yyvsp[0].addrmask.mask);

		    ph->pa_next = v->uv_addrs;

		    v->uv_addrs = ph;

				}

break;

case 24:

#line 265 "cfparse.y"

{

		    warn("Expected address after altnet keyword, ignored");

				}

break;

case 25:

#line 272 "cfparse.y"

{ if (yyvsp[0].num < 1 || yyvsp[0].num > 255)

				    fatal("Invalid threshold %d",yyvsp[0].num);

				  v->uv_threshold = yyvsp[0].num;

				}

break;

case 26:

#line 276 "cfparse.y"

{

		    warn("Expected number after threshold keyword, ignored");

				}

break;

case 27:

#line 281 "cfparse.y"

{ if (yyvsp[0].num < 1 || yyvsp[0].num > UNREACHABLE)

				    fatal("Invalid metric %d",yyvsp[0].num);

				  v->uv_metric = yyvsp[0].num;

				}

break;

case 28:

#line 285 "cfparse.y"

{

		    warn("Expected number after metric keyword, ignored");

				}

break;

case 29:

#line 290 "cfparse.y"

{ if (yyvsp[0].num > MAX_RATE_LIMIT)

				    fatal("Invalid rate_limit %d",yyvsp[0].num);

				  v->uv_rate_limit = yyvsp[0].num;

				}

break;

case 30:

#line 294 "cfparse.y"

{

		    warn("Expected number after rate_limit keyword, ignored");

				}

break;

case 31:

#line 299 "cfparse.y"

{

		    struct vif_acl *v_acl;

		    v_acl = malloc(sizeof(struct vif_acl));

		    if (v_acl == NULL)

			fatal("out of memory");

		    VAL_TO_MASK(v_acl->acl_mask, yyvsp[0].addrmask.mask);

		    v_acl->acl_addr = yyvsp[0].addrmask.addr & v_acl->acl_mask;

		    if (yyvsp[0].addrmask.addr & ~v_acl->acl_mask)

			warn("Boundary spec %s/%d has host bits set",

				inet_fmt(yyvsp[0].addrmask.addr,s1),yyvsp[0].addrmask.mask);

		    v_acl->acl_next = v->uv_acl;

		    v->uv_acl = v_acl;

				}

break;

case 32:

#line 315 "cfparse.y"

{

		warn("Expected boundary spec after boundary keyword, ignored");

				}

break;

case 33:

#line 322 "cfparse.y"

{ yyval.addr = yyvsp[0].addr; }

break;

case 34:

#line 323 "cfparse.y"

{

				  yyval.addr = valid_if(yyvsp[0].ptr);

				  if (yyval.addr == 0)

					fatal("Invalid interface name %s",yyvsp[0].ptr);

				}

break;

case 35: