Head

GCC Code Coverage Report
Directory:	./		Exec	Total	Coverage
File:	usr.sbin/hostapd/parse.c	Lines:	0	515	0.0 %
Date:	2017-11-07	Branches:	0	376	0.0 %

#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 24 "parse.y"
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/queue.h>
#include <sys/stat.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_media.h>
#include <net/if_arp.h>
#include <net/if_llc.h>
#include <net/bpf.h>

#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <arpa/inet.h>

#include <net80211/ieee80211.h>
#include <net80211/ieee80211_radiotap.h>

#include <ctype.h>
#include <errno.h>
#include <event.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <stdint.h>
#include <err.h>

#include "hostapd.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 *);

extern struct hostapd_config hostapd_cfg;

typedef struct {
	union {
		struct {
			u_int8_t		lladdr[IEEE80211_ADDR_LEN];
			struct hostapd_table	*table;
			u_int32_t		flags;
		} reflladdr;
		struct {
			u_int16_t		alg;
			u_int16_t		transaction;
		} authalg;
		struct in_addr		in;
		char			*string;
		int64_t			number;
		u_int16_t		reason;
		enum hostapd_op		op;
		struct timeval		timeout;
	} v;
	int lineno;
} YYSTYPE;

struct hostapd_apme *apme;
struct hostapd_table *table;
struct hostapd_entry *entry;
struct hostapd_frame frame, *frame_ptr;
struct hostapd_ieee80211_frame *frame_ieee80211;

#define HOSTAPD_MATCH(_m, _not)	{					\
	frame.f_flags |= (_not) ?					\
	    HOSTAPD_FRAME_F_##_m##_N : HOSTAPD_FRAME_F_##_m;		\
}
#define HOSTAPD_MATCH_TABLE(_m, _not)	{				\
	frame.f_flags |= HOSTAPD_FRAME_F_##_m##_TABLE | ((_not) ?	\
	    HOSTAPD_FRAME_F_##_m##_N : HOSTAPD_FRAME_F_##_m);		\
}
#define HOSTAPD_MATCH_RADIOTAP(_x) {					\
	if (hostapd_cfg.c_apme_dlt == DLT_IEEE802_11 ||			\
	    (hostapd_cfg.c_apme_dlt == 0 &&				\
	    HOSTAPD_DLT == DLT_IEEE802_11)) {				\
		yyerror("option %s requires radiotap headers", #_x);	\
		YYERROR;						\
	}								\
	frame.f_radiotap |= HOSTAPD_RADIOTAP_F(RSSI);			\
	frame.f_flags |= HOSTAPD_FRAME_F_##_x;				\
}
#define HOSTAPD_IAPP_FLAG(_f, _not) {					\
	if (_not)							\
		hostapd_cfg.c_iapp.i_flags &= ~(HOSTAPD_IAPP_F_##_f);	\
	else								\
		hostapd_cfg.c_iapp.i_flags |= (HOSTAPD_IAPP_F_##_f);	\
}

#line 137 "parse.c"
#define MODE 257
#define INTERFACE 258
#define IAPP 259
#define HOSTAP 260
#define MULTICAST 261
#define BROADCAST 262
#define SET 263
#define SEC 264
#define USEC 265
#define HANDLE 266
#define TYPE 267
#define SUBTYPE 268
#define FROM 269
#define TO 270
#define BSSID 271
#define WITH 272
#define FRAME 273
#define RADIOTAP 274
#define NWID 275
#define PASSIVE 276
#define MANAGEMENT 277
#define DATA 278
#define PROBE 279
#define BEACON 280
#define ATIM 281
#define ANY 282
#define DS 283
#define NO 284
#define DIR 285
#define RESEND 286
#define RANDOM 287
#define AUTH 288
#define DEAUTH 289
#define ASSOC 290
#define DISASSOC 291
#define REASSOC 292
#define REQUEST 293
#define RESPONSE 294
#define PCAP 295
#define RATE 296
#define ERROR 297
#define CONST 298
#define TABLE 299
#define NODE 300
#define DELETE 301
#define ADD 302
#define LOG 303
#define VERBOSE 304
#define LIMIT 305
#define QUICK 306
#define SKIP 307
#define REASON 308
#define UNSPECIFIED 309
#define EXPIRE 310
#define LEAVE 311
#define TOOMANY 312
#define NOT 313
#define AUTHED 314
#define ASSOCED 315
#define RESERVED 316
#define RSN 317
#define REQUIRED 318
#define INCONSISTENT 319
#define IE 320
#define INVALID 321
#define MIC 322
#define FAILURE 323
#define OPEN 324
#define ADDRESS 325
#define PORT 326
#define ON 327
#define NOTIFY 328
#define TTL 329
#define INCLUDE 330
#define ROUTE 331
#define ROAMING 332
#define RSSI 333
#define TXRATE 334
#define FREQ 335
#define HOPPER 336
#define DELAY 337
#define NE 338
#define LE 339
#define GE 340
#define ARROW 341
#define STRING 342
#define NUMBER 343
#define YYERRCODE 256
const short yylhs[] =
	{                                        -1,
    0,    0,    0,    0,    0,    0,    0,    0,   17,   19,
   19,   19,   19,   19,   19,   19,   19,   19,   26,   26,
   28,   28,   29,   29,   30,   30,   24,   24,   22,   22,
   32,   32,   33,   23,   23,   35,   35,   36,   37,   37,
   39,   42,   20,   27,   27,   45,   45,   46,   46,   46,
   46,   38,   38,   38,   41,   41,   41,   41,   41,   41,
   47,   47,   49,   50,   50,   40,   40,   51,   51,   48,
   43,   43,   43,   44,   44,   52,   52,   52,   52,   63,
   63,   63,   64,   64,   64,   64,   64,   64,   64,   64,
   64,   64,   64,   65,   65,   68,   68,   69,   66,   66,
   10,   10,   67,    7,    7,    7,    7,    7,    7,    7,
    7,    7,    7,    7,    7,    7,    7,    7,   53,   53,
   53,   70,   70,   70,   70,   54,   54,   54,   55,   55,
   55,   56,   56,   56,   57,   57,   71,   71,   72,   72,
   72,    6,    6,   58,   58,   73,   59,   59,   60,   61,
   62,    5,    5,    5,    8,   75,   18,   74,   74,   76,
   76,   77,   77,   77,    9,    9,   21,    2,    2,    2,
   78,   78,   81,   79,   80,   80,   80,    1,   83,   83,
    3,    4,   25,   25,   82,   84,   34,   34,   31,   31,
   15,   15,   15,   11,   11,   11,   11,   11,   11,   11,
   11,   11,   12,   13,   14,   16,
};
const short yylen[] =
	{                                         2,
    0,    2,    3,    3,    3,    3,    3,    3,    2,    4,
    5,    5,    4,    5,    4,    6,    6,    5,    4,    2,
    0,    2,    0,    2,    0,    2,    1,    1,    5,    1,
    1,    3,    1,    5,    1,    1,    3,    1,    0,    3,
    0,    0,   10,    5,    1,    1,    3,    3,    2,    3,
    3,    0,    1,    1,    0,    3,    3,    3,    4,    2,
    0,    1,    3,    1,    1,    1,    7,    0,    1,    5,
    0,    3,    3,    0,    5,    0,    2,    3,    4,    0,
    2,    3,    3,    3,    2,    1,    2,    2,    2,    2,
    2,    2,    2,    0,    1,    2,    1,    3,    0,    1,
    2,    2,    1,    0,    2,    3,    3,    3,    3,    3,
    3,    3,    4,    2,    3,    3,    3,    3,    0,    2,
    3,    2,    2,    2,    3,    0,    2,    3,    0,    2,
    3,    0,    2,    3,    0,    1,    2,    1,    3,    3,
    3,    1,    1,    2,    3,    2,    0,    2,    2,    2,
    2,    1,    1,    1,    3,    0,    4,    0,    1,    2,
    1,    1,    3,    5,    2,    1,    3,    2,    2,    2,
    1,    3,    0,    3,    0,    3,    2,    1,    0,    2,
    1,    1,    0,    1,    1,    1,    0,    2,    0,    1,
    0,    1,    1,    0,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,
};
const short yydefred[] =
	{                                      1,
    0,    0,    0,    0,    0,    0,    0,    2,    0,    0,
    0,    0,    0,    8,   41,    0,    0,    0,  156,    9,
    0,    3,    4,    5,    6,    7,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,  166,    0,   53,
   54,    0,    0,    0,   15,    0,    0,    0,    0,   27,
   28,   13,   33,    0,   10,   30,    0,    0,  155,  162,
    0,  157,    0,  161,  165,    0,    0,    0,    0,    0,
   20,  184,   14,  193,    0,  192,    0,   18,   45,    0,
    0,  190,    0,   38,    0,   11,   35,  206,   12,    0,
  160,    0,   69,   66,   42,    0,  178,   22,    0,   24,
    0,   49,    0,    0,    0,   16,   17,    0,   31,    0,
  181,  163,  173,    0,  171,   40,    0,    0,    0,    0,
   19,    0,   46,   48,   51,   50,    0,    0,    0,    0,
   36,    0,    0,    0,    0,    0,   77,    0,    0,    0,
   26,    0,    0,  188,   29,   32,    0,    0,  185,  186,
  174,    0,    0,  164,  172,    0,    0,   60,    0,    0,
    0,    0,    0,   78,  120,    0,    0,    0,   44,   47,
   34,   37,    0,  177,    0,   58,    0,   57,    0,   64,
   65,    0,   62,   56,    0,    0,   43,    0,   79,    0,
    0,    0,    0,  121,  127,    0,    0,    0,    0,  176,
    0,    0,  144,    0,    0,  182,    0,  154,  152,  153,
   59,   72,   73,    0,   81,    0,  124,  123,    0,  122,
  143,  128,  142,  130,    0,    0,    0,  180,   63,    0,
  145,  148,    0,    0,  168,  169,  170,    0,    0,    0,
   86,    0,    0,    0,    0,    0,   82,  125,  131,  133,
    0,    0,    0,    0,   67,    0,  138,  146,  149,    0,
    0,    0,    0,    0,    0,   85,    0,   97,    0,  100,
   87,    0,  103,   88,   89,   91,   90,   92,   93,  134,
  198,  199,  201,  200,  202,  195,  197,  196,    0,    0,
    0,  137,  150,    0,   70,   75,   83,   84,    0,   96,
  101,  102,    0,    0,  105,    0,  114,    0,    0,    0,
  203,  139,  204,  140,  205,  141,  151,   98,  106,  107,
  108,  112,  109,    0,  110,  111,  115,  116,  117,  118,
  113,
};
const short yydgoto[] =
	{                                       1,
   98,  208,  209,  210,  211,  222,  273,  223,   39,  270,
  289,  312,  314,  316,   77,   89,    9,   10,   11,   12,
   13,   55,   86,   52,   73,   45,   78,   69,   71,  121,
   83,  108,   56,  129,  130,   87,   67,   42,   27,   95,
  136,  117,  162,  187,  122,   79,  184,  178,  176,  182,
   96,  119,  140,  168,  198,  227,  255,  179,  205,  234,
  261,  295,  189,  247,  266,  271,  274,  267,  268,  194,
  256,  257,  231,   62,   37,   63,   64,  114,  115,  151,
  132,  152,  200,  153,
};
const short yysindex[] =
	{                                      0,
  -10,   37, -217, -208,    5, -288,    1,    0,   60,   88,
   95,  100,  108,    0,    0, -229, -236, -241,    0,    0,
 -214,    0,    0,    0,    0,    0, -218, -141, -207, -131,
 -185, -170, -226, -115, -231,  109, -103,    0, -169,    0,
    0, -140, -136, -122,    0,  -57,  -19,  -97,  -78,    0,
    0,    0,    0,  210,    0,    0, -112, -121,    0,    0,
  210,    0, -103,    0,    0,  -18, -188, -116, -122, -114,
    0,    0,    0,    0,  210,    0, -249,    0,    0,    5,
    5,    0, -111,    0,  210,    0,    0,    0,    0, -108,
    0, -110,    0,    0,    0,  -44,    0,    0, -101,    0,
  -18,    0, -104,  -99,  -95,    0,    0,   30,    0, -102,
    0,    0,    0,   30,    0,    0,  -34,  -20,  -46, -100,
    0,   30,    0,    0,    0,    0,  210,  116, -111,   30,
    0,    3,  117,  -94, -213,  -61,    0, -146,   78,  -24,
    0,  122,  -18,    0,    0,    0,  126, -102,    0,    0,
    0, -116,  -94,    0,    0,  -15,  -13,    0, -160,  -55,
  -88,  -39,  -12,    0,    0, -144,   89,  -11,    0,    0,
    0,    0,  213,    0,   -4,    0, -133,    0,  -17,    0,
    0,  -29,    0,    0, -105,  -66,    0,   90,    0,   -2,
   -1,   10,   13,    0,    0,  -54,   91,   12,  -58,    0,
  -55,   18,    0, -144,   43,    0, -178,    0,    0,    0,
    0,    0,    0,  250,    0,  -98,    0,    0,   63,    0,
    0,    0,    0,    0,  -54,  132, -221,    0,    0,  -98,
    0,    0,  -29,   77,    0,    0,    0,    9, -126,   73,
    0,   29,   47, -124,   47, -119,    0,    0,    0,    0,
  -54,  -30,  -30,  -30,    0, -221,    0,    0,    0,  -29,
   85,   97,   73,   73,  -18,    0,   73,    0, -117,    0,
    0, -245,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,   15,   24,
   40,    0,    0,  -29,    0,    0,    0,    0,   42,    0,
    0,    0, -132, -158,    0, -118,    0, -109,   64,   74,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,   56,    0,    0,    0,    0,    0,    0,
    0,};
const short yyrindex[] =
	{                                      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,   -6,    0,    0,    0,
    0,    0,    0,    0,    0,    0,  409,    0,  412,    0,
    0,    2,   14,   88,    0,  415, -195,    0,    0,    0,
    0,    0,    0,   92,    0,    0,    0,    0,    0,    0,
 -107,    0,  420,    0,    0,   94,   34,    0,   -3,    0,
    0,    0,    0,    0,  180,    0,    0,    0,    0,    0,
    0,    0,    0,    0,   92,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,   46,    0,    0,  100,    0,
 -195,    0,    0,    0,    0,    0,    0, -106,    0,    0,
    0,    0,    0, -106,    0,    0,   45,  -79,  146,    0,
    0,  175,    0,    0,    0,    0,  170,    0,    0, -106,
    0,   -9,    0,    0,    0,   -5,    0,    0, -120,  141,
    0,    0, -195,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,   49,
    0,  421,   53,    0,    0,    0,  -50,  128,    0,    0,
    0,    0,   -8,    0,    0,    0,    0,    0,  166,    0,
    0,    0,    0,    0,    0,    0,    0,  -74,    0,    0,
    0,    0,    0,    0,    0,    0,  -50,  151,    0,    0,
   49,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  -50,    6,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,   93,
    0,  105,  124,    0,  124,    0,    0,    0,    0,    0,
    0,  101,  101,  101,    0,   87,    0,    0,    0,    0,
    0,    0,   93,   93,   94,    0,  136,    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,};
const short yygindex[] =
	{                                      0,
  296,    0,  -67,    0, -199, -168,    0,   28,    0,    0,
  -53,    0,    0,    0,  -40,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  381,    0,
   58,    0,  -45,  -64,    0,  -68,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  -62,  251,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,  223,  -52,    0,  215,    0,  188,  260,
    0,  209,    0,    0,    0,    0,  403,    0,  333,    0,
    0,    0,    0,    0,
};
#define YYTABLESIZE 512
const short yytable[] =
	{                                       8,
  175,  179,  287,   52,   71,   18,   23,   54,  207,  191,
   85,   39,   76,   76,   76,  135,  112,  189,  189,   61,
   33,   34,  113,   21,  102,   92,   57,   28,   29,  284,
  286,  285,   19,  259,  175,  179,   30,  109,  123,   82,
  150,  131,  303,   68,  304,  156,   14,   50,   15,  134,
   16,   17,  103,   20,   55,   76,  249,  143,   61,  157,
  293,   21,   80,  305,   18,  148,  113,  306,   51,   22,
  307,  308,  158,  127,  309,  104,  310,  138,  191,  172,
  170,  105,  280,  146,   93,  174,  159,   40,   41,  160,
  235,  236,  237,   94,  317,   31,  136,   23,  166,   35,
   36,   32,   94,   75,   24,   58,  191,  106,  107,   25,
   76,  252,  253,  254,   99,  175,  179,   26,   90,   43,
   44,   76,   76,   76,  190,  191,  196,   38,  221,  191,
  163,  164,  101,  104,   46,  191,   47,  129,  192,  193,
  180,  181,  110,  202,  203,   95,   48,  216,  191,  191,
  126,  321,  322,  323,  324,  119,  225,  221,  212,  213,
  132,   49,  191,  191,   76,  128,  263,  264,  275,  276,
   59,  133,   65,  278,  279,  301,  302,  319,  320,  142,
  239,  240,  241,  221,  144,  251,   66,  147,   68,  242,
  243,  244,  245,  246,   60,  325,  326,  191,  191,  290,
  291,   80,  189,   70,  191,  191,  191,  187,  327,  328,
  297,  298,  189,  191,  191,  191,  191,  191,   72,   82,
   81,   88,  118,  124,  299,   97,   53,  120,  100,   84,
   53,  116,  125,  111,  189,  187,  126,  135,  139,   84,
  145,  154,  141,  161,  167,    2,  169,  111,  183,    3,
  171,  175,    4,  177,  185,  188,  186,  206,  197,  199,
   52,  137,   52,   52,   52,   52,   52,  204,   39,  201,
   39,   39,   39,   39,   39,   52,  214,  135,   52,  219,
  217,  218,  226,   39,  228,  230,   39,  111,    5,   52,
   71,  191,   74,   74,   74,  220,  238,   39,   52,  189,
   68,  135,   68,   68,   68,   68,   39,  281,  282,  283,
  135,  233,  111,  288,   76,   76,   76,   76,   68,    6,
   52,   80,   80,   80,   80,   23,   52,   52,   52,   68,
   76,    7,  175,  179,   39,   39,   39,   80,   68,   21,
   55,   76,   21,  149,   61,  248,  260,  265,   80,   55,
   76,  262,  269,   61,  272,  294,  311,   80,  136,  165,
  296,   94,   94,   94,   94,  313,   68,   68,   68,  331,
  195,  215,  224,   99,   99,   99,   99,   94,   76,   76,
   76,  315,  136,  318,  329,   80,   80,   80,   94,   99,
   74,  136,  104,  104,  104,  104,  330,   94,  129,  129,
   99,   74,   74,   74,   95,   95,   95,   95,  104,   99,
  126,  126,  126,  250,  119,  119,  119,  119,  158,  104,
   95,  167,  132,  129,  183,   94,   94,   94,  104,  159,
   74,   95,  129,  189,  147,  191,  126,   99,   99,   99,
   95,  119,  194,  189,   74,  126,  132,  173,  187,   99,
  119,  229,  258,  189,  300,  132,  104,  104,  104,  277,
  129,  129,  129,  232,  292,   91,  155,    0,   95,   95,
   95,  189,    0,  126,  126,  126,  187,    0,  119,  119,
  119,  189,  189,  132,  132,  132,    0,  187,    0,    0,
    0,    0,  189,    0,  189,    0,    0,    0,    0,  187,
  189,    0,    0,    0,  189,  187,    0,    0,    0,    0,
  189,  189,
};
const short yycheck[] =
	{                                      10,
   10,   10,   33,   10,   10,   60,   10,  123,   38,   60,
  123,   10,   33,   33,   33,   10,  125,  125,  125,  123,
  257,  258,   90,   10,  274,   66,  258,  257,  258,   60,
   61,   62,    5,  233,   44,   44,  266,   83,  101,   10,
   38,  110,  288,   10,  290,  259,   10,  274,  266,  114,
  259,  260,  302,  342,   10,   10,  225,  122,   10,  273,
  260,   61,   10,  309,   60,  130,  134,  313,  295,   10,
  316,  317,  286,   44,  320,  325,  322,  118,  274,  148,
  143,  331,  251,  129,  273,  153,  300,  306,  307,  303,
  269,  270,  271,  282,  294,  325,   10,   10,  139,  336,
  342,  331,   10,  123,   10,  337,  302,   80,   81,   10,
   33,  333,  334,  335,   10,  125,  125,   10,   61,  261,
  262,   33,   33,   33,  269,  270,  167,  342,  196,  325,
  277,  278,   75,   10,  342,  331,  268,   10,  283,  284,
  301,  302,   85,  277,  278,   10,  332,  188,  269,  270,
   10,  310,  311,  312,  313,   10,  197,  225,  264,  265,
   10,  332,  283,  284,   33,  108,  293,  294,  293,  294,
   62,  114,  342,  293,  294,  293,  294,  310,  311,  122,
  279,  280,  281,  251,  127,  226,  327,  130,  325,  288,
  289,  290,  291,  292,  298,  314,  315,  277,  278,  253,
  254,  299,   33,  326,  279,  280,  281,   33,  318,  319,
  263,  264,   33,  288,  289,  290,  291,  292,  276,   10,
  299,  343,  267,  328,  265,  342,  342,  329,  343,  342,
  342,  342,  332,  342,  342,  342,  332,  272,  285,  342,
  125,  125,  343,  305,  269,  256,  125,  342,  304,  260,
  125,  267,  263,  267,  343,  268,  296,  287,  270,   47,
  267,  282,  269,  270,  271,  272,  273,  285,  267,  274,
  269,  270,  271,  272,  273,  282,  343,  272,  285,  270,
  283,  283,  271,  282,  343,  268,  285,  342,  299,  296,
  296,  342,  313,  313,  313,  283,   47,  296,  305,  125,
  267,  296,  269,  270,  271,  272,  305,  338,  339,  340,
  305,  269,  342,  344,  269,  270,  271,  272,  285,  330,
  327,  269,  270,  271,  272,  329,  333,  334,  335,  296,
  285,  342,  342,  342,  333,  334,  335,  285,  305,  326,
  296,  296,  329,  341,  296,  283,  270,  275,  296,  305,
  305,  343,  324,  305,  308,  271,  342,  305,  272,  282,
  264,  269,  270,  271,  272,  342,  333,  334,  335,  314,
  282,  282,  282,  269,  270,  271,  272,  285,  333,  334,
  335,  342,  296,  342,  321,  333,  334,  335,  296,  285,
  313,  305,  269,  270,  271,  272,  323,  305,  271,  272,
  296,  313,  313,  313,  269,  270,  271,  272,  285,  305,
  270,  271,  272,  282,  269,  270,  271,  272,   10,  296,
  285,   10,  272,  296,   10,  333,  334,  335,  305,   10,
   10,  296,  305,  342,  269,  342,  296,  333,  334,  335,
  305,  296,  342,  274,  313,  305,  296,  152,  274,   69,
  305,  201,  230,  274,  267,  305,  333,  334,  335,  245,
  333,  334,  335,  204,  256,   63,  134,   -1,  333,  334,
  335,  302,   -1,  333,  334,  335,  302,   -1,  333,  334,
  335,  302,  313,  333,  334,  335,   -1,  313,   -1,   -1,
   -1,   -1,  313,   -1,  325,   -1,   -1,   -1,   -1,  325,
  331,   -1,   -1,   -1,  325,  331,   -1,   -1,   -1,   -1,
  331,  342,
};
#define YYFINAL 1
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 344
#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,"MODE","INTERFACE","IAPP","HOSTAP","MULTICAST","BROADCAST","SET","SEC",
"USEC","HANDLE","TYPE","SUBTYPE","FROM","TO","BSSID","WITH","FRAME","RADIOTAP",
"NWID","PASSIVE","MANAGEMENT","DATA","PROBE","BEACON","ATIM","ANY","DS","NO",
"DIR","RESEND","RANDOM","AUTH","DEAUTH","ASSOC","DISASSOC","REASSOC","REQUEST",
"RESPONSE","PCAP","RATE","ERROR","CONST","TABLE","NODE","DELETE","ADD","LOG",
"VERBOSE","LIMIT","QUICK","SKIP","REASON","UNSPECIFIED","EXPIRE","LEAVE",
"TOOMANY","NOT","AUTHED","ASSOCED","RESERVED","RSN","REQUIRED","INCONSISTENT",
"IE","INVALID","MIC","FAILURE","OPEN","ADDRESS","PORT","ON","NOTIFY","TTL",
"INCLUDE","ROUTE","ROAMING","RSSI","TXRATE","FREQ","HOPPER","DELAY","NE","LE",
"GE","ARROW","STRING","NUMBER","\"==\"",
};
const char * const yyrule[] =
	{"$accept : grammar",
"grammar :",
"grammar : grammar '\\n'",
"grammar : grammar include '\\n'",
"grammar : grammar tabledef '\\n'",
"grammar : grammar option '\\n'",
"grammar : grammar event '\\n'",
"grammar : grammar varset '\\n'",
"grammar : grammar error '\\n'",
"include : INCLUDE STRING",
"option : SET HOSTAP INTERFACE hostapifaces",
"option : SET HOSTAP HOPPER INTERFACE hopperifaces",
"option : SET HOSTAP HOPPER DELAY timeout",
"option : SET HOSTAP MODE hostapmode",
"option : SET IAPP INTERFACE STRING passive",
"option : SET IAPP MODE iappmode",
"option : SET IAPP ADDRESS ROAMING TABLE table",
"option : SET IAPP ROUTE ROAMING TABLE table",
"option : SET IAPP HANDLE SUBTYPE iappsubtypes",
"iappmode : MULTICAST iappmodeaddr iappmodeport iappmodettl",
"iappmode : BROADCAST iappmodeport",
"iappmodeaddr :",
"iappmodeaddr : ADDRESS ipv4addr",
"iappmodeport :",
"iappmodeport : PORT NUMBER",
"iappmodettl :",
"iappmodettl : TTL NUMBER",
"hostapmode : RADIOTAP",
"hostapmode : PCAP",
"hostapifaces : '{' optnl hostapifacelist optnl '}'",
"hostapifaces : hostapiface",
"hostapifacelist : hostapiface",
"hostapifacelist : hostapifacelist comma hostapiface",
"hostapiface : STRING",
"hopperifaces : '{' optnl hopperifacelist optnl '}'",
"hopperifaces : hopperiface",
"hopperifacelist : hopperiface",
"hopperifacelist : hopperifacelist comma hopperiface",
"hopperiface : STRING",
"hostapmatch :",
"hostapmatch : ON not STRING",
"$$1 :",
"$$2 :",
"event : HOSTAP HANDLE $$1 eventopt hostapmatch frmmatch $$2 action limit rate",
"iappsubtypes : '{' optnl iappsubtypelist optnl '}'",
"iappsubtypes : iappsubtype",
"iappsubtypelist : iappsubtype",
"iappsubtypelist : iappsubtypelist comma iappsubtype",
"iappsubtype : not ADD NOTIFY",
"iappsubtype : not RADIOTAP",
"iappsubtype : not ROUTE ROAMING",
"iappsubtype : not ADDRESS ROAMING",
"eventopt :",
"eventopt : QUICK",
"eventopt : SKIP",
"action :",
"action : WITH LOG verbose",
"action : WITH FRAME frmaction",
"action : WITH IAPP iapp",
"action : WITH NODE nodeopt frmactionaddr",
"action : WITH RESEND",
"verbose :",
"verbose : VERBOSE",
"iapp : TYPE RADIOTAP verbose",
"nodeopt : DELETE",
"nodeopt : ADD",
"frmmatch : ANY",
"frmmatch : frm frmmatchtype frmmatchdir frmmatchfrom frmmatchto frmmatchbssid frmmatchrtap",
"frm :",
"frm : FRAME",
"frmaction : frmactiontype frmactiondir frmactionfrom frmactionto frmactionbssid",
"limit :",
"limit : LIMIT NUMBER SEC",
"limit : LIMIT NUMBER USEC",
"rate :",
"rate : RATE NUMBER '/' NUMBER SEC",
"frmmatchtype :",
"frmmatchtype : TYPE ANY",
"frmmatchtype : TYPE not DATA",
"frmmatchtype : TYPE not MANAGEMENT frmmatchmgmt",
"frmmatchmgmt :",
"frmmatchmgmt : SUBTYPE ANY",
"frmmatchmgmt : SUBTYPE not frmsubtype",
"frmsubtype : PROBE REQUEST frmelems",
"frmsubtype : PROBE RESPONSE frmelems",
"frmsubtype : BEACON frmelems",
"frmsubtype : ATIM",
"frmsubtype : AUTH frmauth",
"frmsubtype : DEAUTH frmreason",
"frmsubtype : ASSOC REQUEST",
"frmsubtype : DISASSOC frmreason",
"frmsubtype : ASSOC RESPONSE",
"frmsubtype : REASSOC REQUEST",
"frmsubtype : REASSOC RESPONSE",
"frmelems :",
"frmelems : frmelems_l",
"frmelems_l : frmelems_l frmelem",
"frmelems_l : frmelem",
"frmelem : NWID not STRING",
"frmauth :",
"frmauth : authalg",
"authalg : OPEN REQUEST",
"authalg : OPEN RESPONSE",
"frmreason : frmreason_l",
"frmreason_l :",
"frmreason_l : REASON UNSPECIFIED",
"frmreason_l : REASON AUTH EXPIRE",
"frmreason_l : REASON AUTH LEAVE",
"frmreason_l : REASON ASSOC EXPIRE",
"frmreason_l : REASON ASSOC TOOMANY",
"frmreason_l : REASON NOT AUTHED",
"frmreason_l : REASON NOT ASSOCED",
"frmreason_l : REASON ASSOC LEAVE",
"frmreason_l : REASON ASSOC NOT AUTHED",
"frmreason_l : REASON RESERVED",
"frmreason_l : REASON RSN REQUIRED",
"frmreason_l : REASON RSN INCONSISTENT",
"frmreason_l : REASON IE INVALID",
"frmreason_l : REASON MIC FAILURE",
"frmmatchdir :",
"frmmatchdir : DIR ANY",
"frmmatchdir : DIR not frmdir",
"frmdir : NO DS",
"frmdir : TO DS",
"frmdir : FROM DS",
"frmdir : DS TO DS",
"frmmatchfrom :",
"frmmatchfrom : FROM ANY",
"frmmatchfrom : FROM not frmmatchaddr",
"frmmatchto :",
"frmmatchto : TO ANY",
"frmmatchto : TO not frmmatchaddr",
"frmmatchbssid :",
"frmmatchbssid : BSSID ANY",
"frmmatchbssid : BSSID not frmmatchaddr",
"frmmatchrtap :",
"frmmatchrtap : frmmatchrtap_l",
"frmmatchrtap_l : frmmatchrtap_l frmmatchrtapopt",
"frmmatchrtap_l : frmmatchrtapopt",
"frmmatchrtapopt : RSSI unaryop percent",
"frmmatchrtapopt : TXRATE unaryop txrate",
"frmmatchrtapopt : FREQ unaryop freq",
"frmmatchaddr : table",
"frmmatchaddr : lladdr",
"frmactiontype : TYPE DATA",
"frmactiontype : TYPE MANAGEMENT frmactionmgmt",
"frmactionmgmt : SUBTYPE frmsubtype",
"frmactiondir :",
"frmactiondir : DIR frmdir",
"frmactionfrom : FROM frmactionaddr",
"frmactionto : TO frmactionaddr",
"frmactionbssid : BSSID frmactionaddr",
"frmactionaddr : lladdr",
"frmactionaddr : randaddr",
"frmactionaddr : refaddr",
"table : '<' STRING '>'",
"$$3 :",
"tabledef : TABLE table $$3 tableopts",
"tableopts :",
"tableopts : tableopts_l",
"tableopts_l : tableopts_l tableopt",
"tableopts_l : tableopt",
"tableopt : CONST",
"tableopt : '{' optnl '}'",
"tableopt : '{' optnl tableaddrlist optnl '}'",
"string : string STRING",
"string : STRING",
"varset : STRING '=' string",
"refaddr : '&' FROM",
"refaddr : '&' TO",
"refaddr : '&' BSSID",
"tableaddrlist : tableaddrentry",
"tableaddrlist : tableaddrlist comma tableaddrentry",
"$$4 :",
"tableaddrentry : lladdr $$4 tableaddropt",
"tableaddropt :",
"tableaddropt : assign ipv4addr ipv4netmask",
"tableaddropt : mask lladdr",
"ipv4addr : STRING",
"ipv4netmask :",
"ipv4netmask : '/' NUMBER",
"lladdr : STRING",
"randaddr : RANDOM",
"passive :",
"passive : PASSIVE",
"assign : ARROW",
"mask : '&'",
"comma :",
"comma : ',' optnl",
"optnl :",
"optnl : '\\n'",
"not :",
"not : '!'",
"not : NOT",
"unaryop :",
"unaryop : '='",
"unaryop : \"==\"",
"unaryop : '!'",
"unaryop : NE",
"unaryop : LE",
"unaryop : '<'",
"unaryop : GE",
"unaryop : '>'",
"percent : STRING",
"txrate : STRING",
"freq : STRING",
"timeout : NUMBER",
};
#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 1226 "parse.y"

/*
 * Parser and lexer
 */

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

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

int
lookup(char *token)
{
	/* Keep this list sorted */
	static const struct keywords keywords[] = {
		{ "add",		ADD },
		{ "address",		ADDRESS },
		{ "any",		ANY },
		{ "assoc",		ASSOC },
		{ "assoced",		ASSOCED },
		{ "atim",		ATIM },
		{ "auth",		AUTH },
		{ "authed",		AUTHED },
		{ "beacon",		BEACON },
		{ "broadcast",		BROADCAST },
		{ "bssid",		BSSID },
		{ "const",		CONST },
		{ "data",		DATA },
		{ "deauth",		DEAUTH },
		{ "delay",		DELAY },
		{ "delete",		DELETE },
		{ "dir",		DIR },
		{ "disassoc",		DISASSOC },
		{ "ds",			DS },
		{ "expire",		EXPIRE },
		{ "failure",		FAILURE },
		{ "frame",		FRAME },
		{ "freq",		FREQ },
		{ "from",		FROM },
		{ "handle",		HANDLE },
		{ "hopper",		HOPPER },
		{ "hostap",		HOSTAP },
		{ "iapp",		IAPP },
		{ "ie",			IE },
		{ "include",		INCLUDE },
		{ "inconsistent",	INCONSISTENT },
		{ "interface",		INTERFACE },
		{ "invalid",		INVALID },
		{ "leave",		LEAVE },
		{ "limit",		LIMIT },
		{ "log",		LOG },
		{ "management",		MANAGEMENT },
		{ "mic",		MIC },
		{ "mode",		MODE },
		{ "multicast",		MULTICAST },
		{ "no",			NO },
		{ "node",		NODE },
		{ "not",		NOT },
		{ "notify",		NOTIFY },
		{ "nwid",		NWID },
		{ "on",			ON },
		{ "open",		OPEN },
		{ "passive",		PASSIVE },
		{ "pcap",		PCAP },
		{ "port",		PORT },
		{ "probe",		PROBE },
		{ "quick",		QUICK },
		{ "radiotap",		RADIOTAP },
		{ "random",		RANDOM },
		{ "rate",		RATE },
		{ "reason",		REASON },
		{ "reassoc",		REASSOC },
		{ "request",		REQUEST },
		{ "required",		REQUIRED },
		{ "resend",		RESEND },
		{ "reserved",		RESERVED },
		{ "response",		RESPONSE },
		{ "roaming",		ROAMING },
		{ "route",		ROUTE },
		{ "rsn",		RSN },
		{ "sec",		SEC },
		{ "set",		SET },
		{ "signal",		RSSI },
		{ "skip",		SKIP },
		{ "subtype",		SUBTYPE },
		{ "table",		TABLE },
		{ "to",			TO },
		{ "toomany",		TOOMANY },
		{ "ttl",		TTL },
		{ "txrate",		TXRATE },
		{ "type",		TYPE },
		{ "unspecified",	UNSPECIFIED },
		{ "usec",		USEC },
		{ "verbose",		VERBOSE },
		{ "with",		WITH }
	};
	const struct keywords *p;

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

	return (p == NULL ? STRING : p->k_val);
}

#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)
			hostapd_fatal("yylex: strdup");
		return (STRING);
	case '-':
		next = lgetc(0);
		if (next == '>')
			return (ARROW);
		lungetc(next);
		break;
	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 (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)
				hostapd_fatal("yylex: strdup");
		return (token);
	}
	if (c == '\n') {
		yylval.lineno = file->lineno;
		file->lineno++;
	}
	if (c == EOF)
		return (0);
	return (c);
}

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);

	hostapd_log(HOSTAPD_LOG_DEBUG, "%s = \"%s\"", sym->nam, sym->val);

	return (0);
}

int
hostapd_parse_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)
		hostapd_fatal("cmdline_symset: malloc");

	(void)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
check_file_secrecy(int fd, const char *fname)
{
	struct stat	st;

	if (fstat(fd, &st)) {
		warn("cannot stat %s", fname);
		return (-1);
	}
	if (st.st_uid != 0 && st.st_uid != getuid()) {
		warnx("%s: owner not root or current user", fname);
		return (-1);
	}
	if (st.st_mode & (S_IWGRP | S_IXGRP | S_IRWXO)) {
		warnx("%s: group writable or world read/writable", fname);
		return (-1);
	}
	return (0);
}

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

	if ((nfile = calloc(1, sizeof(struct file))) == NULL) {
		warn("out of memory");
		return (NULL);
	}
	if ((nfile->name = strdup(name)) == NULL) {
		warn("out of memory");
		free(nfile);
		return (NULL);
	}
	if ((nfile->stream = fopen(nfile->name, "r")) == NULL) {
		warn("%s", nfile->name);
		free(nfile->name);
		free(nfile);
		return (NULL);
	} else 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
hostapd_parse_file(struct hostapd_config *cfg)
{
	struct sym *sym, *next;
	int errors = 0;
	int ret;

	if ((file = pushfile(cfg->c_config, 1)) == NULL)
		hostapd_fatal("failed to open the main config file: %s\n",
		    cfg->c_config);
	topfile = file;

	/* Init tables and data structures */
	TAILQ_INIT(&cfg->c_apmes);
	TAILQ_INIT(&cfg->c_tables);
	TAILQ_INIT(&cfg->c_frames);
	cfg->c_iapp.i_multicast.sin_addr.s_addr = INADDR_ANY;
	cfg->c_iapp.i_flags = HOSTAPD_IAPP_F_DEFAULT;
	cfg->c_iapp.i_ttl = IP_DEFAULT_MULTICAST_TTL;
	cfg->c_apme_hopdelay.tv_sec = HOSTAPD_HOPPER_MDELAY / 1000;
	cfg->c_apme_hopdelay.tv_usec = (HOSTAPD_HOPPER_MDELAY % 1000) * 1000;

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

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

	return (errors ? EINVAL : ret);
}

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

	file->errors++;

	va_start(ap, fmt);
	if (vasprintf(&msg, fmt, ap) == -1)
		hostapd_fatal("yyerror vasprintf");
	va_end(ap);
	fprintf(stderr, "%s:%d: %s\n", file->name, yylval.lineno, msg);
	fflush(stderr);
	free(msg);

	return (0);
}
#line 1357 "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 8:
#line 186 "parse.y"
{ file->errors++; }
break;
case 9:
#line 190 "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 10:
#line 206 "parse.y"
{
			if (!TAILQ_EMPTY(&hostapd_cfg.c_apmes))
				hostapd_cfg.c_flags |= HOSTAPD_CFG_F_APME;
		}
break;
case 12:
#line 212 "parse.y"
{
			bcopy(&yyvsp[0].v.timeout, &hostapd_cfg.c_apme_hopdelay,
			    sizeof(struct timeval));
		}
break;
case 14:
#line 218 "parse.y"
{
			if (strlcpy(hostapd_cfg.c_iapp.i_iface, yyvsp[-1].v.string,
			    sizeof(hostapd_cfg.c_iapp.i_iface)) >=
			    sizeof(hostapd_cfg.c_iapp.i_iface)) {
				yyerror("invalid interface %s", yyvsp[-1].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}

			hostapd_cfg.c_flags |= HOSTAPD_CFG_F_IAPP;

			hostapd_log(HOSTAPD_LOG_DEBUG,
			    "%s: IAPP interface added", yyvsp[-1].v.string);

			free(yyvsp[-1].v.string);
		}
break;
case 16:
#line 236 "parse.y"
{
			if ((hostapd_cfg.c_iapp.i_addr_tbl =
			    hostapd_table_lookup(&hostapd_cfg, yyvsp[0].v.string)) == NULL) {
				yyerror("undefined table <%s>", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 17:
#line 246 "parse.y"
{
			if ((hostapd_cfg.c_iapp.i_route_tbl =
			    hostapd_table_lookup(&hostapd_cfg, yyvsp[0].v.string)) == NULL) {
				yyerror("undefined table <%s>", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 19:
#line 259 "parse.y"
{
			hostapd_cfg.c_flags &= ~HOSTAPD_CFG_F_BRDCAST;
		}
break;
case 20:
#line 263 "parse.y"
{
			hostapd_cfg.c_flags |= HOSTAPD_CFG_F_BRDCAST;
		}
break;
case 22:
#line 270 "parse.y"
{
			bcopy(&yyvsp[0].v.in, &hostapd_cfg.c_iapp.i_multicast.sin_addr,
			    sizeof(struct in_addr));
		}
break;
case 24:
#line 278 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > UINT16_MAX) {
				yyerror("port out of range: %lld", yyvsp[0].v.number);
				YYERROR;
			}
			hostapd_cfg.c_iapp.i_addr.sin_port = htons(yyvsp[0].v.number);
		}
break;
case 26:
#line 289 "parse.y"
{
			if (yyvsp[0].v.number < 1 || yyvsp[0].v.number > UINT8_MAX) {
				yyerror("ttl out of range: %lld", yyvsp[0].v.number);
				YYERROR;
			}
			hostapd_cfg.c_iapp.i_ttl = yyvsp[0].v.number;
		}
break;
case 27:
#line 299 "parse.y"
{
			hostapd_cfg.c_apme_dlt = DLT_IEEE802_11_RADIO;
		}
break;
case 28:
#line 303 "parse.y"
{
			hostapd_cfg.c_apme_dlt = DLT_IEEE802_11;
		}
break;
case 33:
#line 317 "parse.y"
{
			if (hostapd_apme_add(&hostapd_cfg, yyvsp[0].v.string) != 0) {
				yyerror("failed to add hostap interface");
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 38:
#line 335 "parse.y"
{
			if ((apme = hostapd_apme_addhopper(&hostapd_cfg,
			    yyvsp[0].v.string)) == NULL) {
				yyerror("failed to add hopper %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 40:
#line 348 "parse.y"
{
			if ((frame.f_apme =
			    hostapd_apme_lookup(&hostapd_cfg, yyvsp[0].v.string)) == NULL) {
				yyerror("undefined hostap interface");
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);

			HOSTAPD_MATCH(APME, yyvsp[-1].v.number);
		}
break;
case 41:
#line 362 "parse.y"
{
			bzero(&frame, sizeof(struct hostapd_frame));
			/* IEEE 802.11 frame to match */
			frame_ieee80211 = &frame.f_frame;
		}
break;
case 42:
#line 366 "parse.y"
{
			/* IEEE 802.11 raw frame to send as an action */
			frame_ieee80211 = &frame.f_action_data.a_frame;
		}
break;
case 43:
#line 369 "parse.y"
{
			if ((frame_ptr = calloc(1, sizeof(struct hostapd_frame)))
			    == NULL) {
				yyerror("calloc");
				YYERROR;
			}

			if (gettimeofday(&frame.f_last, NULL) == -1)
				hostapd_fatal("gettimeofday");
			timeradd(&frame.f_last, &frame.f_limit, &frame.f_then);

			bcopy(&frame, frame_ptr, sizeof(struct hostapd_frame));
			TAILQ_INSERT_TAIL(&hostapd_cfg.c_frames,
			    frame_ptr, f_entries);
		}
break;
case 48:
#line 395 "parse.y"
{
			HOSTAPD_IAPP_FLAG(ADD_NOTIFY, yyvsp[-2].v.number);
		}
break;
case 49:
#line 399 "parse.y"
{
			HOSTAPD_IAPP_FLAG(RADIOTAP, yyvsp[-1].v.number);
		}
break;
case 50:
#line 403 "parse.y"
{
			HOSTAPD_IAPP_FLAG(ROAMING_ROUTE, yyvsp[-2].v.number);
		}
break;
case 51:
#line 407 "parse.y"
{
			HOSTAPD_IAPP_FLAG(ROAMING_ADDRESS, yyvsp[-2].v.number);
		}
break;
case 52:
#line 413 "parse.y"
{
			frame.f_flags |= HOSTAPD_FRAME_F_RET_OK;
		}
break;
case 53:
#line 417 "parse.y"
{
			frame.f_flags |= HOSTAPD_FRAME_F_RET_QUICK;
		}
break;
case 54:
#line 421 "parse.y"
{
			frame.f_flags |= HOSTAPD_FRAME_F_RET_SKIP;
		}
break;
case 55:
#line 427 "parse.y"
{
			frame.f_action = HOSTAPD_ACTION_NONE;
		}
break;
case 56:
#line 431 "parse.y"
{
			frame.f_action = HOSTAPD_ACTION_LOG;
		}
break;
case 57:
#line 435 "parse.y"
{
			frame.f_action = HOSTAPD_ACTION_FRAME;
		}
break;
case 59:
#line 440 "parse.y"
{
			if ((yyvsp[0].v.reflladdr.flags & HOSTAPD_ACTION_F_REF_M) == 0) {
				bcopy(yyvsp[0].v.reflladdr.lladdr, frame.f_action_data.a_lladdr,
				    IEEE80211_ADDR_LEN);
			} else
				frame.f_action_data.a_flags |= yyvsp[0].v.reflladdr.flags;
		}
break;
case 60:
#line 448 "parse.y"
{
			frame.f_action = HOSTAPD_ACTION_RESEND;
		}
break;
case 62:
#line 455 "parse.y"
{
			frame.f_action_flags |= HOSTAPD_ACTION_VERBOSE;
		}
break;
case 63:
#line 461 "parse.y"
{
			frame.f_action = HOSTAPD_ACTION_RADIOTAP;
		}
break;
case 64:
#line 467 "parse.y"
{
			frame.f_action = HOSTAPD_ACTION_DELNODE;
		}
break;
case 65:
#line 471 "parse.y"
{
			frame.f_action = HOSTAPD_ACTION_ADDNODE;
		}
break;
case 72:
#line 490 "parse.y"
{
			if (yyvsp[-1].v.number < 0 || yyvsp[-1].v.number > LONG_MAX) {
				yyerror("limit out of range: %lld sec", yyvsp[-1].v.number);
				YYERROR;
			}
			frame.f_limit.tv_sec = yyvsp[-1].v.number;
		}
break;
case 73:
#line 498 "parse.y"
{
			if (yyvsp[-1].v.number < 0 || yyvsp[-1].v.number > LONG_MAX) {
				yyerror("limit out of range: %lld usec", yyvsp[-1].v.number);
				YYERROR;
			}
			frame.f_limit.tv_usec = yyvsp[-1].v.number;
		}
break;
case 75:
#line 509 "parse.y"
{
			if ((yyvsp[-3].v.number < 1 || yyvsp[-3].v.number > LONG_MAX) ||
			    (yyvsp[-1].v.number < 1 || yyvsp[-1].v.number > LONG_MAX)) {
				yyerror("rate out of range: %lld/%lld sec",
				    yyvsp[-3].v.number, yyvsp[-1].v.number);
				YYERROR;
			}

			if (!(yyvsp[-3].v.number && yyvsp[-1].v.number)) {
				yyerror("invalid rate");
				YYERROR;
			}

			frame.f_rate = yyvsp[-3].v.number;
			frame.f_rate_intval = yyvsp[-1].v.number;
		}
break;
case 78:
#line 530 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_TYPE_DATA;
			HOSTAPD_MATCH(TYPE, yyvsp[-1].v.number);
		}
break;
case 79:
#line 536 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_TYPE_MGT;
			HOSTAPD_MATCH(TYPE, yyvsp[-2].v.number);
		}
break;
case 82:
#line 546 "parse.y"
{
			HOSTAPD_MATCH(SUBTYPE, yyvsp[-1].v.number);
		}
break;
case 83:
#line 552 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_SUBTYPE_PROBE_REQ;
		}
break;
case 84:
#line 557 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_SUBTYPE_PROBE_RESP;
		}
break;
case 85:
#line 562 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_SUBTYPE_BEACON;
		}
break;
case 86:
#line 567 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_SUBTYPE_ATIM;
		}
break;
case 87:
#line 572 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_SUBTYPE_AUTH;
		}
break;
case 88:
#line 577 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_SUBTYPE_DEAUTH;
		}
break;
case 89:
#line 582 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_SUBTYPE_ASSOC_REQ;
		}
break;
case 90:
#line 587 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_SUBTYPE_DISASSOC;
		}
break;
case 91:
#line 592 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_SUBTYPE_ASSOC_RESP;
		}
break;
case 92:
#line 597 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_SUBTYPE_REASSOC_REQ;
		}
break;
case 93:
#line 602 "parse.y"
{
			frame_ieee80211->i_fc[0] |=
			    IEEE80211_FC0_SUBTYPE_REASSOC_RESP;
		}
break;
case 100:
#line 621 "parse.y"
{
			if ((frame_ieee80211->i_data = malloc(6)) == NULL) {
				yyerror("failed to allocate auth");
				YYERROR;
			}
			((u_int16_t *)frame_ieee80211->i_data)[0] =
				yyvsp[0].v.authalg.alg;
			((u_int16_t *)frame_ieee80211->i_data)[1] =
				yyvsp[0].v.authalg.transaction;
			((u_int16_t *)frame_ieee80211->i_data)[0] = 0;
			frame_ieee80211->i_data_len = 6;
		}
break;
case 101:
#line 636 "parse.y"
{
			yyval.v.authalg.alg = htole16(IEEE80211_AUTH_ALG_OPEN);
			yyval.v.authalg.transaction = htole16(IEEE80211_AUTH_OPEN_REQUEST);
		}
break;
case 102:
#line 641 "parse.y"
{
			yyval.v.authalg.alg = htole16(IEEE80211_AUTH_ALG_OPEN);
			yyval.v.authalg.transaction = htole16(IEEE80211_AUTH_OPEN_RESPONSE);
		}
break;
case 103:
#line 648 "parse.y"
{
			if (yyvsp[0].v.reason != 0) {
				if ((frame_ieee80211->i_data =
				    malloc(sizeof(u_int16_t))) == NULL) {
					yyerror("failed to allocate "
					    "reason code %u", yyvsp[0].v.reason);
					YYERROR;
				}
				*(u_int16_t *)frame_ieee80211->i_data =
				    htole16(yyvsp[0].v.reason);
				frame_ieee80211->i_data_len = sizeof(u_int16_t);
			}
		}
break;
case 104:
#line 664 "parse.y"
{
			yyval.v.reason = 0;
		}
break;
case 105:
#line 668 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_UNSPECIFIED;
		}
break;
case 106:
#line 672 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_AUTH_EXPIRE;
		}
break;
case 107:
#line 676 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_AUTH_LEAVE;
		}
break;
case 108:
#line 680 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_ASSOC_EXPIRE;
		}
break;
case 109:
#line 684 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_ASSOC_TOOMANY;
		}
break;
case 110:
#line 688 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_NOT_AUTHED;
		}
break;
case 111:
#line 692 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_NOT_ASSOCED;
		}
break;
case 112:
#line 696 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_ASSOC_LEAVE;
		}
break;
case 113:
#line 700 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_NOT_AUTHED;
		}
break;
case 114:
#line 704 "parse.y"
{
			yyval.v.reason = 10;	/* XXX unknown */
		}
break;
case 115:
#line 708 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_RSN_REQUIRED;
		}
break;
case 116:
#line 712 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_RSN_INCONSISTENT;
		}
break;
case 117:
#line 716 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_IE_INVALID;
		}
break;
case 118:
#line 720 "parse.y"
{
			yyval.v.reason = IEEE80211_REASON_MIC_FAILURE;
		}
break;
case 121:
#line 728 "parse.y"
{
			HOSTAPD_MATCH(DIR, yyvsp[-1].v.number);
		}
break;
case 122:
#line 734 "parse.y"
{
			frame_ieee80211->i_fc[1] |= IEEE80211_FC1_DIR_NODS;
		}
break;
case 123:
#line 738 "parse.y"
{
			frame_ieee80211->i_fc[1] |= IEEE80211_FC1_DIR_TODS;
		}
break;
case 124:
#line 742 "parse.y"
{
			frame_ieee80211->i_fc[1] |= IEEE80211_FC1_DIR_FROMDS;
		}
break;
case 125:
#line 746 "parse.y"
{
			frame_ieee80211->i_fc[1] |= IEEE80211_FC1_DIR_DSTODS;
		}
break;
case 128:
#line 754 "parse.y"
{
			if ((yyvsp[0].v.reflladdr.flags & HOSTAPD_ACTION_F_OPT_TABLE) == 0) {
				bcopy(yyvsp[0].v.reflladdr.lladdr, &frame_ieee80211->i_from,
				    IEEE80211_ADDR_LEN);
				HOSTAPD_MATCH(FROM, yyvsp[-1].v.number);
			} else {
				frame.f_from = yyvsp[0].v.reflladdr.table;
				HOSTAPD_MATCH_TABLE(FROM, yyvsp[-1].v.number);
			}
		}
break;
case 131:
#line 769 "parse.y"
{
			if ((yyvsp[0].v.reflladdr.flags & HOSTAPD_ACTION_F_OPT_TABLE) == 0) {
				bcopy(yyvsp[0].v.reflladdr.lladdr, &frame_ieee80211->i_to,
				    IEEE80211_ADDR_LEN);
				HOSTAPD_MATCH(TO, yyvsp[-1].v.number);
			} else {
				frame.f_to = yyvsp[0].v.reflladdr.table;
				HOSTAPD_MATCH_TABLE(TO, yyvsp[-1].v.number);
			}
		}
break;
case 134:
#line 784 "parse.y"
{
			if ((yyvsp[0].v.reflladdr.flags & HOSTAPD_ACTION_F_OPT_TABLE) == 0) {
				bcopy(yyvsp[0].v.reflladdr.lladdr, &frame_ieee80211->i_bssid,
				    IEEE80211_ADDR_LEN);
				HOSTAPD_MATCH(BSSID, yyvsp[-1].v.number);
			} else {
				frame.f_bssid = yyvsp[0].v.reflladdr.table;
				HOSTAPD_MATCH_TABLE(BSSID, yyvsp[-1].v.number);
			}
		}
break;
case 139:
#line 805 "parse.y"
{
			if ((yyvsp[-1].v.op == HOSTAPD_OP_GT && yyvsp[0].v.number == 100) ||
			    (yyvsp[-1].v.op == HOSTAPD_OP_LE && yyvsp[0].v.number == 100) ||
			    (yyvsp[-1].v.op == HOSTAPD_OP_LT && yyvsp[0].v.number == 0) ||
			    (yyvsp[-1].v.op == HOSTAPD_OP_GE && yyvsp[0].v.number == 0)) {
				yyerror("absurd unary comparison");
				YYERROR;
			}

			frame.f_rssi_op = yyvsp[-1].v.op;
			frame.f_rssi = yyvsp[0].v.number;
			HOSTAPD_MATCH_RADIOTAP(RSSI);
		}
break;
case 140:
#line 819 "parse.y"
{
			frame.f_txrate_op = yyvsp[-1].v.op;
			frame.f_txrate = yyvsp[0].v.number;
			HOSTAPD_MATCH_RADIOTAP(RATE);
		}
break;
case 141:
#line 825 "parse.y"
{
			frame.f_chan_op = yyvsp[-1].v.op;
			frame.f_chan = yyvsp[0].v.number;
			HOSTAPD_MATCH_RADIOTAP(CHANNEL);
		}
break;
case 142:
#line 833 "parse.y"
{
			if ((yyval.v.reflladdr.table =
			    hostapd_table_lookup(&hostapd_cfg, yyvsp[0].v.string)) == NULL) {
				yyerror("undefined table <%s>", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			yyval.v.reflladdr.flags = HOSTAPD_ACTION_F_OPT_TABLE;
			free(yyvsp[0].v.string);
		}
break;
case 143:
#line 844 "parse.y"
{
			bcopy(yyvsp[0].v.reflladdr.lladdr, yyval.v.reflladdr.lladdr, IEEE80211_ADDR_LEN);
			yyval.v.reflladdr.flags = HOSTAPD_ACTION_F_OPT_LLADDR;
		}
break;
case 144:
#line 851 "parse.y"
{
			frame_ieee80211->i_fc[0] |= IEEE80211_FC0_TYPE_DATA;
		}
break;
case 145:
#line 855 "parse.y"
{
			frame_ieee80211->i_fc[0] |= IEEE80211_FC0_TYPE_MGT;
		}
break;
case 147:
#line 864 "parse.y"
{
			frame.f_action_data.a_flags |=
			    HOSTAPD_ACTION_F_OPT_DIR_AUTO;
		}
break;
case 149:
#line 872 "parse.y"
{
			if ((yyvsp[0].v.reflladdr.flags & HOSTAPD_ACTION_F_REF_M) == 0) {
				bcopy(yyvsp[0].v.reflladdr.lladdr, frame_ieee80211->i_from,
				    IEEE80211_ADDR_LEN);
			} else
				frame.f_action_data.a_flags |=
				    (yyvsp[0].v.reflladdr.flags << HOSTAPD_ACTION_F_REF_FROM_S);
		}
break;
case 150:
#line 883 "parse.y"
{
			if ((yyvsp[0].v.reflladdr.flags & HOSTAPD_ACTION_F_REF_M) == 0) {
				bcopy(yyvsp[0].v.reflladdr.lladdr, frame_ieee80211->i_to,
				    IEEE80211_ADDR_LEN);
			} else
				frame.f_action_data.a_flags |=
				    (yyvsp[0].v.reflladdr.flags << HOSTAPD_ACTION_F_REF_TO_S);
		}
break;
case 151:
#line 894 "parse.y"
{
			if ((yyvsp[0].v.reflladdr.flags & HOSTAPD_ACTION_F_REF_M) == 0) {
				bcopy(yyvsp[0].v.reflladdr.lladdr, frame_ieee80211->i_bssid,
				    IEEE80211_ADDR_LEN);
			} else
				frame.f_action_data.a_flags |=
				    (yyvsp[0].v.reflladdr.flags << HOSTAPD_ACTION_F_REF_BSSID_S);
		}
break;
case 152:
#line 905 "parse.y"
{
			bcopy(yyvsp[0].v.reflladdr.lladdr, yyval.v.reflladdr.lladdr, IEEE80211_ADDR_LEN);
			yyval.v.reflladdr.flags = yyvsp[0].v.reflladdr.flags;
		}
break;
case 153:
#line 910 "parse.y"
{
			yyval.v.reflladdr.flags = yyvsp[0].v.reflladdr.flags;
		}
break;
case 154:
#line 914 "parse.y"
{
			yyval.v.reflladdr.flags = yyvsp[0].v.reflladdr.flags;
		}
break;
case 155:
#line 919 "parse.y"
{
			if (strlen(yyvsp[-1].v.string) >= HOSTAPD_TABLE_NAMELEN) {
				yyerror("table name %s too long, max %u",
				    yyvsp[-1].v.string, HOSTAPD_TABLE_NAMELEN - 1);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			yyval.v.string = yyvsp[-1].v.string;
		}
break;
case 156:
#line 930 "parse.y"
{
			if ((table =
			    hostapd_table_add(&hostapd_cfg, yyvsp[0].v.string)) == NULL) {
				yyerror("failed to add table: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 157:
#line 938 "parse.y"
{
			table = NULL;
		}
break;
case 162:
#line 951 "parse.y"
{
			if (table->t_flags & HOSTAPD_TABLE_F_CONST) {
				yyerror("option already specified");
				YYERROR;
			}
			table->t_flags |= HOSTAPD_TABLE_F_CONST;
		}
break;
case 165:
#line 963 "parse.y"
{
			if (asprintf(&yyval.v.string, "%s %s", yyvsp[-1].v.string, yyvsp[0].v.string) == -1)
				hostapd_fatal("string: asprintf");
			free(yyvsp[-1].v.string);
			free(yyvsp[0].v.string);
		}
break;
case 167:
#line 973 "parse.y"
{
			char *s = yyvsp[-2].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)
				hostapd_fatal("cannot store variable");
			free(yyvsp[-2].v.string);
			free(yyvsp[0].v.string);
		}
break;
case 168:
#line 990 "parse.y"
{
			yyval.v.reflladdr.flags |= HOSTAPD_ACTION_F_REF_FROM;
		}
break;
case 169:
#line 994 "parse.y"
{
			yyval.v.reflladdr.flags |= HOSTAPD_ACTION_F_REF_TO;
		}
break;
case 170:
#line 998 "parse.y"
{
			yyval.v.reflladdr.flags |= HOSTAPD_ACTION_F_REF_BSSID;
		}
break;
case 173:
#line 1008 "parse.y"
{
			if ((entry = hostapd_entry_add(table,
			    yyvsp[0].v.reflladdr.lladdr)) == NULL) {
				yyerror("failed to add entry: %s",
				    etheraddr_string(yyvsp[0].v.reflladdr.lladdr));
				YYERROR;
			}
		}
break;
case 174:
#line 1015 "parse.y"
{
			entry = NULL;
		}
break;
case 176:
#line 1022 "parse.y"
{
			entry->e_flags |= HOSTAPD_ENTRY_F_INADDR;
			entry->e_inaddr.in_af = AF_INET;
			bcopy(&yyvsp[-1].v.in, &entry->e_inaddr.in_v4,
			    sizeof(struct in_addr));
		}
break;
case 177:
#line 1029 "parse.y"
{
			entry->e_flags |= HOSTAPD_ENTRY_F_MASK;
			bcopy(yyvsp[0].v.reflladdr.lladdr, entry->e_mask, IEEE80211_ADDR_LEN);

			/* Update entry position in the table */
			hostapd_entry_update(table, entry);
		}
break;
case 178:
#line 1039 "parse.y"
{
			if (inet_net_pton(AF_INET, yyvsp[0].v.string, &yyval.v.in, sizeof(yyval.v.in)) == -1) {
				yyerror("invalid address: %s\n", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 179:
#line 1050 "parse.y"
{
			entry->e_inaddr.in_netmask = -1;
		}
break;
case 180:
#line 1054 "parse.y"
{
			if (yyvsp[0].v.number < 0 || yyvsp[0].v.number > 32) {
				yyerror("netmask out of range: %lld", yyvsp[0].v.number);
				YYERROR;
			}
			entry->e_inaddr.in_netmask = yyvsp[0].v.number;
		}
break;
case 181:
#line 1064 "parse.y"
{
			struct ether_addr *ea;

			if ((ea = ether_aton(yyvsp[0].v.string)) == NULL) {
				yyerror("invalid address: %s\n", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);

			bcopy(ea, yyval.v.reflladdr.lladdr, IEEE80211_ADDR_LEN);
			yyval.v.reflladdr.flags = HOSTAPD_ACTION_F_OPT_LLADDR;
		}
break;
case 182:
#line 1080 "parse.y"
{
			yyval.v.reflladdr.flags |= HOSTAPD_ACTION_F_REF_RANDOM;
		}
break;
case 184:
#line 1087 "parse.y"
{
			hostapd_cfg.c_flags |= HOSTAPD_CFG_F_IAPP_PASSIVE;
		}
break;
case 191:
#line 1107 "parse.y"
{
			yyval.v.number = 0;
		}
break;
case 192:
#line 1111 "parse.y"
{
			yyval.v.number = 1;
		}
break;
case 193:
#line 1115 "parse.y"
{
			yyval.v.number = 1;
		}
break;
case 194:
#line 1121 "parse.y"
{
			yyval.v.op = HOSTAPD_OP_EQ;
		}
break;
case 195:
#line 1125 "parse.y"
{
			yyval.v.op = HOSTAPD_OP_EQ;
		}
break;
case 196:
#line 1129 "parse.y"
{
			yyval.v.op = HOSTAPD_OP_EQ;
		}
break;
case 197:
#line 1133 "parse.y"
{
			yyval.v.op = HOSTAPD_OP_NE;
		}
break;
case 198:
#line 1137 "parse.y"
{
			yyval.v.op = HOSTAPD_OP_NE;
		}
break;
case 199:
#line 1141 "parse.y"
{
			yyval.v.op = HOSTAPD_OP_LE;
		}
break;
case 200:
#line 1145 "parse.y"
{
			yyval.v.op = HOSTAPD_OP_LT;
		}
break;
case 201:
#line 1149 "parse.y"
{
			yyval.v.op = HOSTAPD_OP_GE;
		}
break;
case 202:
#line 1153 "parse.y"
{
			yyval.v.op = HOSTAPD_OP_GT;
		}
break;
case 203:
#line 1159 "parse.y"
{
			double val;
			char *cp;

			val = strtod(yyvsp[0].v.string, &cp);
			if (cp == NULL || strcmp(cp, "%") != 0 ||
			    val < 0 || val > 100) {
				yyerror("invalid percentage: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			yyval.v.number = val;
		}
break;
case 204:
#line 1176 "parse.y"
{
			double val;
			char *cp;

			val = strtod(yyvsp[0].v.string, &cp) * 2;
			if (cp == NULL || strcasecmp(cp, "mb") != 0 ||
			    val != (int)val) {
				yyerror("invalid rate: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			yyval.v.number = val;
		}
break;
case 205:
#line 1193 "parse.y"
{
			double val;
			char *cp;

			val = strtod(yyvsp[0].v.string, &cp);
			if (cp != NULL) {
				if (strcasecmp(cp, "ghz") == 0) {
					yyval.v.number = val * 1000;
				} else if (strcasecmp(cp, "mhz") == 0) {
					yyval.v.number = val;
				} else
					cp = NULL;
			}
			if (cp == NULL) {
				yyerror("invalid frequency: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 206:
#line 1216 "parse.y"
{
			if (yyvsp[0].v.number < 1 || yyvsp[0].v.number > LONG_MAX) {
				yyerror("timeout out of range: %lld", yyvsp[0].v.number);
				YYERROR;
			}
			yyval.v.timeout.tv_sec = yyvsp[0].v.number / 1000;
			yyval.v.timeout.tv_usec = (yyvsp[0].v.number % 1000) * 1000;
		}
break;
#line 2629 "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)