From 8c923f4a1b3d4f980b619692566630ff8ebb3749 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Motiejus=20Jak=C5=A1tys?= Date: Thu, 10 Oct 2024 11:01:53 -0400 Subject: [PATCH] build.zig --- .gitignore | 6 +- README.md | 8 + build.zig | 119 +++ build.zig.zon | 81 ++ cfg_file.c | 2406 ++++++++++++++++++++++++++++++++++++++++++++++++ cfg_file.lex.c | 1997 ++++++++++++++++++++++++++++++++++++++++ cfg_file.tab.h | 163 ++++ lfd_shaper.c | 1 + lib.c | 1 + lib.h | 1 + lock.c | 2 +- 11 files changed, 4781 insertions(+), 4 deletions(-) create mode 100644 build.zig create mode 100644 build.zig.zon create mode 100644 cfg_file.c create mode 100644 cfg_file.lex.c create mode 100644 cfg_file.tab.h diff --git a/.gitignore b/.gitignore index bf3fb25..40ff865 100644 --- a/.gitignore +++ b/.gitignore @@ -2,9 +2,9 @@ *~ Makefile autom4te.cache -cfg_file.lex.c -cfg_file.tab.c -cfg_file.tab.h +#cfg_file.lex.c +#cfg_file.tab.c +#cfg_file.tab.h config.guess config.h config.h.in diff --git a/README.md b/README.md index c1d3efa..34d57a0 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,11 @@ +This is a fork of [Frank's VTUN](https://github.com/jedisct1/vtun) with the +following changes: + +* `zig build` support, currently tested only on Linux. + +Original README +--------------- + This is a fork of [VTUN](http://vtun.sourceforge.net/), with the following changes: diff --git a/build.zig b/build.zig new file mode 100644 index 0000000..625a35e --- /dev/null +++ b/build.zig @@ -0,0 +1,119 @@ +const std = @import("std"); + +pub fn build(b: *std.Build) void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + + const libsodium_dep = b.dependency( + "libsodium", + .{ + .target = target, + .optimize = optimize, + .static = true, + .shared = false, + }, + ); + + const exe = b.addExecutable(.{ + .name = "vtund", + .target = target, + .optimize = optimize, + }); + + exe.linkLibrary(libsodium_dep.artifact("sodium")); + exe.linkLibC(); + exe.addCSourceFiles(.{ + .files = &.{ + "auth.c", + "client.c", + //"freebsd/tun_dev.c", + "generic/pipe_dev.c", + "generic/pty_dev.c", + //"generic/tap_dev.c", + "generic/tcp_proto.c", + //"generic/tun_dev.c", + "generic/udp_proto.c", + "lfd_encrypt.c", + "lfd_lzo.c", + "lfd_shaper.c", + "lfd_zlib.c", + "lib.c", + "linkfd.c", + "linux/tap_dev.c", + "linux/tun_dev.c", + "llist.c", + "lock.c", + "main.c", + "netlib.c", + //"openbsd/tun_dev.c", + "server.c", + //"svr4/tap_dev.c", + //"svr4/tun_dev.c", + "tunnel.c", + + "cfg_file.c", + "cfg_file.lex.c", + }, + .flags = &.{ + "-D_GNU_SOURCE", + "-fstack-protector-all", + "-fno-strict-overflow", + "-fno-strict-aliasing", + }, + }); + + exe.addConfigHeader(b.addConfigHeader(.{ + .include_path = "config.h", + }, .{ + .VTUN_CONFIG_FILE = "/etc/vtund.conf", + .VTUN_PID_FILE = "/var/run/vtund.pid", + .VTUN_STAT_DIR = "/var/log/vtund", + .VTUN_LOCK_DIR = "/var/lock/vtund", + + .ENABLE_NAT_HACK = 0, + .HAVE_ARPA_INET_H = 1, + .HAVE_FORK = 1, + + //.HAVE_GETPT = 1, // pty tunnels + //.HAVE_GRANTPT = 1, // pty tunnels + + .HAVE_INTTYPES_H = 1, + .HAVE_LINUX_IF_TUN_H = 1, + .HAVE_NETDB_H = 1, + .HAVE_NETINET_IN_H = 1, + .HAVE_NETINET_IN_SYSTM_H = 1, + .HAVE_NETINET_IP_H = 1, + .HAVE_NETINET_TCP_H = 1, + //.HAVE_PTSNAME = 1, // pty tunnels + .HAVE_RESOLV_H = 1, + .HAVE_SCHED_H = 1, + .HAVE_SHAPER = 1, + .HAVE_SODIUM = 1, + .HAVE_STDINT_H = 1, + .HAVE_STDIO_H = 1, + .HAVE_STDLIB_H = 1, + .HAVE_STRINGS_H = 1, + .HAVE_STRING_H = 1, + .HAVE_SYS_RESOURCE_H = 1, + .HAVE_SYS_STAT_H = 1, + .HAVE_SYS_TYPES_H = 1, + .HAVE_UNISTD_H = 1, + //.HAVE_UNLOCKPT = 1, // pty tunnels + .HAVE_VFORK = 1, + .HAVE_WORKING_FORK = 1, + .HAVE_WORKING_VFORK = 1, + .PACKAGE_BUGREPORT = "", + .PACKAGE_NAME = "vtun", + .PACKAGE_STRING = "vtun = 3", + .PACKAGE_TARNAME = "vtun", + .PACKAGE_URL = "", + .PACKAGE_VERSION = "3", + .STDC_HEADERS = 1, + .VTUN_VER = "3.X = 10/10/2024", + .YYTEXT_POINTER = 1, + })); + + exe.addIncludePath(b.path(".")); + + b.installArtifact(exe); +} diff --git a/build.zig.zon b/build.zig.zon new file mode 100644 index 0000000..aa161d6 --- /dev/null +++ b/build.zig.zon @@ -0,0 +1,81 @@ +.{ + .name = "vtun", + .version = "1.1.0", + .minimum_zig_version = "0.12.0", + .dependencies = .{ + .libsodium = .{ + .url = "git+https://github.com/jedisct1/libsodium.git?ref=1.0.20-RELEASE#9511c982fb1d046470a8b42aa36556cdb7da15de", + .hash = "1220d265dc673167ffe4a3cefe2840893d2910cfd773cfb1893ff768d5f1351d2a1f", + }, + }, + .paths = .{ + "build.zig", + "build.zig.zon", + + ".cvsignore", + ".gitignore", + "ChangeLog", + "Credits", + "Makefile.in", + "README", + "README.md", + "TODO", + "aclocal.m4", + "auth.c", + "auth.h", + "autogen.sh", + "build.zig", + "cfg_file.l", + "cfg_file.y", + "cfg_kwords.h", + "client.c", + "compat.h", + "configure.ac", + "driver.h", + "freebsd/tun_dev.c", + "generic/pipe_dev.c", + "generic/pty_dev.c", + "generic/tap_dev.c", + "generic/tcp_proto.c", + "generic/tun_dev.c", + "generic/udp_proto.c", + "lfd_encrypt.c", + "lfd_lzo.c", + "lfd_shaper.c", + "lfd_zlib.c", + "lib.c", + "lib.h", + "linkfd.c", + "linkfd.h", + "linux/tap_dev.c", + "linux/tun_dev.c", + "llist.c", + "llist.h", + "lock.c", + "lock.h", + "main.c", + "netlib.c", + "netlib.h", + "openbsd/tun_dev.c", + "packages/vtun.bsd.pkg", + "packages/vtun.solaris.info", + "packages/vtun.spec", + "scripts/reroute", + "scripts/vtund.rc.debian", + "server.c", + "svr4/tap_dev.c", + "svr4/tun_dev.c", + "tunnel.c", + "vtun.drivers", + "vtun.h", + "vtun_socks.h", + "vtund.8", + "vtund.conf", + "vtund.conf.5", + + // generated + "cfg_file.c", + "cfg_file.lex.c", + "cfg_file.tab.h", + }, +} diff --git a/cfg_file.c b/cfg_file.c new file mode 100644 index 0000000..24e7e75 --- /dev/null +++ b/cfg_file.c @@ -0,0 +1,2406 @@ +/* A Bison parser, made by GNU Bison 3.8.2. */ + +/* Bison implementation for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, + Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, + especially those whose name start with YY_ or yy_. They are + private implementation details that can be changed or removed. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output, and Bison version. */ +#define YYBISON 30802 + +/* Bison version string. */ +#define YYBISON_VERSION "3.8.2" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + + + + +/* First part of user prologue. */ +#line 1 "cfg_file.y" + +/* + VTun - Virtual Tunnel over TCP/IP network. + + Copyright (C) 1998-2008 Maxim Krasnyansky + + VTun has been derived from VPPP package by Maxim Krasnyansky. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + */ + +/* + * $Id: cfg_file.y,v 1.8.2.7 2013/07/07 20:36:33 mtbishop Exp $ + */ + +#include "config.h" + +#include +#include +#include +#include + +#include +#include + +#include "compat.h" +#include "vtun.h" +#include "lib.h" + +int lineno = 1; + +struct vtun_host *parse_host; +extern struct vtun_host default_host; + +llist *parse_cmds; +struct vtun_cmd parse_cmd; + +llist host_list; + +int cfg_error(const char *fmt, ...); +int add_cmd(llist *cmds, char *prog, char *args, int flags); +void *cp_cmd(void *d, void *u); +int free_cmd(void *d, void *u); + +void copy_addr(struct vtun_host *to, struct vtun_host *from); +int free_host(void *d, void *u); +void free_addr(struct vtun_host *h); +void free_host_list(void); + +int parse_syslog(char *facility); + +int yyparse(void); +int yylex(void); +int yyerror(char *s); + +#define YYERROR_VERBOSE 1 + + +#line 138 "y.tab.c" + +# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) +# else +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif +# ifndef YY_NULLPTR +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# else +# define YY_NULLPTR ((void*)0) +# endif +# endif + + +/* Debug traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif +#if YYDEBUG +extern int yydebug; +#endif + +/* Token kinds. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + enum yytokentype + { + YYEMPTY = -2, + YYEOF = 0, /* "end of file" */ + YYerror = 256, /* error */ + YYUNDEF = 257, /* "invalid token" */ + K_OPTIONS = 258, /* K_OPTIONS */ + K_DEFAULT = 259, /* K_DEFAULT */ + K_PORT = 260, /* K_PORT */ + K_BINDADDR = 261, /* K_BINDADDR */ + K_PERSIST = 262, /* K_PERSIST */ + K_TIMEOUT = 263, /* K_TIMEOUT */ + K_PASSWD = 264, /* K_PASSWD */ + K_PROG = 265, /* K_PROG */ + K_PPP = 266, /* K_PPP */ + K_SPEED = 267, /* K_SPEED */ + K_IFCFG = 268, /* K_IFCFG */ + K_FWALL = 269, /* K_FWALL */ + K_ROUTE = 270, /* K_ROUTE */ + K_DEVICE = 271, /* K_DEVICE */ + K_MULTI = 272, /* K_MULTI */ + K_SRCADDR = 273, /* K_SRCADDR */ + K_IFACE = 274, /* K_IFACE */ + K_ADDR = 275, /* K_ADDR */ + K_TYPE = 276, /* K_TYPE */ + K_PROT = 277, /* K_PROT */ + K_NAT_HACK = 278, /* K_NAT_HACK */ + K_COMPRESS = 279, /* K_COMPRESS */ + K_ENCRYPT = 280, /* K_ENCRYPT */ + K_KALIVE = 281, /* K_KALIVE */ + K_STAT = 282, /* K_STAT */ + K_UP = 283, /* K_UP */ + K_DOWN = 284, /* K_DOWN */ + K_SYSLOG = 285, /* K_SYSLOG */ + K_IPROUTE = 286, /* K_IPROUTE */ + K_HOST = 287, /* K_HOST */ + K_ERROR = 288, /* K_ERROR */ + WORD = 289, /* WORD */ + PATH = 290, /* PATH */ + STRING = 291, /* STRING */ + NUM = 292, /* NUM */ + DNUM = 293 /* DNUM */ + }; + typedef enum yytokentype yytoken_kind_t; +#endif +/* Token kinds. */ +#define YYEMPTY -2 +#define YYEOF 0 +#define YYerror 256 +#define YYUNDEF 257 +#define K_OPTIONS 258 +#define K_DEFAULT 259 +#define K_PORT 260 +#define K_BINDADDR 261 +#define K_PERSIST 262 +#define K_TIMEOUT 263 +#define K_PASSWD 264 +#define K_PROG 265 +#define K_PPP 266 +#define K_SPEED 267 +#define K_IFCFG 268 +#define K_FWALL 269 +#define K_ROUTE 270 +#define K_DEVICE 271 +#define K_MULTI 272 +#define K_SRCADDR 273 +#define K_IFACE 274 +#define K_ADDR 275 +#define K_TYPE 276 +#define K_PROT 277 +#define K_NAT_HACK 278 +#define K_COMPRESS 279 +#define K_ENCRYPT 280 +#define K_KALIVE 281 +#define K_STAT 282 +#define K_UP 283 +#define K_DOWN 284 +#define K_SYSLOG 285 +#define K_IPROUTE 286 +#define K_HOST 287 +#define K_ERROR 288 +#define WORD 289 +#define PATH 290 +#define STRING 291 +#define NUM 292 +#define DNUM 293 + +/* Value type. */ +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +union YYSTYPE +{ +#line 68 "cfg_file.y" + + char *str; + int num; + struct { int num1; int num2; } dnum; + +#line 270 "y.tab.c" + +}; +typedef union YYSTYPE YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define YYSTYPE_IS_DECLARED 1 +#endif + + +extern YYSTYPE yylval; + + +int yyparse (void); + + + +/* Symbol kind. */ +enum yysymbol_kind_t +{ + YYSYMBOL_YYEMPTY = -2, + YYSYMBOL_YYEOF = 0, /* "end of file" */ + YYSYMBOL_YYerror = 1, /* error */ + YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ + YYSYMBOL_K_OPTIONS = 3, /* K_OPTIONS */ + YYSYMBOL_K_DEFAULT = 4, /* K_DEFAULT */ + YYSYMBOL_K_PORT = 5, /* K_PORT */ + YYSYMBOL_K_BINDADDR = 6, /* K_BINDADDR */ + YYSYMBOL_K_PERSIST = 7, /* K_PERSIST */ + YYSYMBOL_K_TIMEOUT = 8, /* K_TIMEOUT */ + YYSYMBOL_K_PASSWD = 9, /* K_PASSWD */ + YYSYMBOL_K_PROG = 10, /* K_PROG */ + YYSYMBOL_K_PPP = 11, /* K_PPP */ + YYSYMBOL_K_SPEED = 12, /* K_SPEED */ + YYSYMBOL_K_IFCFG = 13, /* K_IFCFG */ + YYSYMBOL_K_FWALL = 14, /* K_FWALL */ + YYSYMBOL_K_ROUTE = 15, /* K_ROUTE */ + YYSYMBOL_K_DEVICE = 16, /* K_DEVICE */ + YYSYMBOL_K_MULTI = 17, /* K_MULTI */ + YYSYMBOL_K_SRCADDR = 18, /* K_SRCADDR */ + YYSYMBOL_K_IFACE = 19, /* K_IFACE */ + YYSYMBOL_K_ADDR = 20, /* K_ADDR */ + YYSYMBOL_K_TYPE = 21, /* K_TYPE */ + YYSYMBOL_K_PROT = 22, /* K_PROT */ + YYSYMBOL_K_NAT_HACK = 23, /* K_NAT_HACK */ + YYSYMBOL_K_COMPRESS = 24, /* K_COMPRESS */ + YYSYMBOL_K_ENCRYPT = 25, /* K_ENCRYPT */ + YYSYMBOL_K_KALIVE = 26, /* K_KALIVE */ + YYSYMBOL_K_STAT = 27, /* K_STAT */ + YYSYMBOL_K_UP = 28, /* K_UP */ + YYSYMBOL_K_DOWN = 29, /* K_DOWN */ + YYSYMBOL_K_SYSLOG = 30, /* K_SYSLOG */ + YYSYMBOL_K_IPROUTE = 31, /* K_IPROUTE */ + YYSYMBOL_K_HOST = 32, /* K_HOST */ + YYSYMBOL_K_ERROR = 33, /* K_ERROR */ + YYSYMBOL_WORD = 34, /* WORD */ + YYSYMBOL_PATH = 35, /* PATH */ + YYSYMBOL_STRING = 36, /* STRING */ + YYSYMBOL_NUM = 37, /* NUM */ + YYSYMBOL_DNUM = 38, /* DNUM */ + YYSYMBOL_39_n_ = 39, /* '\n' */ + YYSYMBOL_40_ = 40, /* '{' */ + YYSYMBOL_41_ = 41, /* '}' */ + YYSYMBOL_YYACCEPT = 42, /* $accept */ + YYSYMBOL_config = 43, /* config */ + YYSYMBOL_statement = 44, /* statement */ + YYSYMBOL_45_1 = 45, /* $@1 */ + YYSYMBOL_46_2 = 46, /* $@2 */ + YYSYMBOL_options = 47, /* options */ + YYSYMBOL_option = 48, /* option */ + YYSYMBOL_bindaddr_option = 49, /* bindaddr_option */ + YYSYMBOL_syslog_opt = 50, /* syslog_opt */ + YYSYMBOL_host_options = 51, /* host_options */ + YYSYMBOL_host_option = 52, /* host_option */ + YYSYMBOL_53_3 = 53, /* $@3 */ + YYSYMBOL_54_4 = 54, /* $@4 */ + YYSYMBOL_55_5 = 55, /* $@5 */ + YYSYMBOL_56_6 = 56, /* $@6 */ + YYSYMBOL_compress = 57, /* compress */ + YYSYMBOL_keepalive = 58, /* keepalive */ + YYSYMBOL_srcaddr_options = 59, /* srcaddr_options */ + YYSYMBOL_srcaddr_option = 60, /* srcaddr_option */ + YYSYMBOL_command_options = 61, /* command_options */ + YYSYMBOL_command_option = 62, /* command_option */ + YYSYMBOL_63_7 = 63, /* $@7 */ + YYSYMBOL_prog_options = 64, /* prog_options */ + YYSYMBOL_prog_option = 65 /* prog_option */ +}; +typedef enum yysymbol_kind_t yysymbol_kind_t; + + + + +#ifdef short +# undef short +#endif + +/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure + and (if available) are included + so that the code can choose integer types of a good width. */ + +#ifndef __PTRDIFF_MAX__ +# include /* INFRINGES ON USER NAME SPACE */ +# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_STDINT_H +# endif +#endif + +/* Narrow types that promote to a signed type and that can represent a + signed or unsigned integer of at least N bits. In tables they can + save space and decrease cache pressure. Promoting to a signed type + helps avoid bugs in integer arithmetic. */ + +#ifdef __INT_LEAST8_MAX__ +typedef __INT_LEAST8_TYPE__ yytype_int8; +#elif defined YY_STDINT_H +typedef int_least8_t yytype_int8; +#else +typedef signed char yytype_int8; +#endif + +#ifdef __INT_LEAST16_MAX__ +typedef __INT_LEAST16_TYPE__ yytype_int16; +#elif defined YY_STDINT_H +typedef int_least16_t yytype_int16; +#else +typedef short yytype_int16; +#endif + +/* Work around bug in HP-UX 11.23, which defines these macros + incorrectly for preprocessor constants. This workaround can likely + be removed in 2023, as HPE has promised support for HP-UX 11.23 + (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of + . */ +#ifdef __hpux +# undef UINT_LEAST8_MAX +# undef UINT_LEAST16_MAX +# define UINT_LEAST8_MAX 255 +# define UINT_LEAST16_MAX 65535 +#endif + +#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST8_TYPE__ yytype_uint8; +#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST8_MAX <= INT_MAX) +typedef uint_least8_t yytype_uint8; +#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX +typedef unsigned char yytype_uint8; +#else +typedef short yytype_uint8; +#endif + +#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST16_TYPE__ yytype_uint16; +#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST16_MAX <= INT_MAX) +typedef uint_least16_t yytype_uint16; +#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX +typedef unsigned short yytype_uint16; +#else +typedef int yytype_uint16; +#endif + +#ifndef YYPTRDIFF_T +# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ +# define YYPTRDIFF_T __PTRDIFF_TYPE__ +# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ +# elif defined PTRDIFF_MAX +# ifndef ptrdiff_t +# include /* INFRINGES ON USER NAME SPACE */ +# endif +# define YYPTRDIFF_T ptrdiff_t +# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX +# else +# define YYPTRDIFF_T long +# define YYPTRDIFF_MAXIMUM LONG_MAX +# endif +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned +# endif +#endif + +#define YYSIZE_MAXIMUM \ + YY_CAST (YYPTRDIFF_T, \ + (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ + ? YYPTRDIFF_MAXIMUM \ + : YY_CAST (YYSIZE_T, -1))) + +#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) + + +/* Stored state numbers (used for stacks). */ +typedef yytype_uint8 yy_state_t; + +/* State numbers in computations. */ +typedef int yy_state_fast_t; + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif + + +#ifndef YY_ATTRIBUTE_PURE +# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) +# else +# define YY_ATTRIBUTE_PURE +# endif +#endif + +#ifndef YY_ATTRIBUTE_UNUSED +# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +# else +# define YY_ATTRIBUTE_UNUSED +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YY_USE(E) ((void) (E)) +#else +# define YY_USE(E) /* empty */ +#endif + +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") +# else +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# endif +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_INITIAL_VALUE(Value) Value +#endif +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif + +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif + + +#define YY_ASSERT(E) ((void) (0 && (E))) + +#if !defined yyoverflow + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS +# include /* INFRINGES ON USER NAME SPACE */ + /* Use EXIT_SUCCESS as a witness for stdlib.h. */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's 'empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* !defined yyoverflow */ + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yy_state_t yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYPTRDIFF_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / YYSIZEOF (*yyptr); \ + } \ + while (0) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from SRC to DST. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(Dst, Src, Count) \ + __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) +# else +# define YYCOPY(Dst, Src, Count) \ + do \ + { \ + YYPTRDIFF_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (Dst)[yyi] = (Src)[yyi]; \ + } \ + while (0) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 2 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 217 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 42 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 24 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 88 +/* YYNSTATES -- Number of states. */ +#define YYNSTATES 142 + +/* YYMAXUTOK -- Last valid token kind. */ +#define YYMAXUTOK 293 + + +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ +#define YYTRANSLATE(YYX) \ + (0 <= (YYX) && (YYX) <= YYMAXUTOK \ + ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ + : YYSYMBOL_YYUNDEF) + +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex. */ +static const yytype_int8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 39, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 40, 2, 41, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38 +}; + +#if YYDEBUG +/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ +static const yytype_int16 yyrline[] = +{ + 0, 87, 87, 88, 91, 92, 94, 94, 99, 99, + 135, 142, 143, 147, 148, 153, 155, 160, 165, 170, + 175, 180, 185, 190, 195, 197, 204, 209, 214, 219, + 226, 230, 237, 244, 245, 250, 251, 256, 261, 265, + 269, 277, 286, 286, 291, 299, 299, 304, 311, 318, + 323, 328, 337, 339, 339, 344, 344, 349, 356, 363, + 368, 375, 380, 388, 394, 395, 396, 400, 406, 412, + 418, 422, 428, 429, 430, 433, 434, 434, 442, 447, + 452, 457, 462, 467, 474, 475, 479, 483, 487 +}; +#endif + +/** Accessing symbol of state STATE. */ +#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) + +#if YYDEBUG || 0 +/* The user-facing name of the symbol whose (internal) number is + YYSYMBOL. No bounds checking. */ +static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; + +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "\"end of file\"", "error", "\"invalid token\"", "K_OPTIONS", + "K_DEFAULT", "K_PORT", "K_BINDADDR", "K_PERSIST", "K_TIMEOUT", + "K_PASSWD", "K_PROG", "K_PPP", "K_SPEED", "K_IFCFG", "K_FWALL", + "K_ROUTE", "K_DEVICE", "K_MULTI", "K_SRCADDR", "K_IFACE", "K_ADDR", + "K_TYPE", "K_PROT", "K_NAT_HACK", "K_COMPRESS", "K_ENCRYPT", "K_KALIVE", + "K_STAT", "K_UP", "K_DOWN", "K_SYSLOG", "K_IPROUTE", "K_HOST", "K_ERROR", + "WORD", "PATH", "STRING", "NUM", "DNUM", "'\\n'", "'{'", "'}'", + "$accept", "config", "statement", "$@1", "$@2", "options", "option", + "bindaddr_option", "syslog_opt", "host_options", "host_option", "$@3", + "$@4", "$@5", "$@6", "compress", "keepalive", "srcaddr_options", + "srcaddr_option", "command_options", "command_option", "$@7", + "prog_options", "prog_option", YY_NULLPTR +}; + +static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + return yytname[yysymbol]; +} +#endif + +#define YYPACT_NINF (-75) + +#define yypact_value_is_default(Yyn) \ + ((Yyn) == YYPACT_NINF) + +#define YYTABLE_NINF (-1) + +#define yytable_value_is_error(Yyn) \ + 0 + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +static const yytype_int16 yypact[] = +{ + -75, 0, -75, -29, -75, -75, -75, -75, -75, 96, + -26, -19, -11, 13, -8, -27, 38, 62, 63, 69, + 66, -32, 64, -75, -75, 4, -75, 116, 116, -75, + -13, -75, -75, -75, -75, -75, -75, -75, -75, -75, + -75, -75, -75, -75, -75, 75, 76, 80, 49, 82, + 81, 79, 83, 84, 85, -75, 93, -75, 94, -75, + -75, -75, -75, 39, -75, 67, -12, 102, -75, 105, + -75, -75, -75, -75, -75, -75, -75, 11, -75, -75, + -75, 21, -75, 44, -75, 113, 114, -75, -75, -75, + -75, -75, -75, -75, 121, 2, 128, -75, 8, -75, + -75, -75, -75, -75, -75, -75, -75, -75, 178, 178, + -75, -75, -75, -75, -75, -75, -75, 127, 129, 130, + 131, 133, -75, -75, 137, -75, 146, 34, -75, -75, + -75, -75, -75, -75, -75, -75, -75, -75, -75, 34, + -75, -75 +}; + +/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE does not specify something else to do. Zero + means the default is an error. */ +static const yytype_int8 yydefact[] = +{ + 2, 0, 1, 0, 6, 8, 10, 4, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 25, 13, 0, 11, 0, 0, 14, + 0, 18, 19, 20, 22, 21, 16, 17, 32, 31, + 30, 24, 23, 5, 12, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 42, 0, 45, 0, 53, + 55, 57, 35, 0, 33, 0, 0, 0, 29, 0, + 48, 39, 36, 40, 41, 37, 38, 64, 49, 50, + 51, 0, 44, 0, 47, 0, 0, 7, 34, 9, + 27, 28, 26, 15, 0, 0, 0, 71, 0, 65, + 60, 58, 59, 43, 63, 61, 62, 46, 72, 72, + 70, 68, 69, 67, 52, 66, 76, 0, 0, 0, + 0, 0, 83, 75, 0, 73, 0, 0, 78, 79, + 81, 80, 82, 54, 74, 56, 86, 87, 88, 77, + 84, 85 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = +{ + -75, -75, -75, -75, -75, -75, 139, -75, -75, 143, + -23, -75, -75, -75, -75, -75, -75, -75, 74, 65, + -74, -75, -75, 36 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_uint8 yydefgoto[] = +{ + 0, 1, 8, 10, 11, 25, 26, 69, 41, 63, + 64, 81, 83, 85, 86, 103, 107, 98, 99, 124, + 125, 127, 139, 140 +}; + +/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule whose + number is the opposite. If YYTABLE_NINF, syntax error. */ +static const yytype_uint8 yytable[] = +{ + 2, 38, 39, 3, 4, 40, 66, 67, 32, 12, + 13, 9, 14, 94, 27, 15, 94, 16, 17, 18, + 68, 28, 90, 19, 91, 20, 29, 95, 96, 31, + 95, 96, 5, 6, 21, 22, 111, 23, 112, 7, + 88, 97, 88, 24, 97, 43, 45, 46, 47, 114, + 134, 48, 134, 30, 100, 49, 50, 51, 101, 102, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 136, + 137, 138, 61, 33, 45, 46, 47, 104, 62, 48, + 87, 105, 106, 49, 50, 51, 73, 74, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 34, 35, 42, + 61, 12, 13, 37, 14, 36, 62, 15, 89, 16, + 17, 18, 70, 71, 72, 19, 75, 20, 76, 77, + 78, 79, 80, 45, 46, 47, 21, 22, 48, 23, + 82, 84, 49, 50, 51, 24, 92, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 93, 116, 117, 61, + 118, 119, 120, 108, 109, 62, 116, 117, 110, 118, + 119, 120, 113, 128, 44, 129, 130, 131, 121, 132, + 122, 65, 115, 0, 126, 141, 123, 121, 133, 122, + 0, 0, 0, 0, 0, 123, 0, 135, 116, 117, + 0, 118, 119, 120, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 121, + 0, 122, 0, 0, 0, 0, 0, 123 +}; + +static const yytype_int16 yycheck[] = +{ + 0, 33, 34, 3, 4, 37, 19, 20, 35, 5, + 6, 40, 8, 5, 40, 11, 5, 13, 14, 15, + 33, 40, 34, 19, 36, 21, 37, 19, 20, 37, + 19, 20, 32, 33, 30, 31, 34, 33, 36, 39, + 63, 33, 65, 39, 33, 41, 7, 8, 9, 41, + 124, 12, 126, 40, 33, 16, 17, 18, 37, 38, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 35, + 36, 37, 33, 35, 7, 8, 9, 33, 39, 12, + 41, 37, 38, 16, 17, 18, 37, 38, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 35, 35, 35, + 33, 5, 6, 37, 8, 36, 39, 11, 41, 13, + 14, 15, 37, 37, 34, 19, 34, 21, 37, 40, + 37, 37, 37, 7, 8, 9, 30, 31, 12, 33, + 37, 37, 16, 17, 18, 39, 34, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 41, 10, 11, 33, + 13, 14, 15, 40, 40, 39, 10, 11, 37, 13, + 14, 15, 34, 36, 25, 36, 36, 36, 31, 36, + 33, 28, 98, -1, 109, 139, 39, 31, 41, 33, + -1, -1, -1, -1, -1, 39, -1, 41, 10, 11, + -1, 13, 14, 15, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 31, + -1, 33, -1, -1, -1, -1, -1, 39 +}; + +/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of + state STATE-NUM. */ +static const yytype_int8 yystos[] = +{ + 0, 43, 0, 3, 4, 32, 33, 39, 44, 40, + 45, 46, 5, 6, 8, 11, 13, 14, 15, 19, + 21, 30, 31, 33, 39, 47, 48, 40, 40, 37, + 40, 37, 35, 35, 35, 35, 36, 37, 33, 34, + 37, 50, 35, 41, 48, 7, 8, 9, 12, 16, + 17, 18, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 33, 39, 51, 52, 51, 19, 20, 33, 49, + 37, 37, 34, 37, 38, 34, 37, 40, 37, 37, + 37, 53, 37, 54, 37, 55, 56, 41, 52, 41, + 34, 36, 34, 41, 5, 19, 20, 33, 59, 60, + 33, 37, 38, 57, 33, 37, 38, 58, 40, 40, + 37, 34, 36, 34, 41, 60, 10, 11, 13, 14, + 15, 31, 33, 39, 61, 62, 61, 63, 36, 36, + 36, 36, 36, 41, 62, 41, 35, 36, 37, 64, + 65, 65 +}; + +/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ +static const yytype_int8 yyr1[] = +{ + 0, 42, 43, 43, 44, 44, 45, 44, 46, 44, + 44, 47, 47, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 49, 49, 49, 49, + 50, 50, 50, 51, 51, 52, 52, 52, 52, 52, + 52, 52, 53, 52, 52, 54, 52, 52, 52, 52, + 52, 52, 52, 55, 52, 56, 52, 52, 57, 57, + 57, 58, 58, 58, 59, 59, 59, 60, 60, 60, + 60, 60, 61, 61, 61, 62, 63, 62, 62, 62, + 62, 62, 62, 62, 64, 64, 65, 65, 65 +}; + +/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ +static const yytype_int8 yyr2[] = +{ + 0, 2, 0, 2, 1, 4, 0, 5, 0, 5, + 1, 1, 2, 1, 2, 4, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, + 1, 1, 1, 1, 2, 1, 2, 2, 2, 2, + 2, 2, 0, 3, 2, 0, 3, 2, 2, 2, + 2, 2, 4, 0, 5, 0, 5, 1, 1, 1, + 1, 1, 1, 1, 0, 1, 2, 2, 2, 2, + 2, 1, 0, 1, 2, 1, 0, 3, 2, 2, + 2, 2, 2, 1, 1, 2, 1, 1, 1 +}; + + +enum { YYENOMEM = -2 }; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYNOMEM goto yyexhaustedlab + + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) + +/* Backward compatibility with an undocumented macro. + Use YYerror or YYUNDEF. */ +#define YYERRCODE YYUNDEF + + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + + + + +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Kind, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + + +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ + +static void +yy_symbol_value_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) +{ + FILE *yyoutput = yyo; + YY_USE (yyoutput); + if (!yyvaluep) + return; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + YY_USE (yykind); + YY_IGNORE_MAYBE_UNINITIALIZED_END +} + + +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ + +static void +yy_symbol_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) +{ + YYFPRINTF (yyo, "%s %s (", + yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); + + yy_symbol_value_print (yyo, yykind, yyvaluep); + YYFPRINTF (yyo, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +static void +yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +static void +yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, + int yyrule) +{ + int yylno = yyrline[yyrule]; + int yynrhs = yyr2[yyrule]; + int yyi; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, + YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), + &yyvsp[(yyi + 1) - (yynrhs)]); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyssp, yyvsp, Rule); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) ((void) 0) +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + + + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +yydestruct (const char *yymsg, + yysymbol_kind_t yykind, YYSTYPE *yyvaluep) +{ + YY_USE (yyvaluep); + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + YY_USE (yykind); + YY_IGNORE_MAYBE_UNINITIALIZED_END +} + + +/* Lookahead token kind. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; +/* Number of syntax errors so far. */ +int yynerrs; + + + + +/*----------. +| yyparse. | +`----------*/ + +int +yyparse (void) +{ + yy_state_fast_t yystate = 0; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus = 0; + + /* Refer to the stacks through separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* Their size. */ + YYPTRDIFF_T yystacksize = YYINITDEPTH; + + /* The state stack: array, bottom, top. */ + yy_state_t yyssa[YYINITDEPTH]; + yy_state_t *yyss = yyssa; + yy_state_t *yyssp = yyss; + + /* The semantic value stack: array, bottom, top. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + YYSTYPE *yyvsp = yyvs; + + int yyn; + /* The return value of yyparse. */ + int yyresult; + /* Lookahead symbol kind. */ + yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yychar = YYEMPTY; /* Cause a token to be read. */ + + goto yysetstate; + + +/*------------------------------------------------------------. +| yynewstate -- push a new state, which is found in yystate. | +`------------------------------------------------------------*/ +yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + +/*--------------------------------------------------------------------. +| yysetstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + YY_ASSERT (0 <= yystate && yystate < YYNSTATES); + YY_IGNORE_USELESS_CAST_BEGIN + *yyssp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END + YY_STACK_PRINT (yyss, yyssp); + + if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + YYNOMEM; +#else + { + /* Get the current used size of the three stacks, in elements. */ + YYPTRDIFF_T yysize = yyssp - yyss + 1; + +# if defined yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + yy_state_t *yyss1 = yyss; + YYSTYPE *yyvs1 = yyvs; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * YYSIZEOF (*yyssp), + &yyvs1, yysize * YYSIZEOF (*yyvsp), + &yystacksize); + yyss = yyss1; + yyvs = yyvs1; + } +# else /* defined YYSTACK_RELOCATE */ + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + YYNOMEM; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yy_state_t *yyss1 = yyss; + union yyalloc *yyptr = + YY_CAST (union yyalloc *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); + if (! yyptr) + YYNOMEM; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YY_IGNORE_USELESS_CAST_BEGIN + YYDPRINTF ((stderr, "Stack size increased to %ld\n", + YY_CAST (long, yystacksize))); + YY_IGNORE_USELESS_CAST_END + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ + + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token\n")); + yychar = yylex (); + } + + if (yychar <= YYEOF) + { + yychar = YYEOF; + yytoken = YYSYMBOL_YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else if (yychar == YYerror) + { + /* The scanner already issued an error message, process directly + to error recovery. But do not keep the error token as + lookahead, it is too special and may lead us to an endless + loop in error recovery. */ + yychar = YYUNDEF; + yytoken = YYSYMBOL_YYerror; + goto yyerrlab1; + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + yystate = yyn; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + /* Discard the shifted token. */ + yychar = YYEMPTY; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + '$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 6: /* $@1: %empty */ +#line 94 "cfg_file.y" + { + parse_host = &default_host; + } +#line 1428 "y.tab.c" + break; + + case 8: /* $@2: %empty */ +#line 99 "cfg_file.y" + { + if( !(parse_host = malloc(sizeof(struct vtun_host))) ){ + yyerror("No memory for the host"); + YYABORT; + } + + /* Fill new host struct with default values. + * MUST dup strings to be able to reread config. + */ + memcpy(parse_host, &default_host, sizeof(struct vtun_host)); + parse_host->host = strdup((yyvsp[0].str)); + parse_host->passwd = NULL; + parse_host->akey = NULL; + parse_host->key = NULL; + parse_host->sopt.host = strdup((yyvsp[0].str)); + + /* Copy local address */ + copy_addr(parse_host, &default_host); + + llist_copy(&default_host.up,&parse_host->up,cp_cmd,NULL); + llist_copy(&default_host.down,&parse_host->down,cp_cmd,NULL); + + } +#line 1456 "y.tab.c" + break; + + case 9: /* statement: K_HOST $@2 '{' host_options '}' */ +#line 123 "cfg_file.y" + { + /* Check if session definition is complete */ + if (!parse_host->passwd) { + cfg_error("Ignored incomplete session definition '%s'", parse_host->host); + free_host(parse_host, NULL); + free(parse_host); + } else { + /* Add host to the list */ + llist_add(&host_list, (void *)parse_host); + } + } +#line 1472 "y.tab.c" + break; + + case 10: /* statement: K_ERROR */ +#line 135 "cfg_file.y" + { + cfg_error("Invalid clause '%s'",(yyvsp[0].str)); + YYABORT; + } +#line 1481 "y.tab.c" + break; + + case 14: /* option: K_PORT NUM */ +#line 148 "cfg_file.y" + { + if(vtun.bind_addr.port == -1) + vtun.bind_addr.port = (yyvsp[0].num); + } +#line 1490 "y.tab.c" + break; + + case 16: /* option: K_IFACE STRING */ +#line 155 "cfg_file.y" + { + if(vtun.svr_addr == NULL) + vtun.svr_addr = strdup((yyvsp[0].str)); + } +#line 1499 "y.tab.c" + break; + + case 17: /* option: K_TYPE NUM */ +#line 160 "cfg_file.y" + { + if(vtun.svr_type == -1) + vtun.svr_type = (yyvsp[0].num); + } +#line 1508 "y.tab.c" + break; + + case 18: /* option: K_TIMEOUT NUM */ +#line 165 "cfg_file.y" + { + if(vtun.timeout == -1) + vtun.timeout = (yyvsp[0].num); + } +#line 1517 "y.tab.c" + break; + + case 19: /* option: K_PPP PATH */ +#line 170 "cfg_file.y" + { + free(vtun.ppp); + vtun.ppp = strdup((yyvsp[0].str)); + } +#line 1526 "y.tab.c" + break; + + case 20: /* option: K_IFCFG PATH */ +#line 175 "cfg_file.y" + { + free(vtun.ifcfg); + vtun.ifcfg = strdup((yyvsp[0].str)); + } +#line 1535 "y.tab.c" + break; + + case 21: /* option: K_ROUTE PATH */ +#line 180 "cfg_file.y" + { + free(vtun.route); + vtun.route = strdup((yyvsp[0].str)); + } +#line 1544 "y.tab.c" + break; + + case 22: /* option: K_FWALL PATH */ +#line 185 "cfg_file.y" + { + free(vtun.fwall); + vtun.fwall = strdup((yyvsp[0].str)); + } +#line 1553 "y.tab.c" + break; + + case 23: /* option: K_IPROUTE PATH */ +#line 190 "cfg_file.y" + { + free(vtun.iproute); + vtun.iproute = strdup((yyvsp[0].str)); + } +#line 1562 "y.tab.c" + break; + + case 25: /* option: K_ERROR */ +#line 197 "cfg_file.y" + { + cfg_error("Unknown option '%s'",(yyvsp[0].str)); + YYABORT; + } +#line 1571 "y.tab.c" + break; + + case 26: /* bindaddr_option: K_ADDR WORD */ +#line 204 "cfg_file.y" + { + vtun.bind_addr.name = strdup((yyvsp[0].str)); + vtun.bind_addr.type = VTUN_ADDR_NAME; + } +#line 1580 "y.tab.c" + break; + + case 27: /* bindaddr_option: K_IFACE WORD */ +#line 209 "cfg_file.y" + { + vtun.bind_addr.name = strdup((yyvsp[0].str)); + vtun.bind_addr.type = VTUN_ADDR_IFACE; + } +#line 1589 "y.tab.c" + break; + + case 28: /* bindaddr_option: K_IFACE STRING */ +#line 214 "cfg_file.y" + { + vtun.bind_addr.name = strdup((yyvsp[0].str)); + vtun.bind_addr.type = VTUN_ADDR_IFACE; + } +#line 1598 "y.tab.c" + break; + + case 29: /* bindaddr_option: K_ERROR */ +#line 219 "cfg_file.y" + { + cfg_error("Unknown option '%s'",(yyvsp[0].str)); + YYABORT; + } +#line 1607 "y.tab.c" + break; + + case 30: /* syslog_opt: NUM */ +#line 226 "cfg_file.y" + { + vtun.syslog = (yyvsp[0].num); + } +#line 1615 "y.tab.c" + break; + + case 31: /* syslog_opt: WORD */ +#line 230 "cfg_file.y" + { + if (parse_syslog((yyvsp[0].str))) { + cfg_error("Unknown syslog facility '%s'", (yyvsp[0].str)); + YYABORT; + } + } +#line 1626 "y.tab.c" + break; + + case 32: /* syslog_opt: K_ERROR */ +#line 237 "cfg_file.y" + { + cfg_error("Unknown syslog option '%s'",(yyvsp[0].str)); + YYABORT; + } +#line 1635 "y.tab.c" + break; + + case 36: /* host_option: K_PASSWD WORD */ +#line 251 "cfg_file.y" + { + free(parse_host->passwd); + parse_host->passwd = strdup((yyvsp[0].str)); + } +#line 1644 "y.tab.c" + break; + + case 37: /* host_option: K_DEVICE WORD */ +#line 256 "cfg_file.y" + { + free(parse_host->dev); + parse_host->dev = strdup((yyvsp[0].str)); + } +#line 1653 "y.tab.c" + break; + + case 38: /* host_option: K_MULTI NUM */ +#line 261 "cfg_file.y" + { + parse_host->multi = (yyvsp[0].num); + } +#line 1661 "y.tab.c" + break; + + case 39: /* host_option: K_TIMEOUT NUM */ +#line 265 "cfg_file.y" + { + parse_host->timeout = (yyvsp[0].num); + } +#line 1669 "y.tab.c" + break; + + case 40: /* host_option: K_SPEED NUM */ +#line 269 "cfg_file.y" + { + if( (yyvsp[0].num) ){ + parse_host->spd_in = parse_host->spd_out = (yyvsp[0].num); + parse_host->flags |= VTUN_SHAPE; + } else + parse_host->flags &= ~VTUN_SHAPE; + } +#line 1681 "y.tab.c" + break; + + case 41: /* host_option: K_SPEED DNUM */ +#line 277 "cfg_file.y" + { + if( yylval.dnum.num1 || yylval.dnum.num2 ){ + parse_host->spd_out = yylval.dnum.num1; + parse_host->spd_in = yylval.dnum.num2; + parse_host->flags |= VTUN_SHAPE; + } else + parse_host->flags &= ~VTUN_SHAPE; + } +#line 1694 "y.tab.c" + break; + + case 42: /* $@3: %empty */ +#line 286 "cfg_file.y" + { + parse_host->flags &= ~(VTUN_ZLIB | VTUN_LZO); + } +#line 1702 "y.tab.c" + break; + + case 44: /* host_option: K_ENCRYPT NUM */ +#line 291 "cfg_file.y" + { + if( (yyvsp[0].num) ){ + parse_host->flags |= VTUN_ENCRYPT; + parse_host->cipher = (yyvsp[0].num); + } else + parse_host->flags &= ~VTUN_ENCRYPT; + } +#line 1714 "y.tab.c" + break; + + case 45: /* $@4: %empty */ +#line 299 "cfg_file.y" + { + parse_host->flags &= ~VTUN_KEEP_ALIVE; + } +#line 1722 "y.tab.c" + break; + + case 47: /* host_option: K_STAT NUM */ +#line 304 "cfg_file.y" + { + if( (yyvsp[0].num) ) + parse_host->flags |= VTUN_STAT; + else + parse_host->flags &= ~VTUN_STAT; + } +#line 1733 "y.tab.c" + break; + + case 48: /* host_option: K_PERSIST NUM */ +#line 311 "cfg_file.y" + { + parse_host->persist = (yyvsp[0].num); + + if(vtun.persist == -1) + vtun.persist = (yyvsp[0].num); + } +#line 1744 "y.tab.c" + break; + + case 49: /* host_option: K_TYPE NUM */ +#line 318 "cfg_file.y" + { + parse_host->flags &= ~VTUN_TYPE_MASK; + parse_host->flags |= (yyvsp[0].num); + } +#line 1753 "y.tab.c" + break; + + case 50: /* host_option: K_PROT NUM */ +#line 323 "cfg_file.y" + { + parse_host->flags &= ~VTUN_PROT_MASK; + parse_host->flags |= (yyvsp[0].num); + } +#line 1762 "y.tab.c" + break; + + case 51: /* host_option: K_NAT_HACK NUM */ +#line 328 "cfg_file.y" + { +#ifdef ENABLE_NAT_HACK + parse_host->flags &= ~VTUN_NAT_HACK_MASK; + parse_host->flags |= (yyvsp[0].num); +#else + cfg_error("This vtund binary was built with the NAT hack disabled for security purposes."); +#endif + } +#line 1775 "y.tab.c" + break; + + case 53: /* $@5: %empty */ +#line 339 "cfg_file.y" + { + parse_cmds = &parse_host->up; + llist_free(parse_cmds, free_cmd, NULL); + } +#line 1784 "y.tab.c" + break; + + case 55: /* $@6: %empty */ +#line 344 "cfg_file.y" + { + parse_cmds = &parse_host->down; + llist_free(parse_cmds, free_cmd, NULL); + } +#line 1793 "y.tab.c" + break; + + case 57: /* host_option: K_ERROR */ +#line 349 "cfg_file.y" + { + cfg_error("Unknown option '%s'",(yyvsp[0].str)); + YYABORT; + } +#line 1802 "y.tab.c" + break; + + case 58: /* compress: NUM */ +#line 356 "cfg_file.y" + { + if( (yyvsp[0].num) ){ + parse_host->flags |= VTUN_ZLIB; + parse_host->zlevel = (yyvsp[0].num); + } + } +#line 1813 "y.tab.c" + break; + + case 59: /* compress: DNUM */ +#line 363 "cfg_file.y" + { + parse_host->flags |= yylval.dnum.num1; + parse_host->zlevel = yylval.dnum.num2; + } +#line 1822 "y.tab.c" + break; + + case 60: /* compress: K_ERROR */ +#line 368 "cfg_file.y" + { + cfg_error("Unknown compression '%s'",(yyvsp[0].str)); + YYABORT; + } +#line 1831 "y.tab.c" + break; + + case 61: /* keepalive: NUM */ +#line 375 "cfg_file.y" + { + if( (yyvsp[0].num) ) + parse_host->flags |= VTUN_KEEP_ALIVE; + } +#line 1840 "y.tab.c" + break; + + case 62: /* keepalive: DNUM */ +#line 380 "cfg_file.y" + { + if( yylval.dnum.num1 ){ + parse_host->flags |= VTUN_KEEP_ALIVE; + parse_host->ka_interval = yylval.dnum.num1; + parse_host->ka_maxfail = yylval.dnum.num2; + } + } +#line 1852 "y.tab.c" + break; + + case 63: /* keepalive: K_ERROR */ +#line 388 "cfg_file.y" + { + cfg_error("Unknown keepalive option '%s'",(yyvsp[0].str)); + YYABORT; + } +#line 1861 "y.tab.c" + break; + + case 67: /* srcaddr_option: K_ADDR WORD */ +#line 400 "cfg_file.y" + { + free_addr(parse_host); + parse_host->src_addr.name = strdup((yyvsp[0].str)); + parse_host->src_addr.type = VTUN_ADDR_NAME; + } +#line 1871 "y.tab.c" + break; + + case 68: /* srcaddr_option: K_IFACE WORD */ +#line 406 "cfg_file.y" + { + free_addr(parse_host); + parse_host->src_addr.name = strdup((yyvsp[0].str)); + parse_host->src_addr.type = VTUN_ADDR_IFACE; + } +#line 1881 "y.tab.c" + break; + + case 69: /* srcaddr_option: K_IFACE STRING */ +#line 412 "cfg_file.y" + { + free_addr(parse_host); + parse_host->src_addr.name = strdup((yyvsp[0].str)); + parse_host->src_addr.type = VTUN_ADDR_IFACE; + } +#line 1891 "y.tab.c" + break; + + case 70: /* srcaddr_option: K_PORT NUM */ +#line 418 "cfg_file.y" + { + parse_host->src_addr.port = (yyvsp[0].num); + } +#line 1899 "y.tab.c" + break; + + case 71: /* srcaddr_option: K_ERROR */ +#line 422 "cfg_file.y" + { + cfg_error("Unknown option '%s'",(yyvsp[0].str)); + YYABORT; + } +#line 1908 "y.tab.c" + break; + + case 76: /* $@7: %empty */ +#line 434 "cfg_file.y" + { + memset(&parse_cmd, 0, sizeof(struct vtun_cmd)); + } +#line 1916 "y.tab.c" + break; + + case 77: /* command_option: K_PROG $@7 prog_options */ +#line 437 "cfg_file.y" + { + add_cmd(parse_cmds, parse_cmd.prog, + parse_cmd.args, parse_cmd.flags); + } +#line 1925 "y.tab.c" + break; + + case 78: /* command_option: K_PPP STRING */ +#line 442 "cfg_file.y" + { + add_cmd(parse_cmds, strdup(vtun.ppp), strdup((yyvsp[0].str)), + VTUN_CMD_DELAY); + } +#line 1934 "y.tab.c" + break; + + case 79: /* command_option: K_IFCFG STRING */ +#line 447 "cfg_file.y" + { + add_cmd(parse_cmds, strdup(vtun.ifcfg),strdup((yyvsp[0].str)), + VTUN_CMD_WAIT); + } +#line 1943 "y.tab.c" + break; + + case 80: /* command_option: K_ROUTE STRING */ +#line 452 "cfg_file.y" + { + add_cmd(parse_cmds, strdup(vtun.route),strdup((yyvsp[0].str)), + VTUN_CMD_WAIT); + } +#line 1952 "y.tab.c" + break; + + case 81: /* command_option: K_FWALL STRING */ +#line 457 "cfg_file.y" + { + add_cmd(parse_cmds, strdup(vtun.fwall),strdup((yyvsp[0].str)), + VTUN_CMD_WAIT); + } +#line 1961 "y.tab.c" + break; + + case 82: /* command_option: K_IPROUTE STRING */ +#line 462 "cfg_file.y" + { + add_cmd(parse_cmds, strdup(vtun.iproute),strdup((yyvsp[0].str)), + VTUN_CMD_WAIT); + } +#line 1970 "y.tab.c" + break; + + case 83: /* command_option: K_ERROR */ +#line 467 "cfg_file.y" + { + cfg_error("Unknown cmd '%s'",(yyvsp[0].str)); + YYABORT; + } +#line 1979 "y.tab.c" + break; + + case 86: /* prog_option: PATH */ +#line 479 "cfg_file.y" + { + parse_cmd.prog = strdup((yyvsp[0].str)); + } +#line 1987 "y.tab.c" + break; + + case 87: /* prog_option: STRING */ +#line 483 "cfg_file.y" + { + parse_cmd.args = strdup((yyvsp[0].str)); + } +#line 1995 "y.tab.c" + break; + + case 88: /* prog_option: NUM */ +#line 487 "cfg_file.y" + { + parse_cmd.flags = (yyvsp[0].num); + } +#line 2003 "y.tab.c" + break; + + +#line 2007 "y.tab.c" + + default: break; + } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + + *++yyvsp = yyval; + + /* Now 'shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } + + goto yynewstate; + + +/*--------------------------------------. +| yyerrlab -- here on detecting error. | +`--------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; + yyerror (YY_("syntax error")); + } + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; + ++yynerrs; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + /* Pop stack until we find a state that shifts the error token. */ + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYSYMBOL_YYerror; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + YY_ACCESSING_SYMBOL (yystate), yyvsp); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturnlab; + + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturnlab; + + +/*-----------------------------------------------------------. +| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | +`-----------------------------------------------------------*/ +yyexhaustedlab: + yyerror (YY_("memory exhausted")); + yyresult = 2; + goto yyreturnlab; + + +/*----------------------------------------------------------. +| yyreturnlab -- parsing is finished, clean up and return. | +`----------------------------------------------------------*/ +yyreturnlab: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval); + } + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + + return yyresult; +} + +#line 491 "cfg_file.y" + + +int yyerror(char *s) +{ + vtun_syslog(LOG_ERR, "%s line %d\n", s, lineno); + return 0; +} + +int cfg_error(const char *fmt, ...) +{ + char buf[255]; + va_list ap; + + /* print the argument string */ + va_start(ap, fmt); + vsnprintf(buf,sizeof(buf),fmt,ap); + va_end(ap); + + yyerror(buf); + return 0; +} + +int add_cmd(llist *cmds, char *prog, char *args, int flags) +{ + struct vtun_cmd *cmd; + if( !(cmd = malloc(sizeof(struct vtun_cmd))) ){ + yyerror("No memory for the command"); + return -1; + } + memset(cmd, 0, sizeof(struct vtun_cmd)); + + cmd->prog = prog; + cmd->args = args; + cmd->flags = flags; + llist_add(cmds, cmd); + + return 0; +} + +void *cp_cmd(void *d, void *u) +{ + struct vtun_cmd *cmd = d, *cmd_copy; + + if( !(cmd_copy = malloc(sizeof(struct vtun_cmd))) ){ + yyerror("No memory to copy the command"); + return NULL; + } + + cmd_copy->prog = strdup(cmd->prog); + cmd_copy->args = strdup(cmd->args); + cmd_copy->flags = cmd->flags; + return cmd_copy; +} + +int free_cmd(void *d, void *u) +{ + struct vtun_cmd *cmd = d; + free(cmd->prog); + free(cmd->args); + free(cmd); + return 0; +} + +void copy_addr(struct vtun_host *to, struct vtun_host *from) +{ + if( from->src_addr.type ){ + to->src_addr.type = from->src_addr.type; + to->src_addr.name = strdup(from->src_addr.name); + } + to->src_addr.port = from->src_addr.port; +} + +void free_addr(struct vtun_host *h) +{ + if( h->src_addr.type ){ + h->src_addr.type = 0; + free(h->src_addr.name); + } +} + +int free_host(void *d, void *u) +{ + struct vtun_host *h = d; + + if (u && !strcmp(h->host, u)) + return 1; + + free(h->host); + free(h->passwd); + sodium_free(h->akey); + sodium_free(h->key); + + llist_free(&h->up, free_cmd, NULL); + llist_free(&h->down, free_cmd, NULL); + + free_addr(h); + + /* releases only host struct instances which were + * allocated in the case of K_HOST except default_host */ + if( h->passwd ) + free(h); + + + return 0; +} + +/* Find host in the hosts list. + * NOTE: This function can be called only once since it deallocates hosts list. + */ +inline struct vtun_host* find_host(char *host) +{ + return (struct vtun_host *)llist_free(&host_list, free_host, host); +} + +int clear_nat_hack_server(void *d, void *u) +{ + ((struct vtun_host*)d)->flags &= ~VTUN_NAT_HACK_CLIENT; + return 0; +} + +int clear_nat_hack_client(void *d, void *u) +{ + ((struct vtun_host*)d)->flags &= ~VTUN_NAT_HACK_SERVER; + return 0; +} + +/* Clear the VTUN_NAT_HACK flag which are not relevant to the current operation mode */ +void clear_nat_hack_flags(int svr) +{ + if (svr) + llist_trav(&host_list,clear_nat_hack_server,NULL); + else + llist_trav(&host_list,clear_nat_hack_client,NULL); +} + +inline void free_host_list(void) +{ + llist_free(&host_list, free_host, NULL); +} + +static struct { + char *c_name; + int c_val; +} syslog_names[] = { + { "auth", LOG_AUTH }, + { "cron", LOG_CRON }, + { "daemon", LOG_DAEMON }, + { "kern", LOG_KERN }, + { "lpr", LOG_LPR }, + { "mail", LOG_MAIL }, + { "news", LOG_NEWS }, + { "syslog", LOG_SYSLOG }, + { "user", LOG_USER }, + { "uucp", LOG_UUCP }, + { "local0", LOG_LOCAL0 }, + { "local1", LOG_LOCAL1 }, + { "local2", LOG_LOCAL2 }, + { "local3", LOG_LOCAL3 }, + { "local4", LOG_LOCAL4 }, + { "local5", LOG_LOCAL5 }, + { "local6", LOG_LOCAL6 }, + { "local7", LOG_LOCAL7 }, + { NULL, -1 } +}; + +int parse_syslog(char *facility) +{ + int i; + + for (i=0; syslog_names[i].c_name;i++) { + if (!strcmp(syslog_names[i].c_name, facility)) { + vtun.syslog = syslog_names[i].c_val; + return(0); + } + } + return -1; +} + +/* + * Read config file. + */ +int read_config(char *file) +{ + static int cfg_loaded = 0; + extern FILE *yyin; + + if( cfg_loaded ){ + free_host_list(); + vtun_syslog(LOG_INFO,"Reloading configuration file"); + } + cfg_loaded = 1; + + llist_init(&host_list); + + if( !(yyin = fopen(file,"r")) ){ + vtun_syslog(LOG_ERR,"Can not open %s", file); + return -1; + } + + yyparse(); + + free_host(&default_host, NULL); + + fclose(yyin); + + return !llist_empty(&host_list); +} diff --git a/cfg_file.lex.c b/cfg_file.lex.c new file mode 100644 index 0000000..062c57f --- /dev/null +++ b/cfg_file.lex.c @@ -0,0 +1,1997 @@ + +#line 2 "" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. + */ +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +extern int yyleng; + +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + #define YY_LINENO_REWIND_TO(ptr) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = NULL; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); + +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); + +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); + +#define yy_new_buffer yy_create_buffer +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ +typedef flex_uint8_t YY_CHAR; + +FILE *yyin = NULL, *yyout = NULL; + +typedef int yy_state_type; + +extern int yylineno; +int yylineno = 1; + +extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state ( void ); +static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); +static int yy_get_next_buffer ( void ); +static void yynoreturn yy_fatal_error ( const char* msg ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; +#define YY_NUM_RULES 17 +#define YY_END_OF_BUFFER 18 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static const flex_int16_t yy_accept[41] = + { 0, + 0, 0, 0, 0, 0, 0, 18, 16, 1, 2, + 5, 5, 4, 6, 7, 8, 8, 12, 16, 16, + 11, 15, 5, 0, 3, 5, 4, 8, 8, 12, + 0, 0, 9, 14, 11, 0, 13, 0, 10, 0 + } ; + +static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 4, 5, 6, 4, 4, 4, 1, 1, + 1, 4, 4, 1, 7, 8, 9, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 11, 12, 1, + 4, 1, 1, 4, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 1, 4, 1, 4, 7, 1, 7, 7, 7, 7, + + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 13, 1, 14, 4, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static const YY_CHAR yy_meta[15] = + { 0, + 1, 1, 2, 3, 1, 3, 4, 4, 1, 4, + 5, 1, 1, 1 + } ; + +static const flex_int16_t yy_base[46] = + { 0, + 0, 0, 11, 0, 21, 0, 84, 85, 85, 85, + 0, 35, 43, 85, 85, 0, 50, 72, 77, 0, + 41, 85, 0, 57, 85, 0, 0, 0, 0, 70, + 70, 71, 61, 53, 0, 49, 45, 0, 10, 85, + 65, 67, 69, 74, 12 + } ; + +static const flex_int16_t yy_def[46] = + { 0, + 40, 1, 1, 3, 40, 5, 40, 40, 40, 40, + 41, 40, 41, 40, 40, 42, 12, 43, 44, 45, + 43, 40, 41, 12, 40, 12, 13, 42, 17, 43, + 40, 44, 44, 45, 21, 40, 40, 45, 40, 0, + 40, 40, 40, 40, 40 + } ; + +static const flex_int16_t yy_nxt[100] = + { 0, + 8, 9, 10, 11, 8, 12, 13, 11, 8, 13, + 8, 8, 14, 15, 16, 34, 17, 16, 16, 39, + 16, 8, 9, 10, 18, 19, 18, 18, 18, 20, + 21, 8, 22, 14, 15, 24, 24, 25, 26, 24, + 26, 26, 26, 24, 26, 24, 24, 24, 24, 27, + 35, 36, 27, 29, 37, 29, 29, 29, 39, 29, + 24, 38, 24, 24, 24, 33, 24, 23, 23, 28, + 28, 30, 30, 30, 32, 33, 32, 32, 32, 37, + 31, 33, 31, 40, 7, 40, 40, 40, 40, 40, + 40, 40, 40, 40, 40, 40, 40, 40, 40 + + } ; + +static const flex_int16_t yy_chk[100] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 3, 45, 3, 3, 3, 39, + 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 12, 12, 12, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, + 21, 21, 13, 17, 37, 17, 17, 17, 36, 17, + 24, 34, 24, 24, 24, 33, 24, 41, 41, 42, + 42, 43, 43, 43, 44, 32, 44, 44, 44, 31, + 30, 19, 18, 7, 40, 40, 40, 40, 40, 40, + 40, 40, 40, 40, 40, 40, 40, 40, 40 + + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int yy_flex_debug; +int yy_flex_debug = 0; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "cfg_file.l" +#line 2 "cfg_file.l" +/* + VTun - Virtual Tunnel over TCP/IP network. + + Copyright (C) 1998-2008 Maxim Krasnyansky + + VTun has been derived from VPPP package by Maxim Krasnyansky. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + */ + +/* + * $Id: cfg_file.l,v 1.4.2.2 2008/01/07 22:35:21 mtbishop Exp $ + */ + +#include "config.h" + +#include + +#include "vtun.h" + +#include "cfg_file.tab.h" +#include "cfg_kwords.h" + +/* static buffer for strings */ +char str_buf[255]; + +int find_keyword(struct kword *kw, char *str); + +#define ECHO {;} +#define YY_DECL int yylex(void) + +/* Push and pop parser state */ +static int stack[16]; +static int ptr = 0; + +#define PUSH_STATE() \ + do { \ + if( ptr == 16 ){ \ + yyerror("To many pushes to parser's state stack"); \ + return K_ERROR; \ + } \ + stack[ptr++] = YY_START; \ + } while(0) + +#define POP_STATE() \ + do { \ + if( !ptr ){ \ + yyerror("To many pops from parser's state stack"); \ + return K_ERROR; \ + } \ + BEGIN(stack[--ptr]); \ + } while(0) + +int cfg_error(const char *ftm, ...); + +int yyerror(char *str); +#line 537 "" + +#line 539 "" + +#define INITIAL 0 +#define OPTION 1 +#define PARAM 2 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +static int yy_init_globals ( void ); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( void ); + +int yyget_debug ( void ); + +void yyset_debug ( int debug_flag ); + +YY_EXTRA_TYPE yyget_extra ( void ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined ); + +FILE *yyget_in ( void ); + +void yyset_in ( FILE * _in_str ); + +FILE *yyget_out ( void ); + +void yyset_out ( FILE * _out_str ); + + int yyget_leng ( void ); + +char *yyget_text ( void ); + +int yyget_lineno ( void ); + +void yyset_lineno ( int _line_number ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( void ); +#else +extern int yywrap ( void ); +#endif +#endif + +#ifndef YY_NO_UNPUT + + static void yyunput ( int c, char *buf_ptr ); + +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * ); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput ( void ); +#else +static int input ( void ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + int n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (void); + +#define YY_DECL int yylex (void) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK /*LINTED*/break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + { +#line 80 "cfg_file.l" + +#line 760 "" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = (yy_start); +yy_match: + do + { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 41 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 85 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 81 "cfg_file.l" +; /* Skip spaces and tabs (All stages) */ + YY_BREAK +case 2: +/* rule 2 can match eol */ +YY_RULE_SETUP +#line 83 "cfg_file.l" +{ lineno++; } /* (All stages) */ + YY_BREAK +case 3: +/* rule 3 can match eol */ +YY_RULE_SETUP +#line 85 "cfg_file.l" +{ lineno++; } /* Skip comments */ + YY_BREAK +case 4: +YY_RULE_SETUP +#line 87 "cfg_file.l" +{ + int kw = find_keyword(cfg_keyword,yytext); + if( kw != -1 ) + return kw; + + /* Keyword not found, means host definition. */ + yylval.str = yytext; + return K_HOST; + } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 97 "cfg_file.l" +{ + yylval.str = yytext; + return K_ERROR; + } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 102 "cfg_file.l" +{ + PUSH_STATE(); + BEGIN(OPTION); + return *yytext; + } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 107 "cfg_file.l" +{ + POP_STATE(); + return *yytext; + } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 112 "cfg_file.l" +{ + int kw = find_keyword(cfg_keyword,yytext); + if( kw != -1 ){ + /* Option found, switch to PARAM stage */ + PUSH_STATE(); + BEGIN(PARAM); + return kw; + } + yylval.str = yytext; + return K_ERROR; + } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 124 "cfg_file.l" +{ + if(yyleng > sizeof(str_buf)-1){ + yyerror("string to long"); + return 0; + } + strncpy(str_buf, yytext+1, yyleng-2); + str_buf[yyleng-2] = '\0'; + + yylval.str = str_buf; + + return STRING; + } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 137 "cfg_file.l" +{ + char *ptr = strchr(yytext,':') + 1; + + yylval.dnum.num1 = atoi(yytext); + yylval.dnum.num2 = atoi(ptr); + return DNUM; + } + YY_BREAK +case 11: +YY_RULE_SETUP +#line 145 "cfg_file.l" +{ + yylval.num = atoi(yytext); + return NUM; + } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 150 "cfg_file.l" +{ + int kw = find_keyword(cfg_param,yytext); + if( kw != -1 ){ + /* Special parameter found (yes,no,etc) */ + yylval.num = kw; + return NUM; + } + yylval.str = yytext; + return WORD; + } + YY_BREAK +case 13: +YY_RULE_SETUP +#line 161 "cfg_file.l" +{ + char *ptr = strchr(yytext,':'); *ptr='\0'; + yylval.dnum.num1 = find_keyword(cfg_param,yytext); + yylval.dnum.num2 = atoi(++ptr); + return DNUM; + } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 168 "cfg_file.l" +{ + yylval.str = yytext; + return PATH; + } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 173 "cfg_file.l" +{ + POP_STATE(); + } + YY_BREAK +case 16: +YY_RULE_SETUP +#line 177 "cfg_file.l" +{ /* Garbage (All stages) */ + cfg_error("Invalid character \'%s\'", yytext); + } + YY_BREAK +case 17: +YY_RULE_SETUP +#line 180 "cfg_file.l" +ECHO; + YY_BREAK +#line 973 "" +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(OPTION): +case YY_STATE_EOF(PARAM): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = (yy_c_buf_p); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ +} /* end of yylex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (void) +{ + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = (yytext_ptr); + int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (void) +{ + yy_state_type yy_current_state; + char *yy_cp; + + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 41 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +{ + int yy_is_jam; + char *yy_cp = (yy_c_buf_p); + + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 41 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 40); + + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_UNPUT + + static void yyunput (int c, char * yy_bp ) +{ + char *yy_cp; + + yy_cp = (yy_c_buf_p); + + /* undo effects of setting up yytext */ + *yy_cp = (yy_hold_char); + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + int number_to_move = (yy_n_chars) + 2; + char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + char *source = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = + (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + (yytext_ptr) = yy_bp; + (yy_hold_char) = *yy_cp; + (yy_c_buf_p) = yy_cp; +} + +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return 0; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +static void yy_load_buffer_state (void) +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree( (void *) b->yy_ch_buf ); + + yyfree( (void *) b ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) + +{ + int oerrno = errno; + + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void yypop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (void) +{ + yy_size_t num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return NULL; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (const char * yystr ) +{ + + return yy_scan_bytes( yystr, (int) strlen(yystr) ); +} + +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yynoreturn yy_fatal_error (const char* msg ) +{ + fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} + +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} + +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} + +/** Get the length of the current token. + * + */ +int yyget_leng (void) +{ + return yyleng; +} + +/** Get the current token. + * + */ + +char *yyget_text (void) +{ + return yytext; +} + +/** Set the current line number. + * @param _line_number line number + * + */ +void yyset_lineno (int _line_number ) +{ + + yylineno = _line_number; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param _in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * _in_str ) +{ + yyin = _in_str ; +} + +void yyset_out (FILE * _out_str ) +{ + yyout = _out_str ; +} + +int yyget_debug (void) +{ + return yy_flex_debug; +} + +void yyset_debug (int _bdebug ) +{ + yy_flex_debug = _bdebug ; +} + +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + (yy_buffer_stack) = NULL; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = NULL; + (yy_init) = 0; + (yy_start) = 0; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = NULL; + yyout = NULL; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} + +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer( YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } + + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( ); + + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, const char * s2, int n ) +{ + + int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (const char * s ) +{ + int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size ) +{ + return malloc(size); +} + +void *yyrealloc (void * ptr, yy_size_t size ) +{ + + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return realloc(ptr, size); +} + +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 180 "cfg_file.l" + + +int yywrap(void) +{ + return 1; +} + +int find_keyword(struct kword *kw, char *str) +{ + while( kw->str ){ + if( !strncmp(str,kw->str,20) ) + return kw->type; + kw++; + } + return -1; +} + diff --git a/cfg_file.tab.h b/cfg_file.tab.h new file mode 100644 index 0000000..949113e --- /dev/null +++ b/cfg_file.tab.h @@ -0,0 +1,163 @@ +/* A Bison parser, made by GNU Bison 3.8.2. */ + +/* Bison interface for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, + Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, + especially those whose name start with YY_ or yy_. They are + private implementation details that can be changed or removed. */ + +#ifndef YY_YY_CFG_FILE_TAB_H_INCLUDED +# define YY_YY_CFG_FILE_TAB_H_INCLUDED +/* Debug traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif +#if YYDEBUG +extern int yydebug; +#endif + +/* Token kinds. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + enum yytokentype + { + YYEMPTY = -2, + YYEOF = 0, /* "end of file" */ + YYerror = 256, /* error */ + YYUNDEF = 257, /* "invalid token" */ + K_OPTIONS = 258, /* K_OPTIONS */ + K_DEFAULT = 259, /* K_DEFAULT */ + K_PORT = 260, /* K_PORT */ + K_BINDADDR = 261, /* K_BINDADDR */ + K_PERSIST = 262, /* K_PERSIST */ + K_TIMEOUT = 263, /* K_TIMEOUT */ + K_PASSWD = 264, /* K_PASSWD */ + K_PROG = 265, /* K_PROG */ + K_PPP = 266, /* K_PPP */ + K_SPEED = 267, /* K_SPEED */ + K_IFCFG = 268, /* K_IFCFG */ + K_FWALL = 269, /* K_FWALL */ + K_ROUTE = 270, /* K_ROUTE */ + K_DEVICE = 271, /* K_DEVICE */ + K_MULTI = 272, /* K_MULTI */ + K_SRCADDR = 273, /* K_SRCADDR */ + K_IFACE = 274, /* K_IFACE */ + K_ADDR = 275, /* K_ADDR */ + K_TYPE = 276, /* K_TYPE */ + K_PROT = 277, /* K_PROT */ + K_NAT_HACK = 278, /* K_NAT_HACK */ + K_COMPRESS = 279, /* K_COMPRESS */ + K_ENCRYPT = 280, /* K_ENCRYPT */ + K_KALIVE = 281, /* K_KALIVE */ + K_STAT = 282, /* K_STAT */ + K_UP = 283, /* K_UP */ + K_DOWN = 284, /* K_DOWN */ + K_SYSLOG = 285, /* K_SYSLOG */ + K_IPROUTE = 286, /* K_IPROUTE */ + K_HOST = 287, /* K_HOST */ + K_ERROR = 288, /* K_ERROR */ + WORD = 289, /* WORD */ + PATH = 290, /* PATH */ + STRING = 291, /* STRING */ + NUM = 292, /* NUM */ + DNUM = 293 /* DNUM */ + }; + typedef enum yytokentype yytoken_kind_t; +#endif +/* Token kinds. */ +#define YYEMPTY -2 +#define YYEOF 0 +#define YYerror 256 +#define YYUNDEF 257 +#define K_OPTIONS 258 +#define K_DEFAULT 259 +#define K_PORT 260 +#define K_BINDADDR 261 +#define K_PERSIST 262 +#define K_TIMEOUT 263 +#define K_PASSWD 264 +#define K_PROG 265 +#define K_PPP 266 +#define K_SPEED 267 +#define K_IFCFG 268 +#define K_FWALL 269 +#define K_ROUTE 270 +#define K_DEVICE 271 +#define K_MULTI 272 +#define K_SRCADDR 273 +#define K_IFACE 274 +#define K_ADDR 275 +#define K_TYPE 276 +#define K_PROT 277 +#define K_NAT_HACK 278 +#define K_COMPRESS 279 +#define K_ENCRYPT 280 +#define K_KALIVE 281 +#define K_STAT 282 +#define K_UP 283 +#define K_DOWN 284 +#define K_SYSLOG 285 +#define K_IPROUTE 286 +#define K_HOST 287 +#define K_ERROR 288 +#define WORD 289 +#define PATH 290 +#define STRING 291 +#define NUM 292 +#define DNUM 293 + +/* Value type. */ +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +union YYSTYPE +{ +#line 68 "cfg_file.y" + + char *str; + int num; + struct { int num1; int num2; } dnum; + +#line 149 "cfg_file.tab.h" + +}; +typedef union YYSTYPE YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define YYSTYPE_IS_DECLARED 1 +#endif + + +extern YYSTYPE yylval; + + +int yyparse (void); + + +#endif /* !YY_YY_CFG_FILE_TAB_H_INCLUDED */ diff --git a/lfd_shaper.c b/lfd_shaper.c index 12799ca..9ba9b48 100644 --- a/lfd_shaper.c +++ b/lfd_shaper.c @@ -25,6 +25,7 @@ #include #include #include +#include #include #include diff --git a/lib.c b/lib.c index daf517e..ce89c70 100644 --- a/lib.c +++ b/lib.c @@ -33,6 +33,7 @@ #include #include #include +#include #include #include "vtun.h" diff --git a/lib.h b/lib.h index c660be6..cd1c5d9 100644 --- a/lib.h +++ b/lib.h @@ -27,6 +27,7 @@ #include #include #include +#include #ifdef HAVE_LIBUTIL_H #include diff --git a/lock.c b/lock.c index a4c8065..7d22b38 100644 --- a/lock.c +++ b/lock.c @@ -27,7 +27,7 @@ #include #include #include -#include +#include #include #include #include