Head

GCC Code Coverage Report
Directory:	./		Exec	Total	Coverage
File:	usr.sbin/bgpd/parse.c	Lines:	359	1252	28.7 %
Date:	2017-11-13	Branches:	224	994	22.5 %

#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 25 "parse.y"
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/ip_ipsp.h>
#include <arpa/inet.h>
#include <netmpls/mpls.h>

#include <ctype.h>
#include <err.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <syslog.h>

#include "bgpd.h"
#include "mrt.h"
#include "session.h"
#include "rde.h"
#include "log.h"

TAILQ_HEAD(files, file)		 files = TAILQ_HEAD_INITIALIZER(files);
static struct file {
	TAILQ_ENTRY(file)	 entry;
	FILE			*stream;
	char			*name;
	int			 lineno;
	int			 errors;
} *file, *topfile;
struct file	*pushfile(const char *, int);
int		 popfile(void);
int		 check_file_secrecy(int, const char *);
int		 yyparse(void);
int		 yylex(void);
int		 yyerror(const char *, ...)
    __attribute__((__format__ (printf, 1, 2)))
    __attribute__((__nonnull__ (1)));
int		 kw_cmp(const void *, const void *);
int		 lookup(char *);
int		 lgetc(int);
int		 lungetc(int);
int		 findeol(void);

TAILQ_HEAD(symhead, sym)	 symhead = TAILQ_HEAD_INITIALIZER(symhead);
struct sym {
	TAILQ_ENTRY(sym)	 entry;
	int			 used;
	int			 persist;
	char			*nam;
	char			*val;
};
int		 symset(const char *, const char *, int);
char		*symget(const char *);

static struct bgpd_config	*conf;
static struct network_head	*netconf;
static struct peer		*peer_l, *peer_l_old;
static struct peer		*curpeer;
static struct peer		*curgroup;
static struct rdomain		*currdom;
static struct filter_head	*filter_l;
static struct filter_head	*peerfilter_l;
static struct filter_head	*groupfilter_l;
static struct filter_rule	*curpeer_filter[2];
static struct filter_rule	*curgroup_filter[2];
static u_int32_t		 id;

struct filter_rib_l {
	struct filter_rib_l	*next;
	char			 name[PEER_DESCR_LEN];
};

struct filter_peers_l {
	struct filter_peers_l	*next;
	struct filter_peers	 p;
};

struct filter_prefix_l {
	struct filter_prefix_l	*next;
	struct filter_prefix	 p;
};

struct filter_prefixlen {
	enum comp_ops		op;
	int			len_min;
	int			len_max;
};

struct filter_as_l {
	struct filter_as_l	*next;
	struct filter_as	 a;
};

struct filter_match_l {
	struct filter_match	 m;
	struct filter_prefix_l	*prefix_l;
	struct filter_as_l	*as_l;
} fmopts;

struct peer	*alloc_peer(void);
struct peer	*new_peer(void);
struct peer	*new_group(void);
int		 add_mrtconfig(enum mrt_type, char *, int, struct peer *,
		    char *);
int		 add_rib(char *, u_int, u_int16_t);
struct rde_rib	*find_rib(char *);
int		 get_id(struct peer *);
int		 merge_prefixspec(struct filter_prefix_l *,
		    struct filter_prefixlen *);
int		 expand_rule(struct filter_rule *, struct filter_rib_l *,
		    struct filter_peers_l *, struct filter_match_l *,
		    struct filter_set_head *);
int		 str2key(char *, char *, size_t);
int		 neighbor_consistent(struct peer *);
int		 merge_filterset(struct filter_set_head *, struct filter_set *);
void		 copy_filterset(struct filter_set_head *,
		    struct filter_set_head *);
void		 merge_filter_lists(struct filter_head *, struct filter_head *);
struct filter_rule	*get_rule(enum action_types);

int		 getcommunity(char *);
int		 parsecommunity(struct filter_community *, char *);
int64_t 	 getlargecommunity(char *);
int		 parselargecommunity(struct filter_largecommunity *, char *);
int		 parsesubtype(char *, int *, int *);
int		 parseextvalue(char *, u_int32_t *);
int		 parseextcommunity(struct filter_extcommunity *, char *,
		    char *);

typedef struct {
	union {
		int64_t			 number;
		char			*string;
		struct bgpd_addr	 addr;
		u_int8_t		 u8;
		struct filter_rib_l	*filter_rib;
		struct filter_peers_l	*filter_peers;
		struct filter_match_l	 filter_match;
		struct filter_prefix_l	*filter_prefix;
		struct filter_as_l	*filter_as;
		struct filter_set	*filter_set;
		struct filter_set_head	*filter_set_head;
		struct {
			struct bgpd_addr	prefix;
			u_int8_t		len;
		}			prefix;
		struct filter_prefixlen	prefixlen;
		struct {
			u_int8_t		enc_alg;
			char			enc_key[IPSEC_ENC_KEY_LEN];
			u_int8_t		enc_key_len;
		}			encspec;
	} v;
	int lineno;
} YYSTYPE;

#line 174 "parse.c"
#define AS 257
#define ROUTERID 258
#define HOLDTIME 259
#define YMIN 260
#define LISTEN 261
#define ON 262
#define FIBUPDATE 263
#define FIBPRIORITY 264
#define RTABLE 265
#define RDOMAIN 266
#define RD 267
#define EXPORTTRGT 268
#define IMPORTTRGT 269
#define RDE 270
#define RIB 271
#define EVALUATE 272
#define IGNORE 273
#define COMPARE 274
#define GROUP 275
#define NEIGHBOR 276
#define NETWORK 277
#define EBGP 278
#define IBGP 279
#define LOCALAS 280
#define REMOTEAS 281
#define DESCR 282
#define LOCALADDR 283
#define MULTIHOP 284
#define PASSIVE 285
#define MAXPREFIX 286
#define RESTART 287
#define ANNOUNCE 288
#define CAPABILITIES 289
#define REFRESH 290
#define AS4BYTE 291
#define CONNECTRETRY 292
#define DEMOTE 293
#define ENFORCE 294
#define NEIGHBORAS 295
#define REFLECTOR 296
#define DEPEND 297
#define DOWN 298
#define DUMP 299
#define IN 300
#define OUT 301
#define SOCKET 302
#define RESTRICTED 303
#define LOG 304
#define ROUTECOLL 305
#define TRANSPARENT 306
#define TCP 307
#define MD5SIG 308
#define PASSWORD 309
#define KEY 310
#define TTLSECURITY 311
#define ALLOW 312
#define DENY 313
#define MATCH 314
#define QUICK 315
#define FROM 316
#define TO 317
#define ANY 318
#define CONNECTED 319
#define STATIC 320
#define COMMUNITY 321
#define EXTCOMMUNITY 322
#define LARGECOMMUNITY 323
#define PREFIX 324
#define PREFIXLEN 325
#define SOURCEAS 326
#define TRANSITAS 327
#define PEERAS 328
#define DELETE 329
#define MAXASLEN 330
#define MAXASSEQ 331
#define SET 332
#define LOCALPREF 333
#define MED 334
#define METRIC 335
#define NEXTHOP 336
#define REJECT 337
#define BLACKHOLE 338
#define NOMODIFY 339
#define SELF 340
#define PREPEND_SELF 341
#define PREPEND_PEER 342
#define PFTABLE 343
#define WEIGHT 344
#define RTLABEL 345
#define ORIGIN 346
#define ERROR 347
#define INCLUDE 348
#define IPSEC 349
#define ESP 350
#define AH 351
#define SPI 352
#define IKE 353
#define IPV4 354
#define IPV6 355
#define QUALIFY 356
#define VIA 357
#define NE 358
#define LE 359
#define GE 360
#define XRANGE 361
#define LONGER 362
#define STRING 363
#define NUMBER 364
#define YYERRCODE 256
const short yylhs[] =
	{                                        -1,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    1,    2,    2,    3,    3,   13,   13,   10,   51,   49,
   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,
   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,
   50,   50,   50,   50,   50,   50,   57,   56,   56,   56,
   11,   11,   12,   12,   14,   15,   15,   16,   16,   58,
   58,   59,    4,    4,   61,   52,   60,   60,   62,   63,
   63,   63,   63,   63,   63,   63,   64,   66,   53,   68,
   54,   67,   67,   69,   69,   69,   65,   65,   71,   71,
   72,   70,   70,   70,   70,   70,   70,   70,   70,   70,
   70,   70,   70,   70,   70,   70,   70,   70,   70,   70,
   70,   70,   70,   70,   70,   70,   70,   70,   70,   70,
   70,   70,   70,   70,   70,   70,   70,    7,    7,    6,
    6,    9,    9,    5,    5,   48,   48,   55,   17,   17,
   17,   18,   18,   19,   19,   21,   21,   21,   22,   22,
   23,   26,   26,   25,   25,   24,   24,   24,   24,   24,
   24,   42,   42,   42,   42,   43,   43,   43,   41,   41,
   40,   32,   32,   34,   34,   33,   33,   35,   35,   35,
   31,   31,   30,   30,   30,   30,   29,   74,   29,   27,
   27,   28,   28,   28,   28,   28,   28,   28,   28,   28,
   36,   36,   36,   36,   47,   47,   47,   47,   38,   38,
   38,   39,   39,   20,   20,   37,   37,   37,   37,   37,
   37,   37,   37,   37,   37,   37,   37,   37,   37,   37,
   37,   37,   37,   37,   37,   37,   37,   37,   37,   37,
    8,   73,   73,   44,   44,   44,   44,   44,   44,   45,
   45,   46,   46,
};
const short yylen[] =
	{                                         2,
    0,    2,    3,    3,    3,    3,    3,    3,    3,    3,
    1,    1,    1,    1,    1,    2,    1,    1,    3,    2,
    2,    3,    2,    2,    3,    3,    2,    2,    2,    3,
    5,    5,    7,    2,    2,    1,    4,    6,    1,    3,
    3,    4,    4,    2,    2,    3,    5,    3,    5,    4,
    1,    1,    1,    0,    1,    3,    3,    1,    1,    2,
    0,    2,    0,    1,    0,    8,    2,    1,    2,    2,
    3,    3,    2,    2,    1,    3,    0,    0,    5,    0,
    8,    2,    1,    2,    2,    2,    4,    0,    2,    1,
    2,    2,    2,    3,    2,    2,    2,    1,    1,    2,
    2,    2,    3,    3,    3,    3,    3,    3,    2,    2,
    3,    3,    3,    4,    4,    3,    8,    2,    2,    7,
    1,    1,    2,    3,    2,    2,    2,    0,    2,    1,
    1,    1,    1,    1,    1,    0,    2,    7,    1,    1,
    1,    0,    1,    1,    1,    0,    2,    4,    1,    3,
    1,    1,    3,    1,    3,    1,    1,    2,    2,    1,
    1,    2,    2,    2,    4,    1,    3,    4,    1,    3,
    2,    1,    3,    1,    3,    2,    4,    1,    3,    4,
    1,    3,    1,    1,    2,    3,    0,    0,    2,    1,
    2,    1,    1,    2,    2,    2,    2,    3,    2,    2,
    0,    1,    3,    4,    1,    1,    1,    1,    0,    2,
    7,    3,    1,    0,    1,    2,    3,    3,    2,    3,
    3,    2,    3,    3,    2,    3,    3,    2,    2,    2,
    2,    2,    2,    2,    2,    2,    3,    3,    4,    2,
    1,    1,    0,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,
};
const short yydefred[] =
	{                                      1,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,  139,
  140,  141,    0,    0,    0,    2,    0,    0,    0,    0,
    0,    0,    0,    0,   36,   39,    0,   10,   12,   11,
   13,    0,   55,   23,    0,   24,    0,   18,   28,   27,
   44,    0,    0,    0,    0,   17,    0,  130,  131,    0,
    0,    0,    0,   45,    0,    0,    0,   35,   29,   34,
    0,   20,    0,  143,    0,    3,    4,    5,    6,    7,
    8,    9,    0,   22,   25,   26,    0,    0,    0,    0,
   40,   41,   16,    0,    0,    0,  133,  132,    0,    0,
    0,   48,    0,   51,   52,    0,    0,   53,   46,    0,
    0,    0,    0,    0,   58,   59,   78,   60,    0,    0,
    0,   42,    0,   56,   57,    0,   50,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  210,    0,    0,   64,   37,    0,   43,  151,    0,  147,
  144,  145,    0,    0,   65,    0,   31,   80,   49,  215,
    0,    0,    0,  216,    0,    0,  219,    0,    0,  222,
    0,    0,  230,  229,  231,  232,  228,  233,  234,  235,
  225,    0,    0,  236,  240,    0,    0,    0,   47,    0,
  149,    0,    0,  160,  161,  156,    0,  157,  152,    0,
    0,   79,    0,    0,    0,  237,    0,  238,  217,  218,
  220,  221,  223,  224,  226,  227,    0,   38,  148,  242,
    0,  158,  159,  154,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,   75,    0,   68,    0,   33,    0,
    0,    0,    0,    0,    0,    0,    0,   98,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,  121,    0,   83,    0,  239,  213,    0,
  150,  153,    0,  138,  205,    0,    0,    0,    0,  206,
  207,  208,    0,    0,    0,    0,    0,    0,    0,  190,
  193,  172,  192,    0,    0,    0,   90,   74,   70,    0,
    0,    0,    0,   66,   67,    0,   69,   86,    0,  102,
  101,    0,   92,    0,   96,   97,    0,    0,    0,    0,
    0,  109,  110,    0,  125,    0,    0,  123,    0,  100,
    0,  127,  126,    0,  118,  119,    0,  134,  135,    0,
   85,   81,   82,   84,    0,    0,  155,  196,    0,  197,
    0,    0,  164,  194,  195,  200,  199,    0,  202,  162,
  163,  174,    0,  191,  184,  251,   14,  250,    0,   15,
    0,  176,    0,   91,   87,   89,   71,   72,   76,   62,
  103,   94,    0,  113,  107,  105,  106,  108,  104,  112,
  111,  124,    0,    0,    0,  116,    0,  211,  212,  198,
    0,  169,    0,    0,  171,  245,  246,  248,    0,  244,
  247,  249,    0,  173,    0,    0,  181,    0,    0,  253,
  252,    0,  185,  129,    0,    0,    0,    0,    0,    0,
  165,    0,  203,  175,    0,    0,  177,  186,    0,    0,
    0,  170,  204,    0,  182,    0,    0,  168,  180,  120,
    0,    0,  117,  137,
};
const short yydgoto[] =
	{                                       1,
  370,   42,  371,  145,  340,   62,  384,  185,  100,   49,
  107,  109,   57,  198,  352,  117,   27,   75,  153,  161,
  113,  190,  150,  199,  225,  200,  289,  290,  226,  417,
  418,  291,  292,  363,  419,  360,  269,  102,  270,  402,
  403,  293,  404,  413,  373,  422,  294,  453,   28,   29,
   30,   31,  263,   33,   34,  235,  264,   88,  307,  236,
  203,  237,  238,   37,  202,  154,  265,  205,  266,  267,
  296,  297,  346,  227,
};
const short yysindex[] =
	{                                      0,
  144,   59, -251, -290, -229, -182, -274, -271, -268, -227,
 -237, -236, -264, -225, -235, -234, -212, -274, -274,    0,
    0,    0, -192, -210,   98,    0, -146,  157,  169,  171,
  176,  184,  186,  202,    0,    0,  -50,    0,    0,    0,
    0, -136,    0,    0, -129,    0, -290,    0,    0,    0,
    0,  208, -127,  -36, -111,    0,   -3,    0,    0,  193,
  194, -163,  -85,    0, -112, -217,  -51,    0,    0,    0,
 -101,    0, -236,    0,  -17,    0,    0,    0,    0,    0,
    0,    0, -180,    0,    0,    0,  208,  132, -238,  -92,
    0,    0,    0,  149,  -91,  -90,    0,    0,  -81,  -85,
  195,    0,  -80,    0,    0,  -89,  -76,    0,    0,  -75,
  -74,  -97, -126,  193,    0,    0,    0,    0,  208,  -84,
    4,    0,  208,    0,    0,  -85,    0,  -38,  -38,  -38,
  -39,  -34,  -33,  -94,  -69,  -66,  -73,  -30,  -67, -236,
    0,  188,  -64,    0,    0,  -89,    0,    0,  -62,    0,
    0,    0,  -86,  197,    0,   31,    0,    0,    0,    0,
  -54,  -47,  -28,    0,  -31,  -27,    0,  -21,  -20,    0,
  -13,  -12,    0,    0,    0,    0,    0,    0,    0,    0,
    0,  -11,   11,    0,    0,  -74,  208,  -89,    0,   -6,
    0, -251,    1,    0,    0,    0, -232,    0,    0,    0,
  208,    0,  605, -274,  610,    0,   17,    0,    0,    0,
    0,    0,    0,    0,    0,    0,  675,    0,    0,    0,
  -62,    0,    0,    0,   -2,  -85,  227,  642, -274,   22,
   23,   24, -236,  115,    0,  -68,    0,  371,    0,  371,
 -228,   25, -251, -251, -236, -290,   19,    0,   27,  -70,
   29, -203, -290,  122,   32,   34,   43, -274,   85, -274,
  195, -153,  371,    0,  470,    0,  371,    0,    0,   58,
    0,    0, -232,    0,    0,   48,   50,   52, -103,    0,
    0,    0,   40,   53, -243, -240, -240, -154,  227,    0,
    0,    0,    0,  -58,  371,  502,    0,    0,    0,   55,
   57,  -74,   60,    0,    0,  208,    0,    0,   61,    0,
    0, -136,    0,  -74,    0,    0,  107, -274, -274, -274,
 -274,    0,    0,   64,    0, -274, -274,    0,   66,    0,
  -98,    0,    0, -102,    0,    0,  293,    0,    0, -206,
    0,    0,    0,    0,  297,  675,    0,    0,   67,    0,
  -99, -240,    0,    0,    0,    0,    0,   10,    0,    0,
    0,    0,    7,    0,    0,    0,    0,    0,  -56,    0,
  -29,    0, -148,    0,    0,    0,    0,    0,    0,    0,
    0,    0,   68,    0,    0,    0,    0,    0,    0,    0,
    0,    0, -236, -236,  208,    0,   72,    0,    0,    0,
 -140,    0,  387,  308,    0,    0,    0,    0,  -29,    0,
    0,    0,   70,    0, -154,   77,    0,  387,  312,    0,
    0, -148,    0,    0,  -74,  -74,  675,   74,   20, -140,
    0,   78,    0,    0,   30,   77,    0,    0,   58,   84,
  -99,    0,    0,  -56,    0,  326,   89,    0,    0,    0,
   90,   91,    0,    0,};
const short yyrindex[] =
	{                                      0,
  179,    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, -208,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,  449,    0,    0,    0,    0,    0,    0,    0,    0,
    0,  341,    0,    0,    0,    0,  341,    0,    0,    0,
    0,    0,  458,    0,    0,    0,  462,    0,    0,    0,
    0,    0,    0,    0, -106,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,  303,    0,  463,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,  458,
  341,    0,    0,    0,    0,  464,    0,    0,    0,    0,
  478,    0,    0,   18,    0,    0,    0,    0,  689,    0,
    0,    0,  556,    0,    0,  458,    0,  126,  126,  126,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  464,    0,    0,    0,    0,
    0,    0,    0,  480,    0,  485,    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,  178,  691,  464,    0,  133,
    0,    0,    0,    0,    0,    0,    0,    0,    0,  139,
  696,    0,    0,    0,  179,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0, -197,  458,    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,  487,    0,  488,    0,    0,    0,    0,    0,
  341,    0,    0,    0,  179,    0,    0,    0,    0,  379,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  155,  155,    0,   -8,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,  492,    0,    0,    0,  400,    0,    0,    0,    0,
    0,  493,    0,  495,    0,    0,  496,    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,    0,    0,    0,
    0,   35,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0, -151,    0,    0,    0,    0,    0,    0,    0,
   -9,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,  691,    0,    0,    0,    0,    0,
    0,    0,  -96,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   15,    0,    0,
    0,    0,    0,    0,  498,  505,    0,    0, -133,    0,
    0,    0,    0,    0,   81,    0,    0,    0,  379,    0,
  401,    0,    0,  402,    0,    0,    0,    0,    0,    0,
  522,    0,    0,    0,};
const short yygindex[] =
	{                                      0,
   14, -139, -315,  -87,    0,  283,    0,    0,    0,   21,
  203,    0,  -65,   51,   41,    0,    0,    0,    0,  104,
    0,    0,  -88, -156,    0,    0,    0,  245,    0, -273,
  119,    0, -265,    0,  100, -200,  -83,  -78,  118, -260,
  141,    0,  105,    0,    0,  138,    0,    0,    0,    0,
    0,    0,  551,    0,    0,  555,  559,  -57, -152,    0,
    0,  325,    0,    0,    0,    0,    0,    0,  299, -178,
    0,  269, -176,    0,
};
#define YYTABLESIZE 1045
const short yytable[] =
	{                                      94,
  183,  189,  368,  165,  368,  166,   87,  111,  168,  171,
  169,  172,  182,  221,  183,  421,   41,  141,  353,  351,
  372,  127,  362,  401,  192,  149,  120,   55,  166,  118,
   45,  309,  356,   53,  183,   65,  197,  220,   69,   70,
  224,  220,  193,  142,  201,  194,  195,  159,  273,  295,
  220,  183,  222,   63,   44,   84,  304,  423,  189,  243,
  191,  155,  142,  220,  369,  158,  416,   87,   38,  411,
  410,  412,   43,  220,  186,  243,  326,  243,  201,   47,
  243,  243,  104,  105,  358,  196,  361,  308,   48,   58,
   59,  327,   50,  104,  105,   51,   54,   86,   60,   61,
  218,  220,  275,  312,  313,  243,  438,  142,  142,  121,
  341,   39,   40,  183,  344,  183,  347,  295,  219,   43,
  243,  359,  272,  116,   48,   55,   56,   66,   67,  217,
   43,  414,  271,  115,   46,  310,   52,  368,   64,  178,
   55,  243,  374,  228,  441,  106,  396,  274,  187,  434,
   68,  405,   72,   26,  444,   97,   98,  201,   73,  201,
   91,   92,  445,   71,  201,  243,   76,  302,   74,  442,
  192,  280,  281,  282,  243,  243,  243,  336,   77,  314,
   78,   99,  114,   61,  177,   79,  415,  241,  193,  151,
  152,  194,  195,   80,  229,   81,  338,  339,  230,  231,
  232,  104,  105,  337,   87,   41,  393,  394,   13,  146,
  146,   82,  345,  233,  367,   40,  318,   87,  319,  320,
  321,  241,   60,   61,  239,   83,  430,   40,  234,  243,
  243,  196,  162,  163,   85,   89,  365,   90,  365,   95,
   96,  436,  173,  174,  175,  176,  101,  183,  380,  298,
  103,  108,  430,  112,  119,  110,   41,   41,  436,   60,
   61,  188,  399,   60,   61,  148,  243,  243,   43,  322,
  122,  123,  124,  125,  144,  157,   43,  201,  333,  156,
  335,  126,  143,   58,   59,  183,  146,  147,   93,  180,
  160,  201,  323,  204,  178,  184,  315,  179,  188,  366,
  148,  366,  241,  328,  367,   40,  367,   40,  206,  243,
  187,  183,  183,  183,  183,  207,  183,  183,  183,  201,
  183,  183,  183,  189,  164,  382,  183,  425,  426,  167,
  170,  420,  209,  181,  208,  357,  210,  427,  385,  386,
  387,  388,  211,  212,  183,  183,  390,  391,  183,  288,
  213,  214,  215,  183,  183,  201,  201,  201,  201,   93,
  201,  201,  201,  223,  201,  201,  201,  406,  407,  408,
  201,  365,  243,  409,  216,  243,  303,  243,  243,  268,
  306,  446,  316,  329,  299,  300,  301,  311,  201,  201,
  317,  325,  334,  383,  330,  188,  331,  201,  201,    2,
    3,    4,    5,  354,    6,  332,    7,    8,    9,   10,
  348,  201,  349,   11,  350,  395,  355,  377,   12,  378,
   13,  398,  379,  428,  381,   61,  389,   61,  392,  400,
  220,  424,  431,  433,  366,   14,  437,  440,  243,  367,
   40,  443,   15,  243,  243,   16,  447,   17,   18,   19,
  450,  451,  452,  454,   77,   20,   21,   22,   21,  188,
  188,  188,  188,   61,  188,  188,  188,  209,  188,  188,
  187,   54,   30,   63,  188,  201,  201,  201,  201,   23,
  201,  201,  201,  275,  201,  201,  201,   19,  214,   88,
  201,   24,  188,  188,   32,  243,  122,   99,  241,  241,
  241,   73,   93,   61,   95,  128,   25,  114,  201,  201,
  241,  241,  241,  241,  115,  128,  129,  130,  241,  241,
  241,  241,  241,  241,   61,  167,  179,  131,  132,  133,
  134,  136,  324,  364,  435,  135,  136,  137,  138,  139,
  140,  429,  397,  449,  439,  448,  432,  276,  277,  278,
  279,   32,  280,  281,  282,   35,  283,  284,   61,   36,
  305,   61,  285,  343,  376,   61,    0,    0,    0,   61,
   61,   61,    0,   61,    0,    0,    0,    0,   61,   61,
  286,  287,   61,   61,   61,   61,   61,   61,   61,    0,
   61,    0,    0,    0,  342,   61,   61,    0,   61,   61,
   61,   61,    0,    0,    0,    0,   61,    0,   61,   61,
    0,    0,    0,   61,    0,    0,    0,    0,    0,    0,
    0,    0,    0,   61,   61,   61,  375,    0,    0,    0,
    0,    0,    0,    0,   61,   61,   61,   61,   61,    0,
    0,    0,    0,   61,   61,   61,   61,   61,   61,    0,
    0,   61,    0,    0,    0,   61,    0,    0,   61,    0,
    0,    0,   61,    0,    0,    0,   61,   61,   61,    0,
   61,    0,    0,    0,    0,   61,   61,    0,    0,   61,
   61,   61,   61,   61,   61,   61,    0,   61,    0,    0,
    0,    0,   61,   61,    0,   61,   61,   61,   61,  243,
  243,  243,    0,   61,    0,   61,   61,    0,    0,    0,
   61,  243,  243,  243,  243,    0,    0,    0,    0,  243,
  243,  243,  243,  243,  243,  240,    0,    0,  241,    0,
    0,   61,    0,    0,    0,    0,    0,    0,    0,    0,
  242,    0,    0,    0,    0,    0,    0,    0,   61,  243,
  244,  245,  246,  247,  248,  249,    0,  250,    0,    0,
  241,    0,  251,  252,    0,  253,  254,  255,  256,    0,
    0,    0,  242,  257,    0,  258,  259,    0,    0,    0,
  260,  243,  244,  245,  246,  247,  248,  249,    0,  250,
    0,    0,    0,    0,  251,  252,    0,  253,  254,  255,
  256,  261,    0,    0,    0,  257,    0,  258,  259,    0,
    0,   61,  260,    0,   61,    0,    0,    0,  262,    0,
    0,    0,    0,    0,    0,    0,   61,    0,    0,    0,
    0,   61,    0,  261,    0,   61,   61,   61,   61,   61,
   61,   61,    0,   61,    0,    0,    0,    0,   61,   61,
  262,   61,   61,   61,   61,    0,    0,    0,    0,   61,
    0,   61,   61,    0,    0,  240,   61,  229,  241,    0,
    0,  230,  231,  232,    0,    0,    0,    0,    0,    0,
  242,   13,    0,    0,    0,    0,  233,   61,    0,  243,
  244,  245,  246,  247,  248,  249,    0,  250,    0,    0,
  241,  234,  251,  252,   61,  253,  254,  255,  256,    0,
    0,    0,  242,  257,    0,  258,  259,    0,    0,    0,
  260,  243,  244,  245,  246,  247,  248,  249,    0,  250,
    0,    0,    0,    0,  251,  252,    0,  253,  254,  255,
  256,  261,    0,    0,    0,  257,    0,  258,  259,    0,
    0,   61,  260,    0,   61,   61,   61,   61,  262,    0,
    0,    0,    0,    0,    0,   61,   61,    0,    0,    0,
   61,    0,    0,  261,    0,   61,   61,   61,   61,   61,
   61,   61,    0,   61,    0,   61,    0,    0,   61,   61,
  262,   61,   61,   61,   61,  128,  129,  130,    0,   61,
    0,   61,   61,    0,    0,    0,   61,  131,  132,  133,
  134,   61,   61,   61,    0,  135,  136,  137,  138,  139,
  140,    0,    0,   61,   61,   61,   61,   61,    0,    0,
    0,   61,   61,   61,   61,   61,   61,    0,    0,    0,
    0,    0,    0,    0,   61,
};
const short yycheck[] =
	{                                      57,
   10,   10,   61,   43,   61,   45,   10,   73,   43,   43,
   45,   45,   43,  190,   45,   45,    3,  101,  279,  123,
  294,  100,  288,  123,  257,  123,  265,   10,  125,   87,
  260,  260,  276,  271,   44,  271,  123,   44,   18,   19,
  197,   44,  275,  101,   10,  278,  279,  126,  225,  228,
   44,   61,  192,   13,    4,   42,  125,  373,  146,  257,
  149,  119,  271,   44,  123,  123,  123,   10,   10,   60,
   61,   62,  363,   44,  140,   61,  280,  275,   44,  262,
  278,  279,  300,  301,  325,  318,  287,  240,  363,  354,
  355,  295,  364,  300,  301,  364,  334,   47,  363,  364,
  188,   44,  257,  243,  244,  257,  422,  316,  317,   89,
  263,  363,  364,  123,  267,  125,  273,  296,  125,  363,
  318,  362,  125,   83,  363,  363,  363,  363,  363,  187,
  363,  125,  221,   83,  364,  364,  364,   61,  364,  125,
  123,   61,  295,  201,  125,  363,  353,  226,   10,  415,
  363,  352,  363,   10,  125,  319,  320,  123,   61,  125,
  272,  273,  436,  356,   10,  363,   10,  233,  315,  430,
  257,  326,  327,  328,  326,  327,  328,  261,   10,  245,
   10,  345,  363,  364,  134,   10,  363,   10,  275,  316,
  317,  278,  279,   10,  263,   10,  350,  351,  267,  268,
  269,  300,  301,  261,   10,  192,  309,  310,  277,  316,
  317,   10,  270,  282,  363,  364,  287,   10,  289,  290,
  291,   44,  363,  364,  204,  276,  403,  364,  297,  363,
  364,  318,  129,  130,  364,  363,  295,  274,  295,   47,
   47,  418,  337,  338,  339,  340,  332,  257,  306,  229,
  363,  303,  429,  271,  123,  357,  243,  244,  435,  363,
  364,  123,  346,  363,  364,  363,  363,  364,  363,  340,
  363,  123,  364,  364,  364,  272,  363,  123,  258,  364,
  260,  363,  363,  354,  355,  295,  363,  363,  363,  363,
  329,  257,  363,  263,  364,  363,  246,  364,  363,  358,
  363,  358,  125,  253,  363,  364,  363,  364,  363,  295,
  123,  321,  322,  323,  324,  363,  326,  327,  328,  123,
  330,  331,  332,  332,  364,  312,  336,  393,  394,  364,
  364,  361,  364,  364,  363,  285,  364,  395,  318,  319,
  320,  321,  364,  364,  354,  355,  326,  327,  358,  123,
  364,  364,  364,  363,  364,  321,  322,  323,  324,  363,
  326,  327,  328,  363,  330,  331,  332,  358,  359,  360,
  336,  295,  358,  364,  364,  295,  262,  363,  364,  363,
   10,  439,  364,  262,  363,  363,  363,  363,  354,  355,
  364,  363,  308,  287,  363,  257,  363,  363,  364,  256,
  257,  258,  259,  364,  261,  363,  263,  264,  265,  266,
  363,  257,  363,  270,  363,  123,  364,  363,  275,  363,
  277,  125,  363,  352,  364,  123,  363,  125,  363,  363,
   44,  364,  125,  364,  358,  292,  125,  364,  358,  363,
  364,  364,  299,  363,  364,  302,  363,  304,  305,  306,
  125,  363,  363,  363,  276,  312,  313,  314,   10,  321,
  322,  323,  324,  123,  326,  327,  328,   10,  330,  331,
  332,   10,   10,   10,  336,  321,  322,  323,  324,  336,
  326,  327,  328,  257,  330,  331,  332,   10,  363,   10,
  336,  348,  354,  355,   10,  363,   10,   10,  321,  322,
  323,   10,   10,  125,   10,   10,  363,   10,  354,  355,
  333,  334,  335,  336,   10,  321,  322,  323,  341,  342,
  343,  344,  345,  346,  125,  125,  125,  333,  334,  335,
  336,   10,  250,  289,  416,  341,  342,  343,  344,  345,
  346,  401,  340,  444,  427,  441,  409,  321,  322,  323,
  324,    1,  326,  327,  328,    1,  330,  331,  256,    1,
  236,  259,  336,  265,  296,  263,   -1,   -1,   -1,  267,
  268,  269,   -1,  271,   -1,   -1,   -1,   -1,  276,  277,
  354,  355,  280,  281,  282,  283,  284,  285,  286,   -1,
  288,   -1,   -1,   -1,  125,  293,  294,   -1,  296,  297,
  298,  299,   -1,   -1,   -1,   -1,  304,   -1,  306,  307,
   -1,   -1,   -1,  311,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  321,  322,  323,  125,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,  332,  333,  334,  335,  336,   -1,
   -1,   -1,   -1,  341,  342,  343,  344,  345,  346,   -1,
   -1,  349,   -1,   -1,   -1,  256,   -1,   -1,  259,   -1,
   -1,   -1,  263,   -1,   -1,   -1,  267,  268,  269,   -1,
  271,   -1,   -1,   -1,   -1,  276,  277,   -1,   -1,  280,
  281,  282,  283,  284,  285,  286,   -1,  288,   -1,   -1,
   -1,   -1,  293,  294,   -1,  296,  297,  298,  299,  321,
  322,  323,   -1,  304,   -1,  306,  307,   -1,   -1,   -1,
  311,  333,  334,  335,  336,   -1,   -1,   -1,   -1,  341,
  342,  343,  344,  345,  346,  256,   -1,   -1,  259,   -1,
   -1,  332,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  271,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  349,  280,
  281,  282,  283,  284,  285,  286,   -1,  288,   -1,   -1,
  259,   -1,  293,  294,   -1,  296,  297,  298,  299,   -1,
   -1,   -1,  271,  304,   -1,  306,  307,   -1,   -1,   -1,
  311,  280,  281,  282,  283,  284,  285,  286,   -1,  288,
   -1,   -1,   -1,   -1,  293,  294,   -1,  296,  297,  298,
  299,  332,   -1,   -1,   -1,  304,   -1,  306,  307,   -1,
   -1,  256,  311,   -1,  259,   -1,   -1,   -1,  349,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,  271,   -1,   -1,   -1,
   -1,  276,   -1,  332,   -1,  280,  281,  282,  283,  284,
  285,  286,   -1,  288,   -1,   -1,   -1,   -1,  293,  294,
  349,  296,  297,  298,  299,   -1,   -1,   -1,   -1,  304,
   -1,  306,  307,   -1,   -1,  256,  311,  263,  259,   -1,
   -1,  267,  268,  269,   -1,   -1,   -1,   -1,   -1,   -1,
  271,  277,   -1,   -1,   -1,   -1,  282,  332,   -1,  280,
  281,  282,  283,  284,  285,  286,   -1,  288,   -1,   -1,
  259,  297,  293,  294,  349,  296,  297,  298,  299,   -1,
   -1,   -1,  271,  304,   -1,  306,  307,   -1,   -1,   -1,
  311,  280,  281,  282,  283,  284,  285,  286,   -1,  288,
   -1,   -1,   -1,   -1,  293,  294,   -1,  296,  297,  298,
  299,  332,   -1,   -1,   -1,  304,   -1,  306,  307,   -1,
   -1,  263,  311,   -1,  259,  267,  268,  269,  349,   -1,
   -1,   -1,   -1,   -1,   -1,  277,  271,   -1,   -1,   -1,
  282,   -1,   -1,  332,   -1,  280,  281,  282,  283,  284,
  285,  286,   -1,  288,   -1,  297,   -1,   -1,  293,  294,
  349,  296,  297,  298,  299,  321,  322,  323,   -1,  304,
   -1,  306,  307,   -1,   -1,   -1,  311,  333,  334,  335,
  336,  321,  322,  323,   -1,  341,  342,  343,  344,  345,
  346,   -1,   -1,  333,  334,  335,  336,  332,   -1,   -1,
   -1,  341,  342,  343,  344,  345,  346,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,  349,
};
#define YYFINAL 1
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 364
#if YYDEBUG
const char * const yyname[] =
	{
"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",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,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,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,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,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,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,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,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,"AS","ROUTERID","HOLDTIME","YMIN","LISTEN","ON","FIBUPDATE",
"FIBPRIORITY","RTABLE","RDOMAIN","RD","EXPORTTRGT","IMPORTTRGT","RDE","RIB",
"EVALUATE","IGNORE","COMPARE","GROUP","NEIGHBOR","NETWORK","EBGP","IBGP",
"LOCALAS","REMOTEAS","DESCR","LOCALADDR","MULTIHOP","PASSIVE","MAXPREFIX",
"RESTART","ANNOUNCE","CAPABILITIES","REFRESH","AS4BYTE","CONNECTRETRY","DEMOTE",
"ENFORCE","NEIGHBORAS","REFLECTOR","DEPEND","DOWN","DUMP","IN","OUT","SOCKET",
"RESTRICTED","LOG","ROUTECOLL","TRANSPARENT","TCP","MD5SIG","PASSWORD","KEY",
"TTLSECURITY","ALLOW","DENY","MATCH","QUICK","FROM","TO","ANY","CONNECTED",
"STATIC","COMMUNITY","EXTCOMMUNITY","LARGECOMMUNITY","PREFIX","PREFIXLEN",
"SOURCEAS","TRANSITAS","PEERAS","DELETE","MAXASLEN","MAXASSEQ","SET",
"LOCALPREF","MED","METRIC","NEXTHOP","REJECT","BLACKHOLE","NOMODIFY","SELF",
"PREPEND_SELF","PREPEND_PEER","PFTABLE","WEIGHT","RTLABEL","ORIGIN","ERROR",
"INCLUDE","IPSEC","ESP","AH","SPI","IKE","IPV4","IPV6","QUALIFY","VIA","NE",
"LE","GE","XRANGE","LONGER","STRING","NUMBER",
};
const char * const yyrule[] =
	{"$accept : grammar",
"grammar :",
"grammar : grammar '\\n'",
"grammar : grammar include '\\n'",
"grammar : grammar conf_main '\\n'",
"grammar : grammar varset '\\n'",
"grammar : grammar rdomain '\\n'",
"grammar : grammar neighbor '\\n'",
"grammar : grammar group '\\n'",
"grammar : grammar filterrule '\\n'",
"grammar : grammar error '\\n'",
"asnumber : NUMBER",
"as4number : STRING",
"as4number : asnumber",
"as4number_any : STRING",
"as4number_any : asnumber",
"string : string STRING",
"string : STRING",
"yesno : STRING",
"varset : STRING '=' string",
"include : INCLUDE STRING",
"conf_main : AS as4number",
"conf_main : AS as4number asnumber",
"conf_main : ROUTERID address",
"conf_main : HOLDTIME NUMBER",
"conf_main : HOLDTIME YMIN NUMBER",
"conf_main : LISTEN ON address",
"conf_main : FIBPRIORITY NUMBER",
"conf_main : FIBUPDATE yesno",
"conf_main : ROUTECOLL yesno",
"conf_main : RDE RIB STRING",
"conf_main : RDE RIB STRING yesno EVALUATE",
"conf_main : RDE RIB STRING RTABLE NUMBER",
"conf_main : RDE RIB STRING RTABLE NUMBER FIBUPDATE yesno",
"conf_main : TRANSPARENT yesno",
"conf_main : LOG STRING",
"conf_main : network",
"conf_main : DUMP STRING STRING optnumber",
"conf_main : DUMP RIB STRING STRING STRING optnumber",
"conf_main : mrtdump",
"conf_main : RDE STRING EVALUATE",
"conf_main : RDE STRING IGNORE",
"conf_main : RDE MED COMPARE STRING",
"conf_main : NEXTHOP QUALIFY VIA STRING",
"conf_main : RTABLE NUMBER",
"conf_main : CONNECTRETRY NUMBER",
"conf_main : SOCKET STRING restricted",
"mrtdump : DUMP STRING inout STRING optnumber",
"network : NETWORK prefix filter_set",
"network : NETWORK family RTLABEL STRING filter_set",
"network : NETWORK family nettype filter_set",
"inout : IN",
"inout : OUT",
"restricted : RESTRICTED",
"restricted :",
"address : STRING",
"prefix : STRING '/' NUMBER",
"prefix : NUMBER '/' NUMBER",
"addrspec : address",
"addrspec : prefix",
"optnl : '\\n' optnl",
"optnl :",
"nl : '\\n' optnl",
"optnumber :",
"optnumber : NUMBER",
"$$1 :",
"rdomain : RDOMAIN NUMBER optnl '{' optnl $$1 rdomainopts_l '}'",
"rdomainopts_l : rdomainopts_l rdomainoptsl",
"rdomainopts_l : rdomainoptsl",
"rdomainoptsl : rdomainopts nl",
"rdomainopts : RD STRING",
"rdomainopts : EXPORTTRGT STRING STRING",
"rdomainopts : IMPORTTRGT STRING STRING",
"rdomainopts : DESCR string",
"rdomainopts : FIBUPDATE yesno",
"rdomainopts : network",
"rdomainopts : DEPEND ON STRING",
"$$2 :",
"$$3 :",
"neighbor : $$2 NEIGHBOR addrspec $$3 peeropts_h",
"$$4 :",
"group : GROUP string optnl '{' optnl $$4 groupopts_l '}'",
"groupopts_l : groupopts_l groupoptsl",
"groupopts_l : groupoptsl",
"groupoptsl : peeropts nl",
"groupoptsl : neighbor nl",
"groupoptsl : error nl",
"peeropts_h : '{' optnl peeropts_l '}'",
"peeropts_h :",
"peeropts_l : peeropts_l peeroptsl",
"peeropts_l : peeroptsl",
"peeroptsl : peeropts nl",
"peeropts : REMOTEAS as4number",
"peeropts : LOCALAS as4number",
"peeropts : LOCALAS as4number asnumber",
"peeropts : DESCR string",
"peeropts : LOCALADDR address",
"peeropts : MULTIHOP NUMBER",
"peeropts : PASSIVE",
"peeropts : DOWN",
"peeropts : DOWN STRING",
"peeropts : RIB STRING",
"peeropts : HOLDTIME NUMBER",
"peeropts : HOLDTIME YMIN NUMBER",
"peeropts : ANNOUNCE family STRING",
"peeropts : ANNOUNCE CAPABILITIES yesno",
"peeropts : ANNOUNCE REFRESH yesno",
"peeropts : ANNOUNCE RESTART yesno",
"peeropts : ANNOUNCE AS4BYTE yesno",
"peeropts : ANNOUNCE SELF",
"peeropts : ANNOUNCE STRING",
"peeropts : ENFORCE NEIGHBORAS yesno",
"peeropts : ENFORCE LOCALAS yesno",
"peeropts : MAXPREFIX NUMBER restart",
"peeropts : TCP MD5SIG PASSWORD string",
"peeropts : TCP MD5SIG KEY string",
"peeropts : IPSEC espah IKE",
"peeropts : IPSEC espah inout SPI NUMBER STRING STRING encspec",
"peeropts : TTLSECURITY yesno",
"peeropts : SET filter_set_opt",
"peeropts : SET optnl '{' optnl filter_set_l optnl '}'",
"peeropts : mrtdump",
"peeropts : REFLECTOR",
"peeropts : REFLECTOR address",
"peeropts : DEPEND ON STRING",
"peeropts : DEMOTE STRING",
"peeropts : TRANSPARENT yesno",
"peeropts : LOG STRING",
"restart :",
"restart : RESTART NUMBER",
"family : IPV4",
"family : IPV6",
"nettype : STATIC",
"nettype : CONNECTED",
"espah : ESP",
"espah : AH",
"encspec :",
"encspec : STRING STRING",
"filterrule : action quick filter_rib_h direction filter_peer_h filter_match_h filter_set",
"action : ALLOW",
"action : DENY",
"action : MATCH",
"quick :",
"quick : QUICK",
"direction : FROM",
"direction : TO",
"filter_rib_h :",
"filter_rib_h : RIB filter_rib",
"filter_rib_h : RIB '{' filter_rib_l '}'",
"filter_rib_l : filter_rib",
"filter_rib_l : filter_rib_l comma filter_rib",
"filter_rib : STRING",
"filter_peer_h : filter_peer",
"filter_peer_h : '{' filter_peer_l '}'",
"filter_peer_l : filter_peer",
"filter_peer_l : filter_peer_l comma filter_peer",
"filter_peer : ANY",
"filter_peer : address",
"filter_peer : AS as4number",
"filter_peer : GROUP STRING",
"filter_peer : EBGP",
"filter_peer : IBGP",
"filter_prefix_h : IPV4 prefixlenop",
"filter_prefix_h : IPV6 prefixlenop",
"filter_prefix_h : PREFIX filter_prefix",
"filter_prefix_h : PREFIX '{' filter_prefix_m '}'",
"filter_prefix_m : filter_prefix_l",
"filter_prefix_m : '{' filter_prefix_l '}'",
"filter_prefix_m : '{' filter_prefix_l '}' filter_prefix_m",
"filter_prefix_l : filter_prefix",
"filter_prefix_l : filter_prefix_l comma filter_prefix",
"filter_prefix : prefix prefixlenop",
"filter_as_h : filter_as_t",
"filter_as_h : '{' filter_as_t_l '}'",
"filter_as_t_l : filter_as_t",
"filter_as_t_l : filter_as_t_l comma filter_as_t",
"filter_as_t : filter_as_type filter_as",
"filter_as_t : filter_as_type '{' filter_as_l_h '}'",
"filter_as_l_h : filter_as_l",
"filter_as_l_h : '{' filter_as_l '}'",
"filter_as_l_h : '{' filter_as_l '}' filter_as_l_h",
"filter_as_l : filter_as",
"filter_as_l : filter_as_l comma filter_as",
"filter_as : as4number_any",
"filter_as : NEIGHBORAS",
"filter_as : equalityop as4number_any",
"filter_as : as4number_any binaryop as4number_any",
"filter_match_h :",
"$$5 :",
"filter_match_h : $$5 filter_match",
"filter_match : filter_elm",
"filter_match : filter_match filter_elm",
"filter_elm : filter_prefix_h",
"filter_elm : filter_as_h",
"filter_elm : MAXASLEN NUMBER",
"filter_elm : MAXASSEQ NUMBER",
"filter_elm : COMMUNITY STRING",
"filter_elm : LARGECOMMUNITY STRING",
"filter_elm : EXTCOMMUNITY STRING STRING",
"filter_elm : NEXTHOP address",
"filter_elm : NEXTHOP NEIGHBOR",
"prefixlenop :",
"prefixlenop : LONGER",
"prefixlenop : PREFIXLEN unaryop NUMBER",
"prefixlenop : PREFIXLEN NUMBER binaryop NUMBER",
"filter_as_type : AS",
"filter_as_type : SOURCEAS",
"filter_as_type : TRANSITAS",
"filter_as_type : PEERAS",
"filter_set :",
"filter_set : SET filter_set_opt",
"filter_set : SET optnl '{' optnl filter_set_l optnl '}'",
"filter_set_l : filter_set_l comma filter_set_opt",
"filter_set_l : filter_set_opt",
"delete :",
"delete : DELETE",
"filter_set_opt : LOCALPREF NUMBER",
"filter_set_opt : LOCALPREF '+' NUMBER",
"filter_set_opt : LOCALPREF '-' NUMBER",
"filter_set_opt : MED NUMBER",
"filter_set_opt : MED '+' NUMBER",
"filter_set_opt : MED '-' NUMBER",
"filter_set_opt : METRIC NUMBER",
"filter_set_opt : METRIC '+' NUMBER",
"filter_set_opt : METRIC '-' NUMBER",
"filter_set_opt : WEIGHT NUMBER",
"filter_set_opt : WEIGHT '+' NUMBER",
"filter_set_opt : WEIGHT '-' NUMBER",
"filter_set_opt : NEXTHOP address",
"filter_set_opt : NEXTHOP BLACKHOLE",
"filter_set_opt : NEXTHOP REJECT",
"filter_set_opt : NEXTHOP NOMODIFY",
"filter_set_opt : NEXTHOP SELF",
"filter_set_opt : PREPEND_SELF NUMBER",
"filter_set_opt : PREPEND_PEER NUMBER",
"filter_set_opt : PFTABLE STRING",
"filter_set_opt : RTLABEL STRING",
"filter_set_opt : COMMUNITY delete STRING",
"filter_set_opt : LARGECOMMUNITY delete STRING",
"filter_set_opt : EXTCOMMUNITY delete STRING STRING",
"filter_set_opt : ORIGIN origincode",
"origincode : string",
"comma : ','",
"comma :",
"unaryop : '='",
"unaryop : NE",
"unaryop : LE",
"unaryop : '<'",
"unaryop : GE",
"unaryop : '>'",
"equalityop : '='",
"equalityop : NE",
"binaryop : '-'",
"binaryop : XRANGE",
};
#endif
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 10000
#define YYMAXDEPTH 10000
#endif
#endif
#define YYINITSTACKSIZE 200
/* LINTUSED */
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short *yyss;
short *yysslim;
YYSTYPE *yyvs;
unsigned int yystacksize;
int yyparse(void);
#line 2328 "parse.y"

struct keywords {
	const char	*k_name;
	int		 k_val;
};

int
yyerror(const char *fmt, ...)
{
	va_list		 ap;
	char		*msg;

	file->errors++;
	va_start(ap, fmt);
	if (vasprintf(&msg, fmt, ap) == -1)
		fatalx("yyerror vasprintf");
	va_end(ap);
	logit(LOG_CRIT, "%s:%d: %s", file->name, yylval.lineno, msg);
	free(msg);
	return (0);
}

int
kw_cmp(const void *k, const void *e)
{
	return (strcmp(k, ((const struct keywords *)e)->k_name));
}

int
lookup(char *s)
{
	/* this has to be sorted always */
	static const struct keywords keywords[] = {
		{ "AS",			AS},
		{ "IPv4",		IPV4},
		{ "IPv6",		IPV6},
		{ "ah",			AH},
		{ "allow",		ALLOW},
		{ "announce",		ANNOUNCE},
		{ "any",		ANY},
		{ "as-4byte",		AS4BYTE },
		{ "blackhole",		BLACKHOLE},
		{ "capabilities",	CAPABILITIES},
		{ "community",		COMMUNITY},
		{ "compare",		COMPARE},
		{ "connect-retry",	CONNECTRETRY},
		{ "connected",		CONNECTED},
		{ "delete",		DELETE},
		{ "demote",		DEMOTE},
		{ "deny",		DENY},
		{ "depend",		DEPEND},
		{ "descr",		DESCR},
		{ "down",		DOWN},
		{ "dump",		DUMP},
		{ "ebgp",		EBGP},
		{ "enforce",		ENFORCE},
		{ "esp",		ESP},
		{ "evaluate",		EVALUATE},
		{ "export-target",	EXPORTTRGT},
		{ "ext-community",	EXTCOMMUNITY},
		{ "fib-priority",	FIBPRIORITY},
		{ "fib-update",		FIBUPDATE},
		{ "from",		FROM},
		{ "group",		GROUP},
		{ "holdtime",		HOLDTIME},
		{ "ibgp",		IBGP},
		{ "ignore",		IGNORE},
		{ "ike",		IKE},
		{ "import-target",	IMPORTTRGT},
		{ "in",			IN},
		{ "include",		INCLUDE},
		{ "inet",		IPV4},
		{ "inet6",		IPV6},
		{ "ipsec",		IPSEC},
		{ "key",		KEY},
		{ "large-community",	LARGECOMMUNITY},
		{ "listen",		LISTEN},
		{ "local-address",	LOCALADDR},
		{ "local-as",		LOCALAS},
		{ "localpref",		LOCALPREF},
		{ "log",		LOG},
		{ "match",		MATCH},
		{ "max-as-len",		MAXASLEN},
		{ "max-as-seq",		MAXASSEQ},
		{ "max-prefix",		MAXPREFIX},
		{ "md5sig",		MD5SIG},
		{ "med",		MED},
		{ "metric",		METRIC},
		{ "min",		YMIN},
		{ "multihop",		MULTIHOP},
		{ "neighbor",		NEIGHBOR},
		{ "neighbor-as",	NEIGHBORAS},
		{ "network",		NETWORK},
		{ "nexthop",		NEXTHOP},
		{ "no-modify",		NOMODIFY},
		{ "on",			ON},
		{ "or-longer",		LONGER},
		{ "origin",		ORIGIN},
		{ "out",		OUT},
		{ "passive",		PASSIVE},
		{ "password",		PASSWORD},
		{ "peer-as",		PEERAS},
		{ "pftable",		PFTABLE},
		{ "prefix",		PREFIX},
		{ "prefixlen",		PREFIXLEN},
		{ "prepend-neighbor",	PREPEND_PEER},
		{ "prepend-self",	PREPEND_SELF},
		{ "qualify",		QUALIFY},
		{ "quick",		QUICK},
		{ "rd",			RD},
		{ "rde",		RDE},
		{ "rdomain",		RDOMAIN},
		{ "refresh",		REFRESH },
		{ "reject",		REJECT},
		{ "remote-as",		REMOTEAS},
		{ "restart",		RESTART},
		{ "restricted",		RESTRICTED},
		{ "rib",		RIB},
		{ "route-collector",	ROUTECOLL},
		{ "route-reflector",	REFLECTOR},
		{ "router-id",		ROUTERID},
		{ "rtable",		RTABLE},
		{ "rtlabel",		RTLABEL},
		{ "self",		SELF},
		{ "set",		SET},
		{ "socket",		SOCKET },
		{ "source-as",		SOURCEAS},
		{ "spi",		SPI},
		{ "static",		STATIC},
		{ "tcp",		TCP},
		{ "to",			TO},
		{ "transit-as",		TRANSITAS},
		{ "transparent-as",	TRANSPARENT},
		{ "ttl-security",	TTLSECURITY},
		{ "via",		VIA},
		{ "weight",		WEIGHT}
	};
	const struct keywords	*p;

	p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
	    sizeof(keywords[0]), kw_cmp);

	if (p)
		return (p->k_val);
	else
		return (STRING);
}

#define MAXPUSHBACK	128

u_char	*parsebuf;
int	 parseindex;
u_char	 pushback_buffer[MAXPUSHBACK];
int	 pushback_index = 0;

int
lgetc(int quotec)
{
	int		c, next;

	if (parsebuf) {
		/* Read character from the parsebuffer instead of input. */
		if (parseindex >= 0) {
			c = parsebuf[parseindex++];
			if (c != '\0')
				return (c);
			parsebuf = NULL;
		} else
			parseindex++;
	}

	if (pushback_index)
		return (pushback_buffer[--pushback_index]);

	if (quotec) {
		if ((c = getc(file->stream)) == EOF) {
			yyerror("reached end of file while parsing "
			    "quoted string");
			if (file == topfile || popfile() == EOF)
				return (EOF);
			return (quotec);
		}
		return (c);
	}

	while ((c = getc(file->stream)) == '\\') {
		next = getc(file->stream);
		if (next != '\n') {
			c = next;
			break;
		}
		yylval.lineno = file->lineno;
		file->lineno++;
	}

	while (c == EOF) {
		if (file == topfile || popfile() == EOF)
			return (EOF);
		c = getc(file->stream);
	}
	return (c);
}

int
lungetc(int c)
{
	if (c == EOF)
		return (EOF);
	if (parsebuf) {
		parseindex--;
		if (parseindex >= 0)
			return (c);
	}
	if (pushback_index < MAXPUSHBACK-1)
		return (pushback_buffer[pushback_index++] = c);
	else
		return (EOF);
}

int
findeol(void)
{
	int	c;

	parsebuf = NULL;

	/* skip to either EOF or the first real EOL */
	while (1) {
		if (pushback_index)
			c = pushback_buffer[--pushback_index];
		else
			c = lgetc(0);
		if (c == '\n') {
			file->lineno++;
			break;
		}
		if (c == EOF)
			break;
	}
	return (ERROR);
}

int
yylex(void)
{
	u_char	 buf[8096];
	u_char	*p, *val;
	int	 quotec, next, c;
	int	 token;

top:
	p = buf;
	while ((c = lgetc(0)) == ' ' || c == '\t')
		; /* nothing */

	yylval.lineno = file->lineno;
	if (c == '#')
		while ((c = lgetc(0)) != '\n' && c != EOF)
			; /* nothing */
	if (c == '$' && parsebuf == NULL) {
		while (1) {
			if ((c = lgetc(0)) == EOF)
				return (0);

			if (p + 1 >= buf + sizeof(buf) - 1) {
				yyerror("string too long");
				return (findeol());
			}
			if (isalnum(c) || c == '_') {
				*p++ = c;
				continue;
			}
			*p = '\0';
			lungetc(c);
			break;
		}
		val = symget(buf);
		if (val == NULL) {
			yyerror("macro '%s' not defined", buf);
			return (findeol());
		}
		parsebuf = val;
		parseindex = 0;
		goto top;
	}

	switch (c) {
	case '\'':
	case '"':
		quotec = c;
		while (1) {
			if ((c = lgetc(quotec)) == EOF)
				return (0);
			if (c == '\n') {
				file->lineno++;
				continue;
			} else if (c == '\\') {
				if ((next = lgetc(quotec)) == EOF)
					return (0);
				if (next == quotec || c == ' ' || c == '\t')
					c = next;
				else if (next == '\n') {
					file->lineno++;
					continue;
				} else
					lungetc(next);
			} else if (c == quotec) {
				*p = '\0';
				break;
			} else if (c == '\0') {
				yyerror("syntax error");
				return (findeol());
			}
			if (p + 1 >= buf + sizeof(buf) - 1) {
				yyerror("string too long");
				return (findeol());
			}
			*p++ = c;
		}
		yylval.v.string = strdup(buf);
		if (yylval.v.string == NULL)
			fatal("yylex: strdup");
		return (STRING);
	case '!':
		next = lgetc(0);
		if (next == '=')
			return (NE);
		lungetc(next);
		break;
	case '<':
		next = lgetc(0);
		if (next == '=')
			return (LE);
		lungetc(next);
		break;
	case '>':
		next = lgetc(0);
		if (next == '<')
			return (XRANGE);
		else if (next == '=')
			return (GE);
		lungetc(next);
		break;
	}

#define allowed_to_end_number(x) \
	(isspace(x) || x == ')' || x ==',' || x == '/' || x == '}' || x == '=')

	if (c == '-' || isdigit(c)) {
		do {
			*p++ = c;
			if ((unsigned)(p-buf) >= sizeof(buf)) {
				yyerror("string too long");
				return (findeol());
			}
		} while ((c = lgetc(0)) != EOF && isdigit(c));
		lungetc(c);
		if (p == buf + 1 && buf[0] == '-')
			goto nodigits;
		if (c == EOF || allowed_to_end_number(c)) {
			const char *errstr = NULL;

			*p = '\0';
			yylval.v.number = strtonum(buf, LLONG_MIN,
			    LLONG_MAX, &errstr);
			if (errstr) {
				yyerror("\"%s\" invalid number: %s",
				    buf, errstr);
				return (findeol());
			}
			return (NUMBER);
		} else {
nodigits:
			while (p > buf + 1)
				lungetc(*--p);
			c = *--p;
			if (c == '-')
				return (c);
		}
	}

#define allowed_in_string(x) \
	(isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \
	x != '{' && x != '}' && x != '<' && x != '>' && \
	x != '!' && x != '=' && x != '/' && x != '#' && \
	x != ','))

	if (isalnum(c) || c == ':' || c == '_' || c == '*') {
		do {
			*p++ = c;
			if ((unsigned)(p-buf) >= sizeof(buf)) {
				yyerror("string too long");
				return (findeol());
			}
		} while ((c = lgetc(0)) != EOF && (allowed_in_string(c)));
		lungetc(c);
		*p = '\0';
		if ((token = lookup(buf)) == STRING)
			if ((yylval.v.string = strdup(buf)) == NULL)
				fatal("yylex: strdup");
		return (token);
	}
	if (c == '\n') {
		yylval.lineno = file->lineno;
		file->lineno++;
	}
	if (c == EOF)
		return (0);
	return (c);
}

int
check_file_secrecy(int fd, const char *fname)
{
	struct stat	st;

	if (fstat(fd, &st)) {
		log_warn("cannot stat %s", fname);
		return (-1);
	}
	return (0);
}

struct file *
pushfile(const char *name, int secret)
{
	struct file	*nfile;

	if ((nfile = calloc(1, sizeof(struct file))) == NULL) {
		log_warn("malloc");
		return (NULL);
	}
	if ((nfile->name = strdup(name)) == NULL) {
		log_warn("malloc");
		free(nfile);
		return (NULL);
	}
	if ((nfile->stream = fopen(nfile->name, "r")) == NULL) {
		log_warn("%s", nfile->name);
		free(nfile->name);
		free(nfile);
		return (NULL);
	}
	if (secret &&
	    check_file_secrecy(fileno(nfile->stream), nfile->name)) {
		fclose(nfile->stream);
		free(nfile->name);
		free(nfile);
		return (NULL);
	}
	nfile->lineno = 1;
	TAILQ_INSERT_TAIL(&files, nfile, entry);
	return (nfile);
}

int
popfile(void)
{
	struct file	*prev;

	if ((prev = TAILQ_PREV(file, files, entry)) != NULL)
		prev->errors += file->errors;

	TAILQ_REMOVE(&files, file, entry);
	fclose(file->stream);
	free(file->name);
	free(file);
	file = prev;
	return (file ? 0 : EOF);
}

int
parse_config(char *filename, struct bgpd_config *xconf, struct peer **xpeers)
{
	struct sym		*sym, *next;
	struct peer		*p, *pnext;
	struct rde_rib		*rr;
	int			 errors = 0;

	conf = new_config();

	if ((filter_l = calloc(1, sizeof(struct filter_head))) == NULL)
		fatal(NULL);
	if ((peerfilter_l = calloc(1, sizeof(struct filter_head))) == NULL)
		fatal(NULL);
	if ((groupfilter_l = calloc(1, sizeof(struct filter_head))) == NULL)
		fatal(NULL);
	TAILQ_INIT(filter_l);
	TAILQ_INIT(peerfilter_l);
	TAILQ_INIT(groupfilter_l);

	peer_l = NULL;
	peer_l_old = *xpeers;
	curpeer = NULL;
	curgroup = NULL;
	id = 1;

	netconf = &conf->networks;

	add_rib("Adj-RIB-In", conf->default_tableid,
	    F_RIB_NOFIB | F_RIB_NOEVALUATE);
	add_rib("Loc-RIB", conf->default_tableid, F_RIB_LOCAL);

	if ((file = pushfile(filename, 1)) == NULL) {
		free(conf);
		return (-1);
	}
	topfile = file;

	yyparse();
	errors = file->errors;
	popfile();

	/* Free macros and check which have not been used. */
	TAILQ_FOREACH_SAFE(sym, &symhead, entry, next) {
		if ((cmd_opts & BGPD_OPT_VERBOSE2) && !sym->used)
			fprintf(stderr, "warning: macro \"%s\" not "
			    "used\n", sym->nam);
		if (!sym->persist) {
			free(sym->nam);
			free(sym->val);
			TAILQ_REMOVE(&symhead, sym, entry);
			free(sym);
		}
	}

	if (errors) {
		for (p = peer_l; p != NULL; p = pnext) {
			pnext = p->next;
			free(p);
		}

		while ((rr = SIMPLEQ_FIRST(&ribnames)) != NULL) {
			SIMPLEQ_REMOVE_HEAD(&ribnames, entry);
			free(rr);
		}

		filterlist_free(filter_l);
		filterlist_free(peerfilter_l);
		filterlist_free(groupfilter_l);

		free_config(conf);
	} else {
		/*
		 * Move filter list and static group and peer filtersets
		 * together. Static group sets come first then peer sets
		 * last normal filter rules.
		 */
		merge_filter_lists(conf->filters, groupfilter_l);
		merge_filter_lists(conf->filters, peerfilter_l);
		merge_filter_lists(conf->filters, filter_l);

		errors += mrt_mergeconfig(xconf->mrt, conf->mrt);
		errors += merge_config(xconf, conf, peer_l);
		*xpeers = peer_l;

		for (p = peer_l_old; p != NULL; p = pnext) {
			pnext = p->next;
			free(p);
		}

		free(filter_l);
		free(peerfilter_l);
		free(groupfilter_l);
	}

	return (errors ? -1 : 0);
}

int
symset(const char *nam, const char *val, int persist)
{
	struct sym	*sym;

	TAILQ_FOREACH(sym, &symhead, entry) {
		if (strcmp(nam, sym->nam) == 0)
			break;
	}

	if (sym != NULL) {
		if (sym->persist == 1)
			return (0);
		else {
			free(sym->nam);
			free(sym->val);
			TAILQ_REMOVE(&symhead, sym, entry);
			free(sym);
		}
	}
	if ((sym = calloc(1, sizeof(*sym))) == NULL)
		return (-1);

	sym->nam = strdup(nam);
	if (sym->nam == NULL) {
		free(sym);
		return (-1);
	}
	sym->val = strdup(val);
	if (sym->val == NULL) {
		free(sym->nam);
		free(sym);
		return (-1);
	}
	sym->used = 0;
	sym->persist = persist;
	TAILQ_INSERT_TAIL(&symhead, sym, entry);
	return (0);
}

int
cmdline_symset(char *s)
{
	char	*sym, *val;
	int	ret;
	size_t	len;

	if ((val = strrchr(s, '=')) == NULL)
		return (-1);

	len = strlen(s) - strlen(val) + 1;
	if ((sym = malloc(len)) == NULL)
		fatal("cmdline_symset: malloc");

	strlcpy(sym, s, len);

	ret = symset(sym, val + 1, 1);
	free(sym);

	return (ret);
}

char *
symget(const char *nam)
{
	struct sym	*sym;

	TAILQ_FOREACH(sym, &symhead, entry) {
		if (strcmp(nam, sym->nam) == 0) {
			sym->used = 1;
			return (sym->val);
		}
	}
	return (NULL);
}

int
getcommunity(char *s)
{
	int		 val;
	const char	*errstr;

	if (strcmp(s, "*") == 0)
		return (COMMUNITY_ANY);
	if (strcmp(s, "neighbor-as") == 0)
		return (COMMUNITY_NEIGHBOR_AS);
	if (strcmp(s, "local-as") == 0)
		return (COMMUNITY_LOCAL_AS);
	val = strtonum(s, 0, USHRT_MAX, &errstr);
	if (errstr) {
		yyerror("Community %s is %s (max: %u)", s, errstr, USHRT_MAX);
		return (COMMUNITY_ERROR);
	}
	return (val);
}

int
parsecommunity(struct filter_community *c, char *s)
{
	char *p;
	int i, as;

	/* Well-known communities */
	if (strcasecmp(s, "GRACEFUL_SHUTDOWN") == 0) {
		c->as = COMMUNITY_WELLKNOWN;
		c->type = COMMUNITY_GRACEFUL_SHUTDOWN;
		return (0);
	} else if (strcasecmp(s, "NO_EXPORT") == 0) {
		c->as = COMMUNITY_WELLKNOWN;
		c->type = COMMUNITY_NO_EXPORT;
		return (0);
	} else if (strcasecmp(s, "NO_ADVERTISE") == 0) {
		c->as = COMMUNITY_WELLKNOWN;
		c->type = COMMUNITY_NO_ADVERTISE;
		return (0);
	} else if (strcasecmp(s, "NO_EXPORT_SUBCONFED") == 0) {
		c->as = COMMUNITY_WELLKNOWN;
		c->type = COMMUNITY_NO_EXPSUBCONFED;
		return (0);
	} else if (strcasecmp(s, "NO_PEER") == 0) {
		c->as = COMMUNITY_WELLKNOWN;
		c->type = COMMUNITY_NO_PEER;
		return (0);
	} else if (strcasecmp(s, "BLACKHOLE") == 0) {
		c->as = COMMUNITY_WELLKNOWN;
		c->type = COMMUNITY_BLACKHOLE;
		return (0);
	}

	if ((p = strchr(s, ':')) == NULL) {
		yyerror("Bad community syntax");
		return (-1);
	}
	*p++ = 0;

	if ((i = getcommunity(s)) == COMMUNITY_ERROR)
		return (-1);
	as = i;

	if ((i = getcommunity(p)) == COMMUNITY_ERROR)
		return (-1);
	c->as = as;
	c->type = i;

	return (0);
}

int64_t
getlargecommunity(char *s)
{
	u_int		 val;
	const char	*errstr;

	if (strcmp(s, "*") == 0)
		return (COMMUNITY_ANY);
	if (strcmp(s, "neighbor-as") == 0)
		return (COMMUNITY_NEIGHBOR_AS);
	if (strcmp(s, "local-as") == 0)
		return (COMMUNITY_LOCAL_AS);
	val = strtonum(s, 0, UINT_MAX, &errstr);
	if (errstr) {
		yyerror("Large Community %s is %s (max: %u)",
		    s, errstr, UINT_MAX);
		return (COMMUNITY_ERROR);
	}
	return (val);
}

int
parselargecommunity(struct filter_largecommunity *c, char *s)
{
	char *p, *q;
	int64_t as, ld1, ld2;

	if ((p = strchr(s, ':')) == NULL) {
		yyerror("Bad community syntax");
		return (-1);
	}
	*p++ = 0;

	if ((q = strchr(p, ':')) == NULL) {
		yyerror("Bad community syntax");
		return (-1);
	}
	*q++ = 0;

	if ((as = getlargecommunity(s)) == COMMUNITY_ERROR)
		return (-1);

	if ((ld1 = getlargecommunity(p)) == COMMUNITY_ERROR)
		return (-1);

	if ((ld2 = getlargecommunity(q)) == COMMUNITY_ERROR)
		return (-1);

	c->as = as;
	c->ld1 = ld1;
	c->ld2 = ld2;

	return (0);
}

int
parsesubtype(char *name, int *type, int *subtype)
{
	const struct ext_comm_pairs *cp;
	int found = 0;

	for (cp = iana_ext_comms; cp->subname != NULL; cp++) {
		if (strcmp(name, cp->subname) == 0) {
			if (found == 0) {
				*type = cp->type;
				*subtype = cp->subtype;
			}
			found++;
		}
	}
	if (found > 1)
		*type = -1;
	return (found);
}

int
parseextvalue(char *s, u_int32_t *v)
{
	const char 	*errstr;
	char		*p;
	struct in_addr	 ip;
	u_int32_t	 uvalh = 0, uval;

	if ((p = strchr(s, '.')) == NULL) {
		/* AS_PLAIN number (4 or 2 byte) */
		uval = strtonum(s, 0, UINT_MAX, &errstr);
		if (errstr) {
			yyerror("Bad ext-community %s is %s", s, errstr);
			return (-1);
		}
		*v = uval;
		if (uval <= USHRT_MAX)
			return (EXT_COMMUNITY_TRANS_TWO_AS);
		else
			return (EXT_COMMUNITY_TRANS_FOUR_AS);
	} else if (strchr(p + 1, '.') == NULL) {
		/* AS_DOT number (4-byte) */
		*p++ = '\0';
		uvalh = strtonum(s, 0, USHRT_MAX, &errstr);
		if (errstr) {
			yyerror("Bad ext-community %s is %s", s, errstr);
			return (-1);
		}
		uval = strtonum(p, 0, USHRT_MAX, &errstr);
		if (errstr) {
			yyerror("Bad ext-community %s is %s", p, errstr);
			return (-1);
		}
		*v = uval | (uvalh << 16);
		return (EXT_COMMUNITY_TRANS_FOUR_AS);
	} else {
		/* more than one dot -> IP address */
		if (inet_aton(s, &ip) == 0) {
			yyerror("Bad ext-community %s not parseable", s);
			return (-1);
		}
		*v = ip.s_addr;
		return (EXT_COMMUNITY_TRANS_IPV4);
	}
	return (-1);
}

int
parseextcommunity(struct filter_extcommunity *c, char *t, char *s)
{
	const struct ext_comm_pairs *cp;
	const char 	*errstr;
	u_int64_t	 ullval;
	u_int32_t	 uval;
	char		*p, *ep;
	int		 type, subtype;

	if (parsesubtype(t, &type, &subtype) == 0) {
		yyerror("Bad ext-community unknown type");
		return (-1);
	}

	switch (type) {
	case -1:
		if ((p = strchr(s, ':')) == NULL) {
			yyerror("Bad ext-community %s", s);
			return (-1);
		}
		*p++ = '\0';
		if ((type = parseextvalue(s, &uval)) == -1)
			return (-1);
		switch (type) {
		case EXT_COMMUNITY_TRANS_TWO_AS:
			ullval = strtonum(p, 0, UINT_MAX, &errstr);
			break;
		case EXT_COMMUNITY_TRANS_IPV4:
		case EXT_COMMUNITY_TRANS_FOUR_AS:
			ullval = strtonum(p, 0, USHRT_MAX, &errstr);
			break;
		default:
			fatalx("parseextcommunity: unexpected result");
		}
		if (errstr) {
			yyerror("Bad ext-community %s is %s", p, errstr);
			return (-1);
		}
		switch (type) {
		case EXT_COMMUNITY_TRANS_TWO_AS:
			c->data.ext_as.as = uval;
			c->data.ext_as.val = ullval;
			break;
		case EXT_COMMUNITY_TRANS_IPV4:
			c->data.ext_ip.addr.s_addr = uval;
			c->data.ext_ip.val = ullval;
			break;
		case EXT_COMMUNITY_TRANS_FOUR_AS:
			c->data.ext_as4.as4 = uval;
			c->data.ext_as4.val = ullval;
			break;
		}
		break;
	case EXT_COMMUNITY_TRANS_OPAQUE:
	case EXT_COMMUNITY_TRANS_EVPN:
		errno = 0;
		ullval = strtoull(s, &ep, 0);
		if (s[0] == '\0' || *ep != '\0') {
			yyerror("Bad ext-community bad value");
			return (-1);
		}
		if (errno == ERANGE && ullval > EXT_COMMUNITY_OPAQUE_MAX) {
			yyerror("Bad ext-community value too big");
			return (-1);
		}
		c->data.ext_opaq = ullval;
		break;
	case EXT_COMMUNITY_NON_TRANS_OPAQUE:
		if (strcmp(s, "valid") == 0)
			c->data.ext_opaq = EXT_COMMUNITY_OVS_VALID;
		else if (strcmp(s, "invalid") == 0)
			c->data.ext_opaq = EXT_COMMUNITY_OVS_INVALID;
		else if (strcmp(s, "not-found") == 0)
			c->data.ext_opaq = EXT_COMMUNITY_OVS_NOTFOUND;
		else {
			yyerror("Bad ext-community %s", s);
			return (-1);
		}
		break;
	}
	c->type = type;
	c->subtype = subtype;

	/* verify type/subtype combo */
	for (cp = iana_ext_comms; cp->subname != NULL; cp++) {
		if (cp->type == type && cp->subtype == subtype) {
			c->flags |= EXT_COMMUNITY_FLAG_VALID;
			return (0);
		}
	}

	yyerror("Bad ext-community bad format for type");
	return (-1);
}

struct peer *
alloc_peer(void)
{
	struct peer	*p;
	u_int8_t	 i;

	if ((p = calloc(1, sizeof(struct peer))) == NULL)
		fatal("new_peer");

	/* some sane defaults */
	p->state = STATE_NONE;
	p->next = NULL;
	p->conf.distance = 1;
	p->conf.announce_type = ANNOUNCE_UNDEF;
	p->conf.announce_capa = 1;
	for (i = 0; i < AID_MAX; i++)
		p->conf.capabilities.mp[i] = -1;
	p->conf.capabilities.refresh = 1;
	p->conf.capabilities.grestart.restart = 1;
	p->conf.capabilities.as4byte = 1;
	p->conf.local_as = conf->as;
	p->conf.local_short_as = conf->short_as;

	return (p);
}

struct peer *
new_peer(void)
{
	struct peer		*p;

	p = alloc_peer();

	if (curgroup != NULL) {
		memcpy(p, curgroup, sizeof(struct peer));
		if (strlcpy(p->conf.group, curgroup->conf.group,
		    sizeof(p->conf.group)) >= sizeof(p->conf.group))
			fatalx("new_peer group strlcpy");
		if (strlcpy(p->conf.descr, curgroup->conf.descr,
		    sizeof(p->conf.descr)) >= sizeof(p->conf.descr))
			fatalx("new_peer descr strlcpy");
		p->conf.groupid = curgroup->conf.id;
		p->conf.local_as = curgroup->conf.local_as;
		p->conf.local_short_as = curgroup->conf.local_short_as;
	}
	p->next = NULL;
	if (conf->flags & BGPD_FLAG_DECISION_TRANS_AS)
		p->conf.flags |= PEERFLAG_TRANS_AS;
	return (p);
}

struct peer *
new_group(void)
{
	return (alloc_peer());
}

int
add_mrtconfig(enum mrt_type type, char *name, int timeout, struct peer *p,
    char *rib)
{
	struct mrt	*m, *n;

	LIST_FOREACH(m, conf->mrt, entry) {
		if ((rib && strcmp(rib, m->rib)) ||
		    (!rib && *m->rib))
			continue;
		if (p == NULL) {
			if (m->peer_id != 0 || m->group_id != 0)
				continue;
		} else {
			if (m->peer_id != p->conf.id ||
			    m->group_id != p->conf.groupid)
				continue;
		}
		if (m->type == type) {
			yyerror("only one mrtdump per type allowed.");
			return (-1);
		}
	}

	if ((n = calloc(1, sizeof(struct mrt_config))) == NULL)
		fatal("add_mrtconfig");

	n->type = type;
	if (strlcpy(MRT2MC(n)->name, name, sizeof(MRT2MC(n)->name)) >=
	    sizeof(MRT2MC(n)->name)) {
		yyerror("filename \"%s\" too long: max %zu",
		    name, sizeof(MRT2MC(n)->name) - 1);
		free(n);
		return (-1);
	}
	MRT2MC(n)->ReopenTimerInterval = timeout;
	if (p != NULL) {
		if (curgroup == p) {
			n->peer_id = 0;
			n->group_id = p->conf.id;
		} else {
			n->peer_id = p->conf.id;
			n->group_id = 0;
		}
	}
	if (rib) {
		if (!find_rib(rib)) {
			yyerror("rib \"%s\" does not exist.", rib);
			free(n);
			return (-1);
		}
		if (strlcpy(n->rib, rib, sizeof(n->rib)) >=
		    sizeof(n->rib)) {
			yyerror("rib name \"%s\" too long: max %zu",
			    name, sizeof(n->rib) - 1);
			free(n);
			return (-1);
		}
	}

	LIST_INSERT_HEAD(conf->mrt, n, entry);

	return (0);
}

int
add_rib(char *name, u_int rtableid, u_int16_t flags)
{
	struct rde_rib	*rr;
	u_int		 rdom, default_rdom;

	if ((rr = find_rib(name)) == NULL) {
		if ((rr = calloc(1, sizeof(*rr))) == NULL) {
			log_warn("add_rib");
			return (-1);
		}
	}
	if (strlcpy(rr->name, name, sizeof(rr->name)) >= sizeof(rr->name)) {
		yyerror("rib name \"%s\" too long: max %zu",
		   name, sizeof(rr->name) - 1);
		free(rr);
		return (-1);
	}
	rr->flags |= flags;
	if ((rr->flags & F_RIB_HASNOFIB) == 0) {
		if (ktable_exists(rtableid, &rdom) != 1) {
			yyerror("rtable id %u does not exist", rtableid);
			free(rr);
			return (-1);
		}
		if (ktable_exists(conf->default_tableid, &default_rdom) != 1)
			fatal("default rtable %u does not exist",
			    conf->default_tableid);
		if (rdom != default_rdom) {
			log_warnx("rtable %u does not belong to rdomain %u",
			    rtableid, default_rdom);
			free(rr);
			return (-1);
		}
		rr->rtableid = rtableid;
	}
	SIMPLEQ_INSERT_TAIL(&ribnames, rr, entry);
	return (0);
}

struct rde_rib *
find_rib(char *name)
{
	struct rde_rib	*rr;

	SIMPLEQ_FOREACH(rr, &ribnames, entry) {
		if (!strcmp(rr->name, name))
			return (rr);
	}
	return (NULL);
}

int
get_id(struct peer *newpeer)
{
	struct peer	*p;

	for (p = peer_l_old; p != NULL; p = p->next)
		if (newpeer->conf.remote_addr.aid) {
			if (!memcmp(&p->conf.remote_addr,
			    &newpeer->conf.remote_addr,
			    sizeof(p->conf.remote_addr))) {
				newpeer->conf.id = p->conf.id;
				return (0);
			}
		} else {	/* newpeer is a group */
			if (strcmp(newpeer->conf.group, p->conf.group) == 0) {
				newpeer->conf.id = p->conf.groupid;
				return (0);
			}
		}

	/* new one */
	for (; id < UINT_MAX / 2; id++) {
		for (p = peer_l_old; p != NULL &&
		    p->conf.id != id && p->conf.groupid != id; p = p->next)
			;	/* nothing */
		if (p == NULL) {	/* we found a free id */
			newpeer->conf.id = id++;
			return (0);
		}
	}

	return (-1);
}

int
merge_prefixspec(struct filter_prefix_l *p, struct filter_prefixlen *pl)
{
	u_int8_t max_len = 0;

	switch (p->p.addr.aid) {
	case AID_INET:
	case AID_VPN_IPv4:
		max_len = 32;
		break;
	case AID_INET6:
		max_len = 128;
		break;
	}

	switch (pl->op) {
	case OP_NONE:
		return (0);
	case OP_RANGE:
	case OP_XRANGE:
		if (pl->len_min > max_len || pl->len_max > max_len) {
			yyerror("prefixlen %d too big for AF, limit %d",
			    pl->len_min > max_len ? pl->len_min : pl->len_max,
			    max_len);
			return (-1);
		}
		if (pl->len_min < p->p.len) {
			yyerror("prefixlen %d smaller than prefix, limit %d",
			    pl->len_min, p->p.len);
			return (-1);
		}
		p->p.len_max = pl->len_max;
		break;
	case OP_GE:
		/* fix up the "or-longer" case */
		if (pl->len_min == -1)
			pl->len_min = p->p.len;
		/* FALLTHROUGH */
	case OP_EQ:
	case OP_NE:
	case OP_LE:
	case OP_GT:
		if (pl->len_min > max_len) {
			yyerror("prefixlen %d too big for AF, limit %d",
			    pl->len_min, max_len);
			return (-1);
		}
		if (pl->len_min < p->p.len) {
			yyerror("prefixlen %d smaller than prefix, limit %d",
			    pl->len_min, p->p.len);
			return (-1);
		}
		break;
	case OP_LT:
		if (pl->len_min > max_len - 1) {
			yyerror("prefixlen %d too big for AF, limit %d",
			    pl->len_min, max_len - 1);
			return (-1);
		}
		if (pl->len_min < p->p.len + 1) {
			yyerror("prefixlen %d too small for prefix, limit %d",
			    pl->len_min, p->p.len + 1);
			return (-1);
		}
		break;
	}

	p->p.op = pl->op;
	p->p.len_min = pl->len_min;
	return (0);
}

int
expand_rule(struct filter_rule *rule, struct filter_rib_l *rib,
    struct filter_peers_l *peer, struct filter_match_l *match,
    struct filter_set_head *set)
{
	struct filter_rule	*r;
	struct filter_rib_l	*rb, *rbnext;
	struct filter_peers_l	*p, *pnext;
	struct filter_prefix_l	*prefix, *prefix_next;
	struct filter_as_l	*a, *anext;
	struct filter_set	*s;

	rb = rib;
	do {
		p = peer;
		do {
			a = match->as_l;
			do {
				prefix = match->prefix_l;
				do {
					if ((r = calloc(1,
					    sizeof(struct filter_rule))) ==
						 NULL) {
						log_warn("expand_rule");
						return (-1);
					}

					memcpy(r, rule, sizeof(struct filter_rule));
					memcpy(&r->match, match,
					    sizeof(struct filter_match));
					TAILQ_INIT(&r->set);
					copy_filterset(set, &r->set);

					if (rb != NULL)
						strlcpy(r->rib, rb->name,
						     sizeof(r->rib));

					if (p != NULL)
						memcpy(&r->peer, &p->p,
						    sizeof(struct filter_peers));

					if (prefix != NULL)
						memcpy(&r->match.prefix, &prefix->p,
						    sizeof(r->match.prefix));

					if (a != NULL)
						memcpy(&r->match.as, &a->a,
						    sizeof(struct filter_as));

					TAILQ_INSERT_TAIL(filter_l, r, entry);

					if (prefix != NULL)
						prefix = prefix->next;
				} while (prefix != NULL);

				if (a != NULL)
					a = a->next;
			} while (a != NULL);

			if (p != NULL)
				p = p->next;
		} while (p != NULL);

		if (rb != NULL)
			rb = rb->next;
	} while (rb != NULL);

	for (rb = rib; rb != NULL; rb = rbnext) {
		rbnext = rb->next;
		free(rb);
	}

	for (p = peer; p != NULL; p = pnext) {
		pnext = p->next;
		free(p);
	}

	for (a = match->as_l; a != NULL; a = anext) {
		anext = a->next;
		free(a);
	}

	for (prefix = match->prefix_l; prefix != NULL; prefix = prefix_next) {
		prefix_next = prefix->next;
		free(prefix);
	}

	if (set != NULL) {
		while ((s = TAILQ_FIRST(set)) != NULL) {
			TAILQ_REMOVE(set, s, entry);
			free(s);
		}
		free(set);
	}

	return (0);
}

int
str2key(char *s, char *dest, size_t max_len)
{
	unsigned	i;
	char		t[3];

	if (strlen(s) / 2 > max_len) {
		yyerror("key too long");
		return (-1);
	}

	if (strlen(s) % 2) {
		yyerror("key must be of even length");
		return (-1);
	}

	for (i = 0; i < strlen(s) / 2; i++) {
		t[0] = s[2*i];
		t[1] = s[2*i + 1];
		t[2] = 0;
		if (!isxdigit(t[0]) || !isxdigit(t[1])) {
			yyerror("key must be specified in hex");
			return (-1);
		}
		dest[i] = strtoul(t, NULL, 16);
	}

	return (0);
}

int
neighbor_consistent(struct peer *p)
{
	u_int8_t	i;

	/* local-address and peer's address: same address family */
	if (p->conf.local_addr.aid &&
	    p->conf.local_addr.aid != p->conf.remote_addr.aid) {
		yyerror("local-address and neighbor address "
		    "must be of the same address family");
		return (-1);
	}

	/* with any form of ipsec local-address is required */
	if ((p->conf.auth.method == AUTH_IPSEC_IKE_ESP ||
	    p->conf.auth.method == AUTH_IPSEC_IKE_AH ||
	    p->conf.auth.method == AUTH_IPSEC_MANUAL_ESP ||
	    p->conf.auth.method == AUTH_IPSEC_MANUAL_AH) &&
	    !p->conf.local_addr.aid) {
		yyerror("neighbors with any form of IPsec configured "
		    "need local-address to be specified");
		return (-1);
	}

	/* with static keying we need both directions */
	if ((p->conf.auth.method == AUTH_IPSEC_MANUAL_ESP ||
	    p->conf.auth.method == AUTH_IPSEC_MANUAL_AH) &&
	    (!p->conf.auth.spi_in || !p->conf.auth.spi_out)) {
		yyerror("with manual keyed IPsec, SPIs and keys "
		    "for both directions are required");
		return (-1);
	}

	if (!conf->as) {
		yyerror("AS needs to be given before neighbor definitions");
		return (-1);
	}

	/* set default values if they where undefined */
	p->conf.ebgp = (p->conf.remote_as != conf->as);
	if (p->conf.announce_type == ANNOUNCE_UNDEF)
		p->conf.announce_type = p->conf.ebgp ?
		    ANNOUNCE_SELF : ANNOUNCE_ALL;
	if (p->conf.enforce_as == ENFORCE_AS_UNDEF)
		p->conf.enforce_as = p->conf.ebgp ?
		    ENFORCE_AS_ON : ENFORCE_AS_OFF;
	if (p->conf.enforce_local_as == ENFORCE_AS_UNDEF)
		p->conf.enforce_local_as = ENFORCE_AS_ON;

	if (p->conf.remote_as == 0 && p->conf.enforce_as != ENFORCE_AS_OFF) {
		yyerror("peer AS may not be zero");
		return (-1);
	}

	/* EBGP neighbors are not allowed in route reflector clusters */
	if (p->conf.reflector_client && p->conf.ebgp) {
		yyerror("EBGP neighbors are not allowed in route "
		    "reflector clusters");
		return (-1);
	}

	/* the default MP capability is NONE */
	for (i = 0; i < AID_MAX; i++)
		if (p->conf.capabilities.mp[i] == -1)
			p->conf.capabilities.mp[i] = 0;

	return (0);
}

int
merge_filterset(struct filter_set_head *sh, struct filter_set *s)
{
	struct filter_set	*t;

	TAILQ_FOREACH(t, sh, entry) {
		/*
		 * need to cycle across the full list because even
		 * if types are not equal filterset_cmp() may return 0.
		 */
		if (filterset_cmp(s, t) == 0) {
			if (s->type == ACTION_SET_COMMUNITY)
				yyerror("community is already set");
			else if (s->type == ACTION_DEL_COMMUNITY)
				yyerror("community will already be deleted");
			else if (s->type == ACTION_SET_LARGE_COMMUNITY)
				yyerror("large-community is already set");
			else if (s->type == ACTION_DEL_LARGE_COMMUNITY)
				yyerror("large-community will already be deleted");
			else if (s->type == ACTION_SET_EXT_COMMUNITY)
				yyerror("ext-community is already set");
			else if (s->type == ACTION_DEL_EXT_COMMUNITY)
				yyerror(
				    "ext-community will already be deleted");
			else
				yyerror("redefining set parameter %s",
				    filterset_name(s->type));
			return (-1);
		}
	}

	TAILQ_FOREACH(t, sh, entry) {
		if (s->type < t->type) {
			TAILQ_INSERT_BEFORE(t, s, entry);
			return (0);
		}
		if (s->type == t->type)
			switch (s->type) {
			case ACTION_SET_COMMUNITY:
			case ACTION_DEL_COMMUNITY:
				if (s->action.community.as <
				    t->action.community.as ||
				    (s->action.community.as ==
				    t->action.community.as &&
				    s->action.community.type <
				    t->action.community.type)) {
					TAILQ_INSERT_BEFORE(t, s, entry);
					return (0);
				}
				break;
			case ACTION_SET_LARGE_COMMUNITY:
			case ACTION_DEL_LARGE_COMMUNITY:
				if (s->action.large_community.as <
				    t->action.large_community.as ||
				    (s->action.large_community.as ==
				    t->action.large_community.as &&
				    s->action.large_community.ld1 <
				    t->action.large_community.ld2 )) {
					TAILQ_INSERT_BEFORE(t, s, entry);
					return (0);
				}
				break;
			case ACTION_SET_EXT_COMMUNITY:
			case ACTION_DEL_EXT_COMMUNITY:
				if (memcmp(&s->action.ext_community,
				    &t->action.ext_community,
				    sizeof(s->action.ext_community)) < 0) {
					TAILQ_INSERT_BEFORE(t, s, entry);
					return (0);
				}
				break;
			case ACTION_SET_NEXTHOP:
				if (s->action.nexthop.aid <
				    t->action.nexthop.aid) {
					TAILQ_INSERT_BEFORE(t, s, entry);
					return (0);
				}
				break;
			default:
				break;
			}
	}

	TAILQ_INSERT_TAIL(sh, s, entry);
	return (0);
}

void
copy_filterset(struct filter_set_head *source, struct filter_set_head *dest)
{
	struct filter_set	*s, *t;

	if (source == NULL)
		return;

	TAILQ_FOREACH(s, source, entry) {
		if ((t = malloc(sizeof(struct filter_set))) == NULL)
			fatal(NULL);
		memcpy(t, s, sizeof(struct filter_set));
		TAILQ_INSERT_TAIL(dest, t, entry);
	}
}

void
merge_filter_lists(struct filter_head *dst, struct filter_head *src)
{
	struct filter_rule *r;

	while ((r = TAILQ_FIRST(src)) != NULL) {
		TAILQ_REMOVE(src, r, entry);
		TAILQ_INSERT_TAIL(dst, r, entry);
	}
}

struct filter_rule *
get_rule(enum action_types type)
{
	struct filter_rule	*r;
	int			 out;

	switch (type) {
	case ACTION_SET_PREPEND_SELF:
	case ACTION_SET_NEXTHOP_NOMODIFY:
	case ACTION_SET_NEXTHOP_SELF:
		out = 1;
		break;
	default:
		out = 0;
		break;
	}
	r = (curpeer == curgroup) ? curgroup_filter[out] : curpeer_filter[out];
	if (r == NULL) {
		if ((r = calloc(1, sizeof(struct filter_rule))) == NULL)
			fatal(NULL);
		r->quick = 0;
		r->dir = out ? DIR_OUT : DIR_IN;
		r->action = ACTION_NONE;
		r->match.community.as = COMMUNITY_UNSET;
		r->match.large_community.as = COMMUNITY_UNSET;
		TAILQ_INIT(&r->set);
		if (curpeer == curgroup) {
			/* group */
			r->peer.groupid = curgroup->conf.id;
			curgroup_filter[out] = r;
		} else {
			/* peer */
			r->peer.peerid = curpeer->conf.id;
			curpeer_filter[out] = r;
		}
	}
	return (r);
}
#line 2595 "parse.c"
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(void)
{
    unsigned int newsize;
    long sslen;
    short *newss;
    YYSTYPE *newvs;

    if ((newsize = yystacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return -1;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;
    sslen = yyssp - yyss;
#ifdef SIZE_MAX
#define YY_SIZE_MAX SIZE_MAX
#else
#define YY_SIZE_MAX 0xffffffffU
#endif
    if (newsize && YY_SIZE_MAX / newsize < sizeof *newss)
        goto bail;
    newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
      (short *)malloc(newsize * sizeof *newss); /* overflow check above */
    if (newss == NULL)
        goto bail;
    yyss = newss;
    yyssp = newss + sslen;
    if (newsize && YY_SIZE_MAX / newsize < sizeof *newvs)
        goto bail;
    newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
      (YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */
    if (newvs == NULL)
        goto bail;
    yyvs = newvs;
    yyvsp = newvs + sslen;
    yystacksize = newsize;
    yysslim = yyss + newsize - 1;
    return 0;
bail:
    if (yyss)
            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 ((yys = getenv("YYDEBUG")))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif /* YYDEBUG */

    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);

    if (yyss == NULL && yygrowstack()) goto yyoverflow;
    yyssp = yyss;
    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)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yyssp >= yysslim && yygrowstack())
        {
            goto yyoverflow;
        }
        *++yyssp = yystate = yytable[yyn];
        *++yyvsp = yylval;
        yychar = (-1);
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;
#if defined(__GNUC__)
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#if defined(__GNUC__)
    goto yyerrlab;
#endif
yyerrlab:
    ++yynerrs;
yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#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
                if (yyssp <= yyss) goto yyabort;
                --yyssp;
                --yyvsp;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            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);
        goto yyloop;
    }
yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    if (yym)
        yyval = yyvsp[1-yym];
    else
        memset(&yyval, 0, sizeof yyval);
    switch (yyn)
    {
case 10:
#line 243 "parse.y"
{ file->errors++; }
break;
case 11:
#line 246 "parse.y"
{
			/*
			 * According to iana 65535 and 4294967295 are reserved
			 * but enforcing this is not duty of the parser.
			 */
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > UINT_MAX) {
				yyerror("AS too big: max %u", UINT_MAX);
				YYERROR;
			}
		}
break;
case 12:
#line 257 "parse.y"
{
			const char	*errstr;
			char		*dot;
			u_int32_t	 uvalh = 0, uval;

			if ((dot = strchr(yyvsp[0].v.string,'.')) != NULL) {
				*dot++ = '\0';
				uvalh = strtonum(yyvsp[0].v.string, 0, USHRT_MAX, &errstr);
				if (errstr) {
					yyerror("number %s is %s", yyvsp[0].v.string, errstr);
					free(yyvsp[0].v.string);
					YYERROR;
				}
				uval = strtonum(dot, 0, USHRT_MAX, &errstr);
				if (errstr) {
					yyerror("number %s is %s", dot, errstr);
					free(yyvsp[0].v.string);
					YYERROR;
				}
				free(yyvsp[0].v.string);
			} else {
				yyerror("AS %s is bad", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			if (uvalh == 0 && uval == AS_TRANS) {
				yyerror("AS %u is reserved and may not be used",
				    AS_TRANS);
				YYERROR;
			}
			yyval.v.number = uval | (uvalh << 16);
		}
break;
case 13:
#line 289 "parse.y"
{
			if (yyvsp[0].v.number == AS_TRANS) {
				yyerror("AS %u is reserved and may not be used",
				    AS_TRANS);
				YYERROR;
			}
			yyval.v.number = yyvsp[0].v.number;
		}
break;
case 14:
#line 299 "parse.y"
{
			const char	*errstr;
			char		*dot;
			u_int32_t	 uvalh = 0, uval;

			if ((dot = strchr(yyvsp[0].v.string,'.')) != NULL) {
				*dot++ = '\0';
				uvalh = strtonum(yyvsp[0].v.string, 0, USHRT_MAX, &errstr);
				if (errstr) {
					yyerror("number %s is %s", yyvsp[0].v.string, errstr);
					free(yyvsp[0].v.string);
					YYERROR;
				}
				uval = strtonum(dot, 0, USHRT_MAX, &errstr);
				if (errstr) {
					yyerror("number %s is %s", dot, errstr);
					free(yyvsp[0].v.string);
					YYERROR;
				}
				free(yyvsp[0].v.string);
			} else {
				yyerror("AS %s is bad", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			yyval.v.number = uval | (uvalh << 16);
		}
break;
case 15:
#line 326 "parse.y"
{
			yyval.v.number = yyvsp[0].v.number;
		}
break;
case 16:
#line 331 "parse.y"
{
			if (asprintf(&yyval.v.string, "%s %s", yyvsp[-1].v.string, yyvsp[0].v.string) == -1)
				fatal("string: asprintf");
			free(yyvsp[-1].v.string);
			free(yyvsp[0].v.string);
		}
break;
case 18:
#line 340 "parse.y"
{
			if (!strcmp(yyvsp[0].v.string, "yes"))
				yyval.v.number = 1;
			else if (!strcmp(yyvsp[0].v.string, "no"))
				yyval.v.number = 0;
			else {
				yyerror("syntax error, "
				    "either yes or no expected");
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 19:
#line 355 "parse.y"
{
			char *s = yyvsp[-2].v.string;
			if (cmd_opts & BGPD_OPT_VERBOSE)
				printf("%s = \"%s\"\n", yyvsp[-2].v.string, yyvsp[0].v.string);
			while (*s++) {
				if (isspace((unsigned char)*s)) {
					yyerror("macro name cannot contain "
					    "whitespace");
					YYERROR;
				}
			}
			if (symset(yyvsp[-2].v.string, yyvsp[0].v.string, 0) == -1)
				fatal("cannot store variable");
			free(yyvsp[-2].v.string);
			free(yyvsp[0].v.string);
		}
break;
case 20:
#line 373 "parse.y"
{
			struct file	*nfile;

			if ((nfile = pushfile(yyvsp[0].v.string, 1)) == NULL) {
				yyerror("failed to include file %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);

			file = nfile;
			lungetc('\n');
		}
break;
case 21:
#line 388 "parse.y"
{
			conf->as = yyvsp[0].v.number;
			if (yyvsp[0].v.number > USHRT_MAX)
				conf->short_as = AS_TRANS;
			else
				conf->short_as = yyvsp[0].v.number;
		}
break;
case 22:
#line 395 "parse.y"
{
			conf->as = yyvsp[-1].v.number;
			conf->short_as = yyvsp[0].v.number;
		}
break;
case 23:
#line 399 "parse.y"
{
			if (yyvsp[0].v.addr.aid != AID_INET) {
				yyerror("router-id must be an IPv4 address");
				YYERROR;
			}
			conf->bgpid = yyvsp[0].v.addr.v4.s_addr;
		}
break;
case 24:
#line 406 "parse.y"
{
			if (yyvsp[0].v.number < MIN_HOLDTIME || yyvsp[0].v.number > USHRT_MAX) {
				yyerror("holdtime must be between %u and %u",
				    MIN_HOLDTIME, USHRT_MAX);
				YYERROR;
			}
			conf->holdtime = yyvsp[0].v.number;
		}
break;
case 25:
#line 414 "parse.y"
{
			if (yyvsp[0].v.number < MIN_HOLDTIME || yyvsp[0].v.number > USHRT_MAX) {
				yyerror("holdtime must be between %u and %u",
				    MIN_HOLDTIME, USHRT_MAX);
				YYERROR;
			}
			conf->min_holdtime = yyvsp[0].v.number;
		}
break;
case 26:
#line 422 "parse.y"
{
			struct listen_addr	*la;

			if ((la = calloc(1, sizeof(struct listen_addr))) ==
			    NULL)
				fatal("parse conf_main listen on calloc");

			la->fd = -1;
			memcpy(&la->sa, addr2sa(&yyvsp[0].v.addr, BGP_PORT), sizeof(la->sa));
			TAILQ_INSERT_TAIL(conf->listen_addrs, la, entry);
		}
break;
case 27:
#line 433 "parse.y"
{
			if (yyvsp[0].v.number <= RTP_NONE || yyvsp[0].v.number > RTP_MAX) {
				yyerror("invalid fib-priority");
				YYERROR;
			}
			conf->fib_priority = yyvsp[0].v.number;
		}
break;
case 28:
#line 440 "parse.y"
{
			struct rde_rib *rr;
			rr = find_rib("Loc-RIB");
			if (rr == NULL)
				fatalx("RTABLE can not find the main RIB!");

			if (yyvsp[0].v.number == 0)
				rr->flags |= F_RIB_NOFIBSYNC;
			else
				rr->flags &= ~F_RIB_NOFIBSYNC;
		}
break;
case 29:
#line 451 "parse.y"
{
			if (yyvsp[0].v.number == 1)
				conf->flags |= BGPD_FLAG_NO_EVALUATE;
			else
				conf->flags &= ~BGPD_FLAG_NO_EVALUATE;
		}
break;
case 30:
#line 457 "parse.y"
{
			if (add_rib(yyvsp[0].v.string, conf->default_tableid, F_RIB_NOFIB)) {
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 31:
#line 464 "parse.y"
{
			if (yyvsp[-1].v.number) {
				free(yyvsp[-2].v.string);
				yyerror("bad rde rib definition");
				YYERROR;
			}
			if (add_rib(yyvsp[-2].v.string, conf->default_tableid,
			    F_RIB_NOFIB | F_RIB_NOEVALUATE)) {
				free(yyvsp[-2].v.string);
				YYERROR;
			}
			free(yyvsp[-2].v.string);
		}
break;
case 32:
#line 477 "parse.y"
{
			if (add_rib(yyvsp[-2].v.string, yyvsp[0].v.number, 0)) {
				free(yyvsp[-2].v.string);
				YYERROR;
			}
			free(yyvsp[-2].v.string);
		}
break;
case 33:
#line 484 "parse.y"
{
			int	flags = 0;
			if (yyvsp[0].v.number == 0)
				flags = F_RIB_NOFIBSYNC;
			if (add_rib(yyvsp[-4].v.string, yyvsp[-2].v.number, flags)) {
				free(yyvsp[-4].v.string);
				YYERROR;
			}
			free(yyvsp[-4].v.string);
		}
break;
case 34:
#line 494 "parse.y"
{
			if (yyvsp[0].v.number == 1)
				conf->flags |= BGPD_FLAG_DECISION_TRANS_AS;
			else
				conf->flags &= ~BGPD_FLAG_DECISION_TRANS_AS;
		}
break;
case 35:
#line 500 "parse.y"
{
			if (!strcmp(yyvsp[0].v.string, "updates"))
				conf->log |= BGPD_LOG_UPDATES;
			else {
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 37:
#line 510 "parse.y"
{
			int action;

			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > INT_MAX) {
				yyerror("bad timeout");
				free(yyvsp[-2].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			if (!strcmp(yyvsp[-2].v.string, "table"))
				action = MRT_TABLE_DUMP;
			else if (!strcmp(yyvsp[-2].v.string, "table-mp"))
				action = MRT_TABLE_DUMP_MP;
			else if (!strcmp(yyvsp[-2].v.string, "table-v2"))
				action = MRT_TABLE_DUMP_V2;
			else {
				yyerror("unknown mrt dump type");
				free(yyvsp[-2].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-2].v.string);
			if (add_mrtconfig(action, yyvsp[-1].v.string, yyvsp[0].v.number, NULL, NULL) == -1) {
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-1].v.string);
		}
break;
case 38:
#line 538 "parse.y"
{
			int action;

			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > INT_MAX) {
				yyerror("bad timeout");
				free(yyvsp[-3].v.string);
				free(yyvsp[-2].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			if (!strcmp(yyvsp[-2].v.string, "table"))
				action = MRT_TABLE_DUMP;
			else if (!strcmp(yyvsp[-2].v.string, "table-mp"))
				action = MRT_TABLE_DUMP_MP;
			else if (!strcmp(yyvsp[-2].v.string, "table-v2"))
				action = MRT_TABLE_DUMP_V2;
			else {
				yyerror("unknown mrt dump type");
				free(yyvsp[-3].v.string);
				free(yyvsp[-2].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-2].v.string);
			if (add_mrtconfig(action, yyvsp[-1].v.string, yyvsp[0].v.number, NULL, yyvsp[-3].v.string) == -1) {
				free(yyvsp[-3].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-3].v.string);
			free(yyvsp[-1].v.string);
		}
break;
case 40:
#line 571 "parse.y"
{
			if (!strcmp(yyvsp[-1].v.string, "route-age"))
				conf->flags |= BGPD_FLAG_DECISION_ROUTEAGE;
			else {
				yyerror("unknown route decision type");
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-1].v.string);
		}
break;
case 41:
#line 581 "parse.y"
{
			if (!strcmp(yyvsp[-1].v.string, "route-age"))
				conf->flags &= ~BGPD_FLAG_DECISION_ROUTEAGE;
			else {
				yyerror("unknown route decision type");
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-1].v.string);
		}
break;
case 42:
#line 591 "parse.y"
{
			if (!strcmp(yyvsp[0].v.string, "always"))
				conf->flags |= BGPD_FLAG_DECISION_MED_ALWAYS;
			else if (!strcmp(yyvsp[0].v.string, "strict"))
				conf->flags &= ~BGPD_FLAG_DECISION_MED_ALWAYS;
			else {
				yyerror("rde med compare: "
				    "unknown setting \"%s\"", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 43:
#line 604 "parse.y"
{
			if (!strcmp(yyvsp[0].v.string, "bgp"))
				conf->flags |= BGPD_FLAG_NEXTHOP_BGP;
			else if (!strcmp(yyvsp[0].v.string, "default"))
				conf->flags |= BGPD_FLAG_NEXTHOP_DEFAULT;
			else {
				yyerror("nexthop depend on: "
				    "unknown setting \"%s\"", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 44:
#line 617 "parse.y"
{
			struct rde_rib *rr;
			if (ktable_exists(yyvsp[0].v.number, NULL) != 1) {
				yyerror("rtable id %lld does not exist", yyvsp[0].v.number);
				YYERROR;
			}
			rr = find_rib("Loc-RIB");
			if (rr == NULL)
				fatalx("RTABLE can not find the main RIB!");
			rr->rtableid = yyvsp[0].v.number;
		}
break;
case 45:
#line 628 "parse.y"
{
			if (yyvsp[0].v.number > USHRT_MAX || yyvsp[0].v.number < 1) {
				yyerror("invalid connect-retry");
				YYERROR;
			}
			conf->connectretry = yyvsp[0].v.number;
		}
break;
case 46:
#line 635 "parse.y"
{
			if (strlen(yyvsp[-1].v.string) >=
			    sizeof(((struct sockaddr_un *)0)->sun_path)) {
				yyerror("socket path too long");
				YYERROR;
			}
			if (yyvsp[0].v.number) {
				free(conf->rcsock);
				conf->rcsock = yyvsp[-1].v.string;
			} else {
				free(conf->csock);
				conf->csock = yyvsp[-1].v.string;
			}
		}
break;
case 47:
#line 651 "parse.y"
{
			int action;

			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > INT_MAX) {
				yyerror("bad timeout");
				free(yyvsp[-3].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			if (!strcmp(yyvsp[-3].v.string, "all"))
				action = yyvsp[-2].v.number ? MRT_ALL_IN : MRT_ALL_OUT;
			else if (!strcmp(yyvsp[-3].v.string, "updates"))
				action = yyvsp[-2].v.number ? MRT_UPDATE_IN : MRT_UPDATE_OUT;
			else {
				yyerror("unknown mrt msg dump type");
				free(yyvsp[-3].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			if (add_mrtconfig(action, yyvsp[-1].v.string, yyvsp[0].v.number, curpeer, NULL) ==
			    -1) {
				free(yyvsp[-3].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-3].v.string);
			free(yyvsp[-1].v.string);
		}
break;
case 48:
#line 681 "parse.y"
{
			struct network	*n, *m;

			if ((n = calloc(1, sizeof(struct network))) == NULL)
				fatal("new_network");
			memcpy(&n->net.prefix, &yyvsp[-1].v.prefix.prefix,
			    sizeof(n->net.prefix));
			n->net.prefixlen = yyvsp[-1].v.prefix.len;
			filterset_move(yyvsp[0].v.filter_set_head, &n->net.attrset);
			free(yyvsp[0].v.filter_set_head);
			TAILQ_FOREACH(m, netconf, entry) {
				if (n->net.prefixlen == m->net.prefixlen &&
				    prefix_compare(&n->net.prefix,
				    &m->net.prefix, n->net.prefixlen) == 0)
					yyerror("duplicate prefix "
					    "in network statement");
			}

			TAILQ_INSERT_TAIL(netconf, n, entry);
		}
break;
case 49:
#line 701 "parse.y"
{
			struct network	*n;

			if ((n = calloc(1, sizeof(struct network))) == NULL)
				fatal("new_network");
			if (afi2aid(yyvsp[-3].v.number, SAFI_UNICAST, &n->net.prefix.aid) ==
			    -1) {
				yyerror("unknown family");
				filterset_free(yyvsp[0].v.filter_set_head);
				free(yyvsp[0].v.filter_set_head);
				YYERROR;
			}
			n->net.type = NETWORK_RTLABEL;
			n->net.rtlabel = rtlabel_name2id(yyvsp[-1].v.string);
			filterset_move(yyvsp[0].v.filter_set_head, &n->net.attrset);
			free(yyvsp[0].v.filter_set_head);

			TAILQ_INSERT_TAIL(netconf, n, entry);
		}
break;
case 50:
#line 720 "parse.y"
{
			struct network	*n;

			if ((n = calloc(1, sizeof(struct network))) == NULL)
				fatal("new_network");
			if (afi2aid(yyvsp[-2].v.number, SAFI_UNICAST, &n->net.prefix.aid) ==
			    -1) {
				yyerror("unknown family");
				filterset_free(yyvsp[0].v.filter_set_head);
				free(yyvsp[0].v.filter_set_head);
				YYERROR;
			}
			n->net.type = yyvsp[-1].v.number ? NETWORK_STATIC : NETWORK_CONNECTED;
			filterset_move(yyvsp[0].v.filter_set_head, &n->net.attrset);
			free(yyvsp[0].v.filter_set_head);

			TAILQ_INSERT_TAIL(netconf, n, entry);
		}
break;
case 51:
#line 740 "parse.y"
{ yyval.v.number = 1; }
break;
case 52:
#line 741 "parse.y"
{ yyval.v.number = 0; }
break;
case 53:
#line 744 "parse.y"
{ yyval.v.number = 1; }
break;
case 54:
#line 745 "parse.y"
{ yyval.v.number = 0; }
break;
case 55:
#line 748 "parse.y"
{
			u_int8_t	len;

			if (!host(yyvsp[0].v.string, &yyval.v.addr, &len)) {
				yyerror("could not parse address spec \"%s\"",
				    yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);

			if ((yyval.v.addr.aid == AID_INET && len != 32) ||
			    (yyval.v.addr.aid == AID_INET6 && len != 128)) {
				/* unreachable */
				yyerror("got prefixlen %u, expected %u",
				    len, yyval.v.addr.aid == AID_INET ? 32 : 128);
				YYERROR;
			}
		}
break;
case 56:
#line 769 "parse.y"
{
			char	*s;

			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > 128) {
				yyerror("bad prefixlen %lld", yyvsp[0].v.number);
				free(yyvsp[-2].v.string);
				YYERROR;
			}
			if (asprintf(&s, "%s/%lld", yyvsp[-2].v.string, yyvsp[0].v.number) == -1)
				fatal(NULL);
			free(yyvsp[-2].v.string);

			if (!host(s, &yyval.v.prefix.prefix, &yyval.v.prefix.len)) {
				yyerror("could not parse address \"%s\"", s);
				free(s);
				YYERROR;
			}
			free(s);
		}
break;
case 57:
#line 788 "parse.y"
{
			char	*s;

			/* does not match IPv6 */
			if (yyvsp[-2].v.number < 0 || yyvsp[-2].v.number > 255 || yyvsp[0].v.number < 0 || yyvsp[0].v.number > 32) {
				yyerror("bad prefix %lld/%lld", yyvsp[-2].v.number, yyvsp[0].v.number);
				YYERROR;
			}
			if (asprintf(&s, "%lld/%lld", yyvsp[-2].v.number, yyvsp[0].v.number) == -1)
				fatal(NULL);

			if (!host(s, &yyval.v.prefix.prefix, &yyval.v.prefix.len)) {
				yyerror("could not parse address \"%s\"", s);
				free(s);
				YYERROR;
			}
			free(s);
		}
break;
case 58:
#line 808 "parse.y"
{
			memcpy(&yyval.v.prefix.prefix, &yyvsp[0].v.addr, sizeof(struct bgpd_addr));
			if (yyval.v.prefix.prefix.aid == AID_INET)
				yyval.v.prefix.len = 32;
			else
				yyval.v.prefix.len = 128;
		}
break;
case 63:
#line 825 "parse.y"
{ yyval.v.number = 0; }
break;
case 65:
#line 829 "parse.y"
{
			if (ktable_exists(yyvsp[-3].v.number, NULL) != 1) {
				yyerror("rdomain %lld does not exist", yyvsp[-3].v.number);
				YYERROR;
			}
			if (!(currdom = calloc(1, sizeof(struct rdomain))))
				fatal(NULL);
			currdom->rtableid = yyvsp[-3].v.number;
			TAILQ_INIT(&currdom->import);
			TAILQ_INIT(&currdom->export);
			TAILQ_INIT(&currdom->net_l);
			netconf = &currdom->net_l;
		}
break;
case 66:
#line 842 "parse.y"
{
			/* insert into list */
			SIMPLEQ_INSERT_TAIL(&conf->rdomains, currdom, entry);
			currdom = NULL;
			netconf = &conf->networks;
		}
break;
case 70:
#line 856 "parse.y"
{
			struct filter_extcommunity	ext;
			u_int64_t			rd;

			if (parseextcommunity(&ext, "rt", yyvsp[0].v.string) == -1) {
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			/*
			 * RD is almost encode like an ext-community,
			 * but only almost so convert here.
			 */
			if (community_ext_conv(&ext, 0, &rd)) {
				yyerror("bad encoding of rd");
				YYERROR;
			}
			rd = betoh64(rd) & 0xffffffffffffULL;
			switch (ext.type) {
			case EXT_COMMUNITY_TRANS_TWO_AS:
				rd |= (0ULL << 48);
				break;
			case EXT_COMMUNITY_TRANS_IPV4:
				rd |= (1ULL << 48);
				break;
			case EXT_COMMUNITY_TRANS_FOUR_AS:
				rd |= (2ULL << 48);
				break;
			default:
				yyerror("bad encoding of rd");
				YYERROR;
			}
			currdom->rd = htobe64(rd);
		}
break;
case 71:
#line 890 "parse.y"
{
			struct filter_set	*set;

			if ((set = calloc(1, sizeof(struct filter_set))) ==
			    NULL)
				fatal(NULL);
			set->type = ACTION_SET_EXT_COMMUNITY;
			if (parseextcommunity(&set->action.ext_community,
			    yyvsp[-1].v.string, yyvsp[0].v.string) == -1) {
				free(yyvsp[0].v.string);
				free(yyvsp[-1].v.string);
				free(set);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			free(yyvsp[-1].v.string);
			TAILQ_INSERT_TAIL(&currdom->export, set, entry);
		}
break;
case 72:
#line 908 "parse.y"
{
			struct filter_set	*set;

			if ((set = calloc(1, sizeof(struct filter_set))) ==
			    NULL)
				fatal(NULL);
			set->type = ACTION_SET_EXT_COMMUNITY;
			if (parseextcommunity(&set->action.ext_community,
			    yyvsp[-1].v.string, yyvsp[0].v.string) == -1) {
				free(yyvsp[0].v.string);
				free(yyvsp[-1].v.string);
				free(set);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			free(yyvsp[-1].v.string);
			TAILQ_INSERT_TAIL(&currdom->import, set, entry);
		}
break;
case 73:
#line 926 "parse.y"
{
			if (strlcpy(currdom->descr, yyvsp[0].v.string,
			    sizeof(currdom->descr)) >=
			    sizeof(currdom->descr)) {
				yyerror("descr \"%s\" too long: max %zu",
				    yyvsp[0].v.string, sizeof(currdom->descr) - 1);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 74:
#line 937 "parse.y"
{
			if (yyvsp[0].v.number == 0)
				currdom->flags |= F_RIB_NOFIBSYNC;
			else
				currdom->flags &= ~F_RIB_NOFIBSYNC;
		}
break;
case 76:
#line 944 "parse.y"
{
			/* XXX this is a hack */
			if (if_nametoindex(yyvsp[0].v.string) == 0) {
				yyerror("interface %s does not exist", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			strlcpy(currdom->ifmpe, yyvsp[0].v.string, IFNAMSIZ);
			free(yyvsp[0].v.string);
			if (get_mpe_label(currdom)) {
				yyerror("failed to get mpls label from %s",
				    currdom->ifmpe);
				YYERROR;
			}
		}
break;
case 77:
#line 961 "parse.y"
{	curpeer = new_peer(); }
break;
case 78:
#line 962 "parse.y"
{
			memcpy(&curpeer->conf.remote_addr, &yyvsp[0].v.prefix.prefix,
			    sizeof(curpeer->conf.remote_addr));
			curpeer->conf.remote_masklen = yyvsp[0].v.prefix.len;
			if ((yyvsp[0].v.prefix.prefix.aid == AID_INET && yyvsp[0].v.prefix.len != 32) ||
			    (yyvsp[0].v.prefix.prefix.aid == AID_INET6 && yyvsp[0].v.prefix.len != 128))
				curpeer->conf.template = 1;
			if (curpeer->conf.capabilities.mp[
			    curpeer->conf.remote_addr.aid] == -1)
				curpeer->conf.capabilities.mp[
				    curpeer->conf.remote_addr.aid] = 1;
			if (get_id(curpeer)) {
				yyerror("get_id failed");
				YYERROR;
			}
		}
break;
case 79:
#line 978 "parse.y"
{
			if (curpeer_filter[0] != NULL)
				TAILQ_INSERT_TAIL(peerfilter_l,
				    curpeer_filter[0], entry);
			if (curpeer_filter[1] != NULL)
				TAILQ_INSERT_TAIL(peerfilter_l,
				    curpeer_filter[1], entry);
			curpeer_filter[0] = NULL;
			curpeer_filter[1] = NULL;

			if (neighbor_consistent(curpeer) == -1)
				YYERROR;
			curpeer->next = peer_l;
			peer_l = curpeer;
			curpeer = curgroup;
		}
break;
case 80:
#line 996 "parse.y"
{
			curgroup = curpeer = new_group();
			if (strlcpy(curgroup->conf.group, yyvsp[-3].v.string,
			    sizeof(curgroup->conf.group)) >=
			    sizeof(curgroup->conf.group)) {
				yyerror("group name \"%s\" too long: max %zu",
				    yyvsp[-3].v.string, sizeof(curgroup->conf.group) - 1);
				free(yyvsp[-3].v.string);
				YYERROR;
			}
			free(yyvsp[-3].v.string);
			if (get_id(curgroup)) {
				yyerror("get_id failed");
				YYERROR;
			}
		}
break;
case 81:
#line 1012 "parse.y"
{
			if (curgroup_filter[0] != NULL)
				TAILQ_INSERT_TAIL(groupfilter_l,
				    curgroup_filter[0], entry);
			if (curgroup_filter[1] != NULL)
				TAILQ_INSERT_TAIL(groupfilter_l,
				    curgroup_filter[1], entry);
			curgroup_filter[0] = NULL;
			curgroup_filter[1] = NULL;

			free(curgroup);
			curgroup = NULL;
		}
break;
case 92:
#line 1047 "parse.y"
{
			curpeer->conf.remote_as = yyvsp[0].v.number;
		}
break;
case 93:
#line 1050 "parse.y"
{
			curpeer->conf.local_as = yyvsp[0].v.number;
			if (yyvsp[0].v.number > USHRT_MAX)
				curpeer->conf.local_short_as = AS_TRANS;
			else
				curpeer->conf.local_short_as = yyvsp[0].v.number;
		}
break;
case 94:
#line 1057 "parse.y"
{
			curpeer->conf.local_as = yyvsp[-1].v.number;
			curpeer->conf.local_short_as = yyvsp[0].v.number;
		}
break;
case 95:
#line 1061 "parse.y"
{
			if (strlcpy(curpeer->conf.descr, yyvsp[0].v.string,
			    sizeof(curpeer->conf.descr)) >=
			    sizeof(curpeer->conf.descr)) {
				yyerror("descr \"%s\" too long: max %zu",
				    yyvsp[0].v.string, sizeof(curpeer->conf.descr) - 1);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 96:
#line 1072 "parse.y"
{
			memcpy(&curpeer->conf.local_addr, &yyvsp[0].v.addr,
			    sizeof(curpeer->conf.local_addr));
		}
break;
case 97:
#line 1076 "parse.y"
{
			if (yyvsp[0].v.number < 2 || yyvsp[0].v.number > 255) {
				yyerror("invalid multihop distance %lld", yyvsp[0].v.number);
				YYERROR;
			}
			curpeer->conf.distance = yyvsp[0].v.number;
		}
break;
case 98:
#line 1083 "parse.y"
{
			curpeer->conf.passive = 1;
		}
break;
case 99:
#line 1086 "parse.y"
{
			curpeer->conf.down = 1;
		}
break;
case 100:
#line 1089 "parse.y"
{
			curpeer->conf.down = 1;
			if (strlcpy(curpeer->conf.shutcomm, yyvsp[0].v.string,
				sizeof(curpeer->conf.shutcomm)) >=
				sizeof(curpeer->conf.shutcomm)) {
				    yyerror("shutdown reason too long");
				    free(yyvsp[0].v.string);
				    YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 101:
#line 1100 "parse.y"
{
			if (!find_rib(yyvsp[0].v.string)) {
				yyerror("rib \"%s\" does not exist.", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			if (strlcpy(curpeer->conf.rib, yyvsp[0].v.string,
			    sizeof(curpeer->conf.rib)) >=
			    sizeof(curpeer->conf.rib)) {
				yyerror("rib name \"%s\" too long: max %zu",
				   yyvsp[0].v.string, sizeof(curpeer->conf.rib) - 1);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 102:
#line 1116 "parse.y"
{
			if (yyvsp[0].v.number < MIN_HOLDTIME || yyvsp[0].v.number > USHRT_MAX) {
				yyerror("holdtime must be between %u and %u",
				    MIN_HOLDTIME, USHRT_MAX);
				YYERROR;
			}
			curpeer->conf.holdtime = yyvsp[0].v.number;
		}
break;
case 103:
#line 1124 "parse.y"
{
			if (yyvsp[0].v.number < MIN_HOLDTIME || yyvsp[0].v.number > USHRT_MAX) {
				yyerror("holdtime must be between %u and %u",
				    MIN_HOLDTIME, USHRT_MAX);
				YYERROR;
			}
			curpeer->conf.min_holdtime = yyvsp[0].v.number;
		}
break;
case 104:
#line 1132 "parse.y"
{
			u_int8_t	aid, safi;
			int8_t		val = 1;

			if (!strcmp(yyvsp[0].v.string, "none")) {
				safi = SAFI_UNICAST;
				val = 0;
			} else if (!strcmp(yyvsp[0].v.string, "unicast")) {
				safi = SAFI_UNICAST;
			} else if (!strcmp(yyvsp[0].v.string, "vpn")) {
				safi = SAFI_MPLSVPN;
			} else {
				yyerror("unknown/unsupported SAFI \"%s\"",
				    yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);

			if (afi2aid(yyvsp[-1].v.number, safi, &aid) == -1) {
				yyerror("unknown AFI/SAFI pair");
				YYERROR;
			}
			curpeer->conf.capabilities.mp[aid] = val;
		}
break;
case 105:
#line 1157 "parse.y"
{
			curpeer->conf.announce_capa = yyvsp[0].v.number;
		}
break;
case 106:
#line 1160 "parse.y"
{
			curpeer->conf.capabilities.refresh = yyvsp[0].v.number;
		}
break;
case 107:
#line 1163 "parse.y"
{
			curpeer->conf.capabilities.grestart.restart = yyvsp[0].v.number;
		}
break;
case 108:
#line 1166 "parse.y"
{
			curpeer->conf.capabilities.as4byte = yyvsp[0].v.number;
		}
break;
case 109:
#line 1169 "parse.y"
{
			curpeer->conf.announce_type = ANNOUNCE_SELF;
		}
break;
case 110:
#line 1172 "parse.y"
{
			if (!strcmp(yyvsp[0].v.string, "self"))
				curpeer->conf.announce_type = ANNOUNCE_SELF;
			else if (!strcmp(yyvsp[0].v.string, "none"))
				curpeer->conf.announce_type = ANNOUNCE_NONE;
			else if (!strcmp(yyvsp[0].v.string, "all"))
				curpeer->conf.announce_type = ANNOUNCE_ALL;
			else if (!strcmp(yyvsp[0].v.string, "default-route"))
				curpeer->conf.announce_type =
				    ANNOUNCE_DEFAULT_ROUTE;
			else {
				yyerror("invalid announce type");
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 111:
#line 1189 "parse.y"
{
			if (yyvsp[0].v.number)
				curpeer->conf.enforce_as = ENFORCE_AS_ON;
			else
				curpeer->conf.enforce_as = ENFORCE_AS_OFF;
		}
break;
case 112:
#line 1195 "parse.y"
{
			if (yyvsp[0].v.number)
				curpeer->conf.enforce_local_as = ENFORCE_AS_ON;
			else
				curpeer->conf.enforce_local_as = ENFORCE_AS_OFF;
		}
break;
case 113:
#line 1201 "parse.y"
{
			if (yyvsp[-1].v.number < 0 || yyvsp[-1].v.number > UINT_MAX) {
				yyerror("bad maximum number of prefixes");
				YYERROR;
			}
			curpeer->conf.max_prefix = yyvsp[-1].v.number;
			curpeer->conf.max_prefix_restart = yyvsp[0].v.number;
		}
break;
case 114:
#line 1209 "parse.y"
{
			if (curpeer->conf.auth.method) {
				yyerror("auth method cannot be redefined");
				free(yyvsp[0].v.string);
				YYERROR;
			}
			if (strlcpy(curpeer->conf.auth.md5key, yyvsp[0].v.string,
			    sizeof(curpeer->conf.auth.md5key)) >=
			    sizeof(curpeer->conf.auth.md5key)) {
				yyerror("tcp md5sig password too long: max %zu",
				    sizeof(curpeer->conf.auth.md5key) - 1);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			curpeer->conf.auth.method = AUTH_MD5SIG;
			curpeer->conf.auth.md5key_len = strlen(yyvsp[0].v.string);
			free(yyvsp[0].v.string);
		}
break;
case 115:
#line 1227 "parse.y"
{
			if (curpeer->conf.auth.method) {
				yyerror("auth method cannot be redefined");
				free(yyvsp[0].v.string);
				YYERROR;
			}

			if (str2key(yyvsp[0].v.string, curpeer->conf.auth.md5key,
			    sizeof(curpeer->conf.auth.md5key)) == -1) {
				free(yyvsp[0].v.string);
				YYERROR;
			}
			curpeer->conf.auth.method = AUTH_MD5SIG;
			curpeer->conf.auth.md5key_len = strlen(yyvsp[0].v.string) / 2;
			free(yyvsp[0].v.string);
		}
break;
case 116:
#line 1243 "parse.y"
{
			if (curpeer->conf.auth.method) {
				yyerror("auth method cannot be redefined");
				YYERROR;
			}
			if (yyvsp[-1].v.number)
				curpeer->conf.auth.method = AUTH_IPSEC_IKE_ESP;
			else
				curpeer->conf.auth.method = AUTH_IPSEC_IKE_AH;
		}
break;
case 117:
#line 1253 "parse.y"
{
			u_int32_t	auth_alg;
			u_int8_t	keylen;

			if (curpeer->conf.auth.method &&
			    (((curpeer->conf.auth.spi_in && yyvsp[-5].v.number == 1) ||
			    (curpeer->conf.auth.spi_out && yyvsp[-5].v.number == 0)) ||
			    (yyvsp[-6].v.number == 1 && curpeer->conf.auth.method !=
			    AUTH_IPSEC_MANUAL_ESP) ||
			    (yyvsp[-6].v.number == 0 && curpeer->conf.auth.method !=
			    AUTH_IPSEC_MANUAL_AH))) {
				yyerror("auth method cannot be redefined");
				free(yyvsp[-2].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}

			if (!strcmp(yyvsp[-2].v.string, "sha1")) {
				auth_alg = SADB_AALG_SHA1HMAC;
				keylen = 20;
			} else if (!strcmp(yyvsp[-2].v.string, "md5")) {
				auth_alg = SADB_AALG_MD5HMAC;
				keylen = 16;
			} else {
				yyerror("unknown auth algorithm \"%s\"", yyvsp[-2].v.string);
				free(yyvsp[-2].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-2].v.string);

			if (strlen(yyvsp[-1].v.string) / 2 != keylen) {
				yyerror("auth key len: must be %u bytes, "
				    "is %zu bytes", keylen, strlen(yyvsp[-1].v.string) / 2);
				free(yyvsp[-1].v.string);
				YYERROR;
			}

			if (yyvsp[-6].v.number)
				curpeer->conf.auth.method =
				    AUTH_IPSEC_MANUAL_ESP;
			else {
				if (yyvsp[0].v.encspec.enc_alg) {
					yyerror("\"ipsec ah\" doesn't take "
					    "encryption keys");
					free(yyvsp[-1].v.string);
					YYERROR;
				}
				curpeer->conf.auth.method =
				    AUTH_IPSEC_MANUAL_AH;
			}

			if (yyvsp[-3].v.number <= SPI_RESERVED_MAX || yyvsp[-3].v.number > UINT_MAX) {
				yyerror("bad spi number %lld", yyvsp[-3].v.number);
				free(yyvsp[-1].v.string);
				YYERROR;
			}

			if (yyvsp[-5].v.number == 1) {
				if (str2key(yyvsp[-1].v.string, curpeer->conf.auth.auth_key_in,
				    sizeof(curpeer->conf.auth.auth_key_in)) ==
				    -1) {
					free(yyvsp[-1].v.string);
					YYERROR;
				}
				curpeer->conf.auth.spi_in = yyvsp[-3].v.number;
				curpeer->conf.auth.auth_alg_in = auth_alg;
				curpeer->conf.auth.enc_alg_in = yyvsp[0].v.encspec.enc_alg;
				memcpy(&curpeer->conf.auth.enc_key_in,
				    &yyvsp[0].v.encspec.enc_key,
				    sizeof(curpeer->conf.auth.enc_key_in));
				curpeer->conf.auth.enc_keylen_in =
				    yyvsp[0].v.encspec.enc_key_len;
				curpeer->conf.auth.auth_keylen_in = keylen;
			} else {
				if (str2key(yyvsp[-1].v.string, curpeer->conf.auth.auth_key_out,
				    sizeof(curpeer->conf.auth.auth_key_out)) ==
				    -1) {
					free(yyvsp[-1].v.string);
					YYERROR;
				}
				curpeer->conf.auth.spi_out = yyvsp[-3].v.number;
				curpeer->conf.auth.auth_alg_out = auth_alg;
				curpeer->conf.auth.enc_alg_out = yyvsp[0].v.encspec.enc_alg;
				memcpy(&curpeer->conf.auth.enc_key_out,
				    &yyvsp[0].v.encspec.enc_key,
				    sizeof(curpeer->conf.auth.enc_key_out));
				curpeer->conf.auth.enc_keylen_out =
				    yyvsp[0].v.encspec.enc_key_len;
				curpeer->conf.auth.auth_keylen_out = keylen;
			}
			free(yyvsp[-1].v.string);
		}
break;
case 118:
#line 1346 "parse.y"
{
			curpeer->conf.ttlsec = yyvsp[0].v.number;
		}
break;
case 119:
#line 1349 "parse.y"
{
			struct filter_rule	*r;

			r = get_rule(yyvsp[0].v.filter_set->type);
			if (merge_filterset(&r->set, yyvsp[0].v.filter_set) == -1)
				YYERROR;
		}
break;
case 120:
#line 1356 "parse.y"
{
			struct filter_rule	*r;
			struct filter_set	*s;

			while ((s = TAILQ_FIRST(yyvsp[-2].v.filter_set_head)) != NULL) {
				TAILQ_REMOVE(yyvsp[-2].v.filter_set_head, s, entry);
				r = get_rule(s->type);
				if (merge_filterset(&r->set, s) == -1)
					YYERROR;
			}
			free(yyvsp[-2].v.filter_set_head);
		}
break;
case 122:
#line 1369 "parse.y"
{
			if ((conf->flags & BGPD_FLAG_REFLECTOR) &&
			    conf->clusterid != 0) {
				yyerror("only one route reflector "
				    "cluster allowed");
				YYERROR;
			}
			conf->flags |= BGPD_FLAG_REFLECTOR;
			curpeer->conf.reflector_client = 1;
		}
break;
case 123:
#line 1379 "parse.y"
{
			if (yyvsp[0].v.addr.aid != AID_INET) {
				yyerror("route reflector cluster-id must be "
				    "an IPv4 address");
				YYERROR;
			}
			if ((conf->flags & BGPD_FLAG_REFLECTOR) &&
			    conf->clusterid != yyvsp[0].v.addr.v4.s_addr) {
				yyerror("only one route reflector "
				    "cluster allowed");
				YYERROR;
			}
			conf->flags |= BGPD_FLAG_REFLECTOR;
			curpeer->conf.reflector_client = 1;
			conf->clusterid = yyvsp[0].v.addr.v4.s_addr;
		}
break;
case 124:
#line 1395 "parse.y"
{
			if (strlcpy(curpeer->conf.if_depend, yyvsp[0].v.string,
			    sizeof(curpeer->conf.if_depend)) >=
			    sizeof(curpeer->conf.if_depend)) {
				yyerror("interface name \"%s\" too long: "
				    "max %zu", yyvsp[0].v.string,
				    sizeof(curpeer->conf.if_depend) - 1);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 125:
#line 1407 "parse.y"
{
			if (strlcpy(curpeer->conf.demote_group, yyvsp[0].v.string,
			    sizeof(curpeer->conf.demote_group)) >=
			    sizeof(curpeer->conf.demote_group)) {
				yyerror("demote group name \"%s\" too long: "
				    "max %zu", yyvsp[0].v.string,
				    sizeof(curpeer->conf.demote_group) - 1);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			if (carp_demote_init(curpeer->conf.demote_group,
			    cmd_opts & BGPD_OPT_FORCE_DEMOTE) == -1) {
				yyerror("error initializing group \"%s\"",
				    curpeer->conf.demote_group);
				YYERROR;
			}
		}
break;
case 126:
#line 1425 "parse.y"
{
			if (yyvsp[0].v.number == 1)
				curpeer->conf.flags |= PEERFLAG_TRANS_AS;
			else
				curpeer->conf.flags &= ~PEERFLAG_TRANS_AS;
		}
break;
case 127:
#line 1431 "parse.y"
{
			if (!strcmp(yyvsp[0].v.string, "updates"))
				curpeer->conf.flags |= PEERFLAG_LOG_UPDATES;
			else if (!strcmp(yyvsp[0].v.string, "no"))
				curpeer->conf.flags &= ~PEERFLAG_LOG_UPDATES;
			else {
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 128:
#line 1444 "parse.y"
{ yyval.v.number = 0; }
break;
case 129:
#line 1445 "parse.y"
{
			if (yyvsp[0].v.number < 1 || yyvsp[0].v.number > USHRT_MAX) {
				yyerror("restart out of range. 1 to %u minutes",
				    USHRT_MAX);
				YYERROR;
			}
			yyval.v.number = yyvsp[0].v.number;
		}
break;
case 130:
#line 1455 "parse.y"
{ yyval.v.number = AFI_IPv4; }
break;
case 131:
#line 1456 "parse.y"
{ yyval.v.number = AFI_IPv6; }
break;
case 132:
#line 1459 "parse.y"
{ yyval.v.number = 1; }
break;
case 133:
#line 1460 "parse.y"
{ yyval.v.number = 0; }
break;
case 134:
#line 1463 "parse.y"
{ yyval.v.number = 1; }
break;
case 135:
#line 1464 "parse.y"
{ yyval.v.number = 0; }
break;
case 136:
#line 1467 "parse.y"
{
			bzero(&yyval.v.encspec, sizeof(yyval.v.encspec));
		}
break;
case 137:
#line 1470 "parse.y"
{
			bzero(&yyval.v.encspec, sizeof(yyval.v.encspec));
			if (!strcmp(yyvsp[-1].v.string, "3des") || !strcmp(yyvsp[-1].v.string, "3des-cbc")) {
				yyval.v.encspec.enc_alg = SADB_EALG_3DESCBC;
				yyval.v.encspec.enc_key_len = 21; /* XXX verify */
			} else if (!strcmp(yyvsp[-1].v.string, "aes") ||
			    !strcmp(yyvsp[-1].v.string, "aes-128-cbc")) {
				yyval.v.encspec.enc_alg = SADB_X_EALG_AES;
				yyval.v.encspec.enc_key_len = 16;
			} else {
				yyerror("unknown enc algorithm \"%s\"", yyvsp[-1].v.string);
				free(yyvsp[-1].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[-1].v.string);

			if (strlen(yyvsp[0].v.string) / 2 != yyval.v.encspec.enc_key_len) {
				yyerror("enc key length wrong: should be %u "
				    "bytes, is %zu bytes",
				    yyval.v.encspec.enc_key_len * 2, strlen(yyvsp[0].v.string));
				free(yyvsp[0].v.string);
				YYERROR;
			}

			if (str2key(yyvsp[0].v.string, yyval.v.encspec.enc_key, sizeof(yyval.v.encspec.enc_key)) == -1) {
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 138:
#line 1504 "parse.y"
{
			struct filter_rule	 r;
			struct filter_rib_l	 *rb, *rbnext;

			bzero(&r, sizeof(r));
			r.action = yyvsp[-6].v.u8;
			r.quick = yyvsp[-5].v.u8;
			r.dir = yyvsp[-3].v.u8;
			if (yyvsp[-4].v.filter_rib) {
				if (r.dir != DIR_IN) {
					yyerror("rib only allowed on \"from\" "
					    "rules.");

					for (rb = yyvsp[-4].v.filter_rib; rb != NULL; rb = rbnext) {
						rbnext = rb->next;
						free(rb);
					}
					YYERROR;
				}
			}
			if (expand_rule(&r, yyvsp[-4].v.filter_rib, yyvsp[-2].v.filter_peers, &yyvsp[-1].v.filter_match, yyvsp[0].v.filter_set_head) == -1)
				YYERROR;
		}
break;
case 139:
#line 1529 "parse.y"
{ yyval.v.u8 = ACTION_ALLOW; }
break;
case 140:
#line 1530 "parse.y"
{ yyval.v.u8 = ACTION_DENY; }
break;
case 141:
#line 1531 "parse.y"
{ yyval.v.u8 = ACTION_NONE; }
break;
case 142:
#line 1534 "parse.y"
{ yyval.v.u8 = 0; }
break;
case 143:
#line 1535 "parse.y"
{ yyval.v.u8 = 1; }
break;
case 144:
#line 1538 "parse.y"
{ yyval.v.u8 = DIR_IN; }
break;
case 145:
#line 1539 "parse.y"
{ yyval.v.u8 = DIR_OUT; }
break;
case 146:
#line 1542 "parse.y"
{ yyval.v.filter_rib = NULL; }
break;
case 147:
#line 1543 "parse.y"
{ yyval.v.filter_rib = yyvsp[0].v.filter_rib; }
break;
case 148:
#line 1544 "parse.y"
{ yyval.v.filter_rib = yyvsp[-1].v.filter_rib; }
break;
case 149:
#line 1546 "parse.y"
{ yyval.v.filter_rib = yyvsp[0].v.filter_rib; }
break;
case 150:
#line 1547 "parse.y"
{
			yyvsp[0].v.filter_rib->next = yyvsp[-2].v.filter_rib;
			yyval.v.filter_rib = yyvsp[0].v.filter_rib;
		}
break;
case 151:
#line 1553 "parse.y"
{
			if (!find_rib(yyvsp[0].v.string)) {
				yyerror("rib \"%s\" does not exist.", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			if ((yyval.v.filter_rib = calloc(1, sizeof(struct filter_rib_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_rib->next = NULL;
			if (strlcpy(yyval.v.filter_rib->name, yyvsp[0].v.string, sizeof(yyval.v.filter_rib->name)) >=
			    sizeof(yyval.v.filter_rib->name)) {
				yyerror("rib name \"%s\" too long: "
				    "max %zu", yyvsp[0].v.string, sizeof(yyval.v.filter_rib->name) - 1);
				free(yyvsp[0].v.string);
				free(yyval.v.filter_rib);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 153:
#line 1576 "parse.y"
{ yyval.v.filter_peers = yyvsp[-1].v.filter_peers; }
break;
case 154:
#line 1579 "parse.y"
{ yyval.v.filter_peers = yyvsp[0].v.filter_peers; }
break;
case 155:
#line 1580 "parse.y"
{
			yyvsp[0].v.filter_peers->next = yyvsp[-2].v.filter_peers;
			yyval.v.filter_peers = yyvsp[0].v.filter_peers;
		}
break;
case 156:
#line 1586 "parse.y"
{
			if ((yyval.v.filter_peers = calloc(1, sizeof(struct filter_peers_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_peers->p.peerid = yyval.v.filter_peers->p.groupid = 0;
			yyval.v.filter_peers->next = NULL;
		}
break;
case 157:
#line 1593 "parse.y"
{
			struct peer *p;

			if ((yyval.v.filter_peers = calloc(1, sizeof(struct filter_peers_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_peers->p.remote_as = yyval.v.filter_peers->p.groupid = yyval.v.filter_peers->p.peerid = 0;
			yyval.v.filter_peers->next = NULL;
			for (p = peer_l; p != NULL; p = p->next)
				if (!memcmp(&p->conf.remote_addr,
				    &yyvsp[0].v.addr, sizeof(p->conf.remote_addr))) {
					yyval.v.filter_peers->p.peerid = p->conf.id;
					break;
				}
			if (yyval.v.filter_peers->p.peerid == 0) {
				yyerror("no such peer: %s", log_addr(&yyvsp[0].v.addr));
				free(yyval.v.filter_peers);
				YYERROR;
			}
		}
break;
case 158:
#line 1613 "parse.y"
{
			if ((yyval.v.filter_peers = calloc(1, sizeof(struct filter_peers_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_peers->p.groupid = yyval.v.filter_peers->p.peerid = 0;
			yyval.v.filter_peers->p.remote_as = yyvsp[0].v.number;
		}
break;
case 159:
#line 1620 "parse.y"
{
			struct peer *p;

			if ((yyval.v.filter_peers = calloc(1, sizeof(struct filter_peers_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_peers->p.remote_as = yyval.v.filter_peers->p.peerid = 0;
			yyval.v.filter_peers->next = NULL;
			for (p = peer_l; p != NULL; p = p->next)
				if (!strcmp(p->conf.group, yyvsp[0].v.string)) {
					yyval.v.filter_peers->p.groupid = p->conf.groupid;
					break;
				}
			if (yyval.v.filter_peers->p.groupid == 0) {
				yyerror("no such group: \"%s\"", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				free(yyval.v.filter_peers);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 160:
#line 1641 "parse.y"
{
			if ((yyval.v.filter_peers = calloc(1, sizeof(struct filter_peers_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_peers->p.ebgp = 1;
		}
break;
case 161:
#line 1647 "parse.y"
{
			if ((yyval.v.filter_peers = calloc(1, sizeof(struct filter_peers_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_peers->p.ibgp = 1;
		}
break;
case 162:
#line 1655 "parse.y"
{
			if (yyvsp[0].v.prefixlen.op == OP_NONE)
				yyvsp[0].v.prefixlen.op = OP_GE;
			if ((yyval.v.filter_prefix = calloc(1, sizeof(struct filter_prefix_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_prefix->p.addr.aid = AID_INET;
			if (merge_prefixspec(yyval.v.filter_prefix, &yyvsp[0].v.prefixlen) == -1) {
				free(yyval.v.filter_prefix);
				YYERROR;
			}
		}
break;
case 163:
#line 1667 "parse.y"
{
			if (yyvsp[0].v.prefixlen.op == OP_NONE)
				yyvsp[0].v.prefixlen.op = OP_GE;
			if ((yyval.v.filter_prefix = calloc(1, sizeof(struct filter_prefix_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_prefix->p.addr.aid = AID_INET6;
			if (merge_prefixspec(yyval.v.filter_prefix, &yyvsp[0].v.prefixlen) == -1) {
				free(yyval.v.filter_prefix);
				YYERROR;
			}
		}
break;
case 164:
#line 1679 "parse.y"
{ yyval.v.filter_prefix = yyvsp[0].v.filter_prefix; }
break;
case 165:
#line 1680 "parse.y"
{ yyval.v.filter_prefix = yyvsp[-1].v.filter_prefix; }
break;
case 167:
#line 1684 "parse.y"
{ yyval.v.filter_prefix = yyvsp[-1].v.filter_prefix; }
break;
case 168:
#line 1686 "parse.y"
{
			struct filter_prefix_l  *p;

			/* merge, both can be lists */
			for (p = yyvsp[-2].v.filter_prefix; p != NULL && p->next != NULL; p = p->next)
				;       /* nothing */
			if (p != NULL)
				p->next = yyvsp[0].v.filter_prefix;
			yyval.v.filter_prefix = yyvsp[-2].v.filter_prefix;
		}
break;
case 169:
#line 1697 "parse.y"
{ yyval.v.filter_prefix = yyvsp[0].v.filter_prefix; }
break;
case 170:
#line 1698 "parse.y"
{
			yyvsp[0].v.filter_prefix->next = yyvsp[-2].v.filter_prefix;
			yyval.v.filter_prefix = yyvsp[0].v.filter_prefix;
		}
break;
case 171:
#line 1704 "parse.y"
{
			if ((yyval.v.filter_prefix = calloc(1, sizeof(struct filter_prefix_l))) ==
			    NULL)
				fatal(NULL);
			memcpy(&yyval.v.filter_prefix->p.addr, &yyvsp[-1].v.prefix.prefix,
			    sizeof(yyval.v.filter_prefix->p.addr));
			yyval.v.filter_prefix->p.len = yyvsp[-1].v.prefix.len;

			if (merge_prefixspec(yyval.v.filter_prefix, &yyvsp[0].v.prefixlen) == -1) {
				free(yyval.v.filter_prefix);
				YYERROR;
			}
		}
break;
case 173:
#line 1720 "parse.y"
{ yyval.v.filter_as = yyvsp[-1].v.filter_as; }
break;
case 175:
#line 1724 "parse.y"
{
			struct filter_as_l	*a;

			/* merge, both can be lists */
			for (a = yyvsp[-2].v.filter_as; a != NULL && a->next != NULL; a = a->next)
				;	/* nothing */
			if (a != NULL)
				a->next = yyvsp[0].v.filter_as;
			yyval.v.filter_as = yyvsp[-2].v.filter_as;
		}
break;
case 176:
#line 1736 "parse.y"
{
			yyval.v.filter_as = yyvsp[0].v.filter_as;
			yyval.v.filter_as->a.type = yyvsp[-1].v.u8;
		}
break;
case 177:
#line 1740 "parse.y"
{
			struct filter_as_l	*a;

			yyval.v.filter_as = yyvsp[-1].v.filter_as;
			for (a = yyval.v.filter_as; a != NULL; a = a->next)
				a->a.type = yyvsp[-3].v.u8;
		}
break;
case 179:
#line 1750 "parse.y"
{ yyval.v.filter_as = yyvsp[-1].v.filter_as; }
break;
case 180:
#line 1752 "parse.y"
{
			struct filter_as_l	*a;

			/* merge, both can be lists */
			for (a = yyvsp[-2].v.filter_as; a != NULL && a->next != NULL; a = a->next)
				;	/* nothing */
			if (a != NULL)
				a->next = yyvsp[0].v.filter_as;
			yyval.v.filter_as = yyvsp[-2].v.filter_as;
		}
break;
case 182:
#line 1765 "parse.y"
{
			yyvsp[0].v.filter_as->next = yyvsp[-2].v.filter_as;
			yyval.v.filter_as = yyvsp[0].v.filter_as;
		}
break;
case 183:
#line 1771 "parse.y"
{
			if ((yyval.v.filter_as = calloc(1, sizeof(struct filter_as_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_as->a.as = yyvsp[0].v.number;
			yyval.v.filter_as->a.op = OP_EQ;
		}
break;
case 184:
#line 1778 "parse.y"
{
			if ((yyval.v.filter_as = calloc(1, sizeof(struct filter_as_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_as->a.flags = AS_FLAG_NEIGHBORAS;
		}
break;
case 185:
#line 1784 "parse.y"
{
			if ((yyval.v.filter_as = calloc(1, sizeof(struct filter_as_l))) ==
			    NULL)
				fatal(NULL);
			yyval.v.filter_as->a.op = yyvsp[-1].v.u8;
			yyval.v.filter_as->a.as = yyvsp[0].v.number;
		}
break;
case 186:
#line 1791 "parse.y"
{
			if ((yyval.v.filter_as = calloc(1, sizeof(struct filter_as_l))) ==
			    NULL)
				fatal(NULL);
			if (yyvsp[-2].v.number >= yyvsp[0].v.number) {
				yyerror("start AS is bigger than end");
				YYERROR;
			}
			yyval.v.filter_as->a.op = yyvsp[-1].v.u8;
			yyval.v.filter_as->a.as_min = yyvsp[-2].v.number;
			yyval.v.filter_as->a.as_max = yyvsp[0].v.number;
		}
break;
case 187:
#line 1805 "parse.y"
{
			bzero(&yyval.v.filter_match, sizeof(yyval.v.filter_match));
			yyval.v.filter_match.m.community.as = COMMUNITY_UNSET;
			yyval.v.filter_match.m.large_community.as = COMMUNITY_UNSET;
		}
break;
case 188:
#line 1810 "parse.y"
{
			bzero(&fmopts, sizeof(fmopts));
			fmopts.m.community.as = COMMUNITY_UNSET;
			fmopts.m.large_community.as = COMMUNITY_UNSET;
		}
break;
case 189:
#line 1815 "parse.y"
{
			memcpy(&yyval.v.filter_match, &fmopts, sizeof(yyval.v.filter_match));
		}
break;
case 192:
#line 1824 "parse.y"
{
			if (fmopts.prefix_l != NULL) {
				yyerror("\"prefix\" already specified");
				YYERROR;
			}
			fmopts.prefix_l = yyvsp[0].v.filter_prefix;
		}
break;
case 193:
#line 1831 "parse.y"
{
			if (fmopts.as_l != NULL) {
				yyerror("AS filters already specified");
				YYERROR;
			}
			fmopts.as_l = yyvsp[0].v.filter_as;
		}
break;
case 194:
#line 1838 "parse.y"
{
			if (fmopts.m.aslen.type != ASLEN_NONE) {
				yyerror("AS length filters already specified");
				YYERROR;
			}
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > UINT_MAX) {
				yyerror("bad max-as-len %lld", yyvsp[0].v.number);
				YYERROR;
			}
			fmopts.m.aslen.type = ASLEN_MAX;
			fmopts.m.aslen.aslen = yyvsp[0].v.number;
		}
break;
case 195:
#line 1850 "parse.y"
{
			if (fmopts.m.aslen.type != ASLEN_NONE) {
				yyerror("AS length filters already specified");
				YYERROR;
			}
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > UINT_MAX) {
				yyerror("bad max-as-seq %lld", yyvsp[0].v.number);
				YYERROR;
			}
			fmopts.m.aslen.type = ASLEN_SEQ;
			fmopts.m.aslen.aslen = yyvsp[0].v.number;
		}
break;
case 196:
#line 1862 "parse.y"
{
			if (fmopts.m.community.as != COMMUNITY_UNSET) {
				yyerror("\"community\" already specified");
				free(yyvsp[0].v.string);
				YYERROR;
			}
			if (parsecommunity(&fmopts.m.community, yyvsp[0].v.string) == -1) {
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 197:
#line 1874 "parse.y"
{
			if (fmopts.m.large_community.as != COMMUNITY_UNSET) {
				yyerror("\"large-community\" already specified");
				free(yyvsp[0].v.string);
				YYERROR;
			}
			if (parselargecommunity(&fmopts.m.large_community, yyvsp[0].v.string) == -1) {
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 198:
#line 1886 "parse.y"
{
			if (fmopts.m.ext_community.flags &
			    EXT_COMMUNITY_FLAG_VALID) {
				yyerror("\"ext-community\" already specified");
				free(yyvsp[-1].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}

			if (parseextcommunity(&fmopts.m.ext_community,
			    yyvsp[-1].v.string, yyvsp[0].v.string) == -1) {
				free(yyvsp[-1].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[-1].v.string);
			free(yyvsp[0].v.string);
		}
break;
case 199:
#line 1904 "parse.y"
{
			if (fmopts.m.nexthop.flags) {
				yyerror("nexthop already specified");
				YYERROR;
			}
			fmopts.m.nexthop.addr = yyvsp[0].v.addr;
			fmopts.m.nexthop.flags = FILTER_NEXTHOP_ADDR;
		}
break;
case 200:
#line 1912 "parse.y"
{
			if (fmopts.m.nexthop.flags) {
				yyerror("nexthop already specified");
				YYERROR;
			}
			fmopts.m.nexthop.flags = FILTER_NEXTHOP_NEIGHBOR;
		}
break;
case 201:
#line 1921 "parse.y"
{ bzero(&yyval.v.prefixlen, sizeof(yyval.v.prefixlen)); }
break;
case 202:
#line 1922 "parse.y"
{
			bzero(&yyval.v.prefixlen, sizeof(yyval.v.prefixlen));
			yyval.v.prefixlen.op = OP_GE;
			yyval.v.prefixlen.len_min = -1;
		}
break;
case 203:
#line 1927 "parse.y"
{
			bzero(&yyval.v.prefixlen, sizeof(yyval.v.prefixlen));
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > 128) {
				yyerror("prefixlen must be >= 0 and <= 128");
				YYERROR;
			}
			if (yyvsp[-1].v.u8 == OP_GT && yyvsp[0].v.number == 0) {
				yyerror("prefixlen must be > 0");
				YYERROR;
			}
			yyval.v.prefixlen.op = yyvsp[-1].v.u8;
			yyval.v.prefixlen.len_min = yyvsp[0].v.number;
		}
break;
case 204:
#line 1940 "parse.y"
{
			bzero(&yyval.v.prefixlen, sizeof(yyval.v.prefixlen));
			if (yyvsp[-2].v.number < 0 || yyvsp[-2].v.number > 128 || yyvsp[0].v.number < 0 || yyvsp[0].v.number > 128) {
				yyerror("prefixlen must be < 128");
				YYERROR;
			}
			if (yyvsp[-2].v.number >= yyvsp[0].v.number) {
				yyerror("start prefixlen is bigger than end");
				YYERROR;
			}
			yyval.v.prefixlen.op = yyvsp[-1].v.u8;
			yyval.v.prefixlen.len_min = yyvsp[-2].v.number;
			yyval.v.prefixlen.len_max = yyvsp[0].v.number;
		}
break;
case 205:
#line 1956 "parse.y"
{ yyval.v.u8 = AS_ALL; }
break;
case 206:
#line 1957 "parse.y"
{ yyval.v.u8 = AS_SOURCE; }
break;
case 207:
#line 1958 "parse.y"
{ yyval.v.u8 = AS_TRANSIT; }
break;
case 208:
#line 1959 "parse.y"
{ yyval.v.u8 = AS_PEER; }
break;
case 209:
#line 1962 "parse.y"
{ yyval.v.filter_set_head = NULL; }
break;
case 210:
#line 1963 "parse.y"
{
			if ((yyval.v.filter_set_head = calloc(1, sizeof(struct filter_set_head))) ==
			    NULL)
				fatal(NULL);
			TAILQ_INIT(yyval.v.filter_set_head);
			TAILQ_INSERT_TAIL(yyval.v.filter_set_head, yyvsp[0].v.filter_set, entry);
		}
break;
case 211:
#line 1970 "parse.y"
{ yyval.v.filter_set_head = yyvsp[-2].v.filter_set_head; }
break;
case 212:
#line 1973 "parse.y"
{
			yyval.v.filter_set_head = yyvsp[-2].v.filter_set_head;
			if (merge_filterset(yyval.v.filter_set_head, yyvsp[0].v.filter_set) == 1)
				YYERROR;
		}
break;
case 213:
#line 1978 "parse.y"
{
			if ((yyval.v.filter_set_head = calloc(1, sizeof(struct filter_set_head))) ==
			    NULL)
				fatal(NULL);
			TAILQ_INIT(yyval.v.filter_set_head);
			TAILQ_INSERT_TAIL(yyval.v.filter_set_head, yyvsp[0].v.filter_set, entry);
		}
break;
case 214:
#line 1987 "parse.y"
{ yyval.v.u8 = 0; }
break;
case 215:
#line 1988 "parse.y"
{ yyval.v.u8 = 1; }
break;
case 216:
#line 1991 "parse.y"
{
			if (yyvsp[0].v.number < -INT_MAX || yyvsp[0].v.number > UINT_MAX) {
				yyerror("bad localpref %lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			if (yyvsp[0].v.number >= 0) {
				yyval.v.filter_set->type = ACTION_SET_LOCALPREF;
				yyval.v.filter_set->action.metric = yyvsp[0].v.number;
			} else {
				yyval.v.filter_set->type = ACTION_SET_RELATIVE_LOCALPREF;
				yyval.v.filter_set->action.relative = yyvsp[0].v.number;
			}
		}
break;
case 217:
#line 2006 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > INT_MAX) {
				yyerror("bad localpref +%lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_RELATIVE_LOCALPREF;
			yyval.v.filter_set->action.relative = yyvsp[0].v.number;
		}
break;
case 218:
#line 2016 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > INT_MAX) {
				yyerror("bad localpref -%lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_RELATIVE_LOCALPREF;
			yyval.v.filter_set->action.relative = -yyvsp[0].v.number;
		}
break;
case 219:
#line 2026 "parse.y"
{
			if (yyvsp[0].v.number < -INT_MAX || yyvsp[0].v.number > UINT_MAX) {
				yyerror("bad metric %lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			if (yyvsp[0].v.number >= 0) {
				yyval.v.filter_set->type = ACTION_SET_MED;
				yyval.v.filter_set->action.metric = yyvsp[0].v.number;
			} else {
				yyval.v.filter_set->type = ACTION_SET_RELATIVE_MED;
				yyval.v.filter_set->action.relative = yyvsp[0].v.number;
			}
		}
break;
case 220:
#line 2041 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > INT_MAX) {
				yyerror("bad metric +%lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_RELATIVE_MED;
			yyval.v.filter_set->action.relative = yyvsp[0].v.number;
		}
break;
case 221:
#line 2051 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > INT_MAX) {
				yyerror("bad metric -%lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_RELATIVE_MED;
			yyval.v.filter_set->action.relative = -yyvsp[0].v.number;
		}
break;
case 222:
#line 2061 "parse.y"
{	/* alias for MED */
			if (yyvsp[0].v.number < -INT_MAX || yyvsp[0].v.number > UINT_MAX) {
				yyerror("bad metric %lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			if (yyvsp[0].v.number >= 0) {
				yyval.v.filter_set->type = ACTION_SET_MED;
				yyval.v.filter_set->action.metric = yyvsp[0].v.number;
			} else {
				yyval.v.filter_set->type = ACTION_SET_RELATIVE_MED;
				yyval.v.filter_set->action.relative = yyvsp[0].v.number;
			}
		}
break;
case 223:
#line 2076 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > INT_MAX) {
				yyerror("bad metric +%lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_RELATIVE_MED;
			yyval.v.filter_set->action.metric = yyvsp[0].v.number;
		}
break;
case 224:
#line 2086 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > INT_MAX) {
				yyerror("bad metric -%lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_RELATIVE_MED;
			yyval.v.filter_set->action.relative = -yyvsp[0].v.number;
		}
break;
case 225:
#line 2096 "parse.y"
{
			if (yyvsp[0].v.number < -INT_MAX || yyvsp[0].v.number > UINT_MAX) {
				yyerror("bad weight %lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			if (yyvsp[0].v.number > 0) {
				yyval.v.filter_set->type = ACTION_SET_WEIGHT;
				yyval.v.filter_set->action.metric = yyvsp[0].v.number;
			} else {
				yyval.v.filter_set->type = ACTION_SET_RELATIVE_WEIGHT;
				yyval.v.filter_set->action.relative = yyvsp[0].v.number;
			}
		}
break;
case 226:
#line 2111 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > INT_MAX) {
				yyerror("bad weight +%lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_RELATIVE_WEIGHT;
			yyval.v.filter_set->action.relative = yyvsp[0].v.number;
		}
break;
case 227:
#line 2121 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > INT_MAX) {
				yyerror("bad weight -%lld", yyvsp[0].v.number);
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_RELATIVE_WEIGHT;
			yyval.v.filter_set->action.relative = -yyvsp[0].v.number;
		}
break;
case 228:
#line 2131 "parse.y"
{
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_NEXTHOP;
			memcpy(&yyval.v.filter_set->action.nexthop, &yyvsp[0].v.addr,
			    sizeof(yyval.v.filter_set->action.nexthop));
		}
break;
case 229:
#line 2138 "parse.y"
{
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_NEXTHOP_BLACKHOLE;
		}
break;
case 230:
#line 2143 "parse.y"
{
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_NEXTHOP_REJECT;
		}
break;
case 231:
#line 2148 "parse.y"
{
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_NEXTHOP_NOMODIFY;
		}
break;
case 232:
#line 2153 "parse.y"
{
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_NEXTHOP_SELF;
		}
break;
case 233:
#line 2158 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > 128) {
				yyerror("bad number of prepends");
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_PREPEND_SELF;
			yyval.v.filter_set->action.prepend = yyvsp[0].v.number;
		}
break;
case 234:
#line 2168 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > 128) {
				yyerror("bad number of prepends");
				YYERROR;
			}
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_PREPEND_PEER;
			yyval.v.filter_set->action.prepend = yyvsp[0].v.number;
		}
break;
case 235:
#line 2178 "parse.y"
{
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_PFTABLE;
			if (!(cmd_opts & BGPD_OPT_NOACTION) &&
			    pftable_exists(yyvsp[0].v.string) != 0) {
				yyerror("pftable name does not exist");
				free(yyvsp[0].v.string);
				free(yyval.v.filter_set);
				YYERROR;
			}
			if (strlcpy(yyval.v.filter_set->action.pftable, yyvsp[0].v.string,
			    sizeof(yyval.v.filter_set->action.pftable)) >=
			    sizeof(yyval.v.filter_set->action.pftable)) {
				yyerror("pftable name too long");
				free(yyvsp[0].v.string);
				free(yyval.v.filter_set);
				YYERROR;
			}
			if (pftable_add(yyvsp[0].v.string) != 0) {
				yyerror("Couldn't register table");
				free(yyvsp[0].v.string);
				free(yyval.v.filter_set);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 236:
#line 2205 "parse.y"
{
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_RTLABEL;
			if (strlcpy(yyval.v.filter_set->action.rtlabel, yyvsp[0].v.string,
			    sizeof(yyval.v.filter_set->action.rtlabel)) >=
			    sizeof(yyval.v.filter_set->action.rtlabel)) {
				yyerror("rtlabel name too long");
				free(yyvsp[0].v.string);
				free(yyval.v.filter_set);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 237:
#line 2219 "parse.y"
{
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			if (yyvsp[-1].v.u8)
				yyval.v.filter_set->type = ACTION_DEL_COMMUNITY;
			else
				yyval.v.filter_set->type = ACTION_SET_COMMUNITY;

			if (parsecommunity(&yyval.v.filter_set->action.community, yyvsp[0].v.string) == -1) {
				free(yyvsp[0].v.string);
				free(yyval.v.filter_set);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			/* Don't allow setting of any match */
			if (!yyvsp[-1].v.u8 && (yyval.v.filter_set->action.community.as == COMMUNITY_ANY ||
			    yyval.v.filter_set->action.community.type == COMMUNITY_ANY)) {
				yyerror("'*' is not allowed in set community");
				free(yyval.v.filter_set);
				YYERROR;
			}
		}
break;
case 238:
#line 2241 "parse.y"
{
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			if (yyvsp[-1].v.u8)
				yyval.v.filter_set->type = ACTION_DEL_LARGE_COMMUNITY;
			else
				yyval.v.filter_set->type = ACTION_SET_LARGE_COMMUNITY;

			if (parselargecommunity(&yyval.v.filter_set->action.large_community,
			    yyvsp[0].v.string) == -1) {
				free(yyvsp[0].v.string);
				free(yyval.v.filter_set);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			/* Don't allow setting of any match */
			if (!yyvsp[-1].v.u8 &&
			    (yyval.v.filter_set->action.large_community.as == COMMUNITY_ANY ||
			    yyval.v.filter_set->action.large_community.ld1 == COMMUNITY_ANY ||
			    yyval.v.filter_set->action.large_community.ld2 == COMMUNITY_ANY)) {
				yyerror("'*' is not allowed in set community");
				free(yyval.v.filter_set);
				YYERROR;
			}
		}
break;
case 239:
#line 2266 "parse.y"
{
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			if (yyvsp[-2].v.u8)
				yyval.v.filter_set->type = ACTION_DEL_EXT_COMMUNITY;
			else
				yyval.v.filter_set->type = ACTION_SET_EXT_COMMUNITY;

			if (parseextcommunity(&yyval.v.filter_set->action.ext_community,
			    yyvsp[-1].v.string, yyvsp[0].v.string) == -1) {
				free(yyvsp[-1].v.string);
				free(yyvsp[0].v.string);
				free(yyval.v.filter_set);
				YYERROR;
			}
			free(yyvsp[-1].v.string);
			free(yyvsp[0].v.string);
		}
break;
case 240:
#line 2284 "parse.y"
{
			if ((yyval.v.filter_set = calloc(1, sizeof(struct filter_set))) == NULL)
				fatal(NULL);
			yyval.v.filter_set->type = ACTION_SET_ORIGIN;
			yyval.v.filter_set->action.origin = yyvsp[0].v.number;
		}
break;
case 241:
#line 2292 "parse.y"
{
			if (!strcmp(yyvsp[0].v.string, "egp"))
				yyval.v.number = ORIGIN_EGP;
			else if (!strcmp(yyvsp[0].v.string, "igp"))
				yyval.v.number = ORIGIN_IGP;
			else if (!strcmp(yyvsp[0].v.string, "incomplete"))
				yyval.v.number = ORIGIN_INCOMPLETE;
			else {
				yyerror("unknown origin \"%s\"", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 244:
#line 2311 "parse.y"
{ yyval.v.u8 = OP_EQ; }
break;
case 245:
#line 2312 "parse.y"
{ yyval.v.u8 = OP_NE; }
break;
case 246:
#line 2313 "parse.y"
{ yyval.v.u8 = OP_LE; }
break;
case 247:
#line 2314 "parse.y"
{ yyval.v.u8 = OP_LT; }
break;
case 248:
#line 2315 "parse.y"
{ yyval.v.u8 = OP_GE; }
break;
case 249:
#line 2316 "parse.y"
{ yyval.v.u8 = OP_GT; }
break;
case 250:
#line 2319 "parse.y"
{ yyval.v.u8 = OP_EQ; }
break;
case 251:
#line 2320 "parse.y"
{ yyval.v.u8 = OP_NE; }
break;
case 252:
#line 2323 "parse.y"
{ yyval.v.u8 = OP_RANGE; }
break;
case 253:
#line 2324 "parse.y"
{ yyval.v.u8 = OP_XRANGE; }
break;
#line 5335 "parse.c"
    }
    yyssp -= yym;
    yystate = *yyssp;
    yyvsp -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
#endif
        yystate = YYFINAL;
        *++yyssp = YYFINAL;
        *++yyvsp = yyval;
        if (yychar < 0)
        {
            if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yyssp, yystate);
#endif
    if (yyssp >= yysslim && yygrowstack())
    {
        goto yyoverflow;
    }
    *++yyssp = yystate;
    *++yyvsp = yyval;
    goto yyloop;
yyoverflow:
    yyerror("yacc stack overflow");
yyabort:
    if (yyss)
            free(yyss);
    if (yyvs)
            free(yyvs);
    yyss = yyssp = NULL;
    yyvs = yyvsp = NULL;
    yystacksize = 0;
    return (1);
yyaccept:
    if (yyss)
            free(yyss);
    if (yyvs)
            free(yyvs);
    yyss = yyssp = NULL;
    yyvs = yyvsp = NULL;
    yystacksize = 0;
    return (0);
}

Generated by: GCOVR (Version 3.3)