Annotation of embedaddon/ipsec-tools/src/libipsec/policy_parse.c, revision 1.1
1.1 ! misho 1:
! 2: /* A Bison parser, made by GNU Bison 2.4.1. */
! 3:
! 4: /* Skeleton implementation for Bison's Yacc-like parsers in C
! 5:
! 6: Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
! 7: Free Software Foundation, Inc.
! 8:
! 9: This program is free software: you can redistribute it and/or modify
! 10: it under the terms of the GNU General Public License as published by
! 11: the Free Software Foundation, either version 3 of the License, or
! 12: (at your option) any later version.
! 13:
! 14: This program is distributed in the hope that it will be useful,
! 15: but WITHOUT ANY WARRANTY; without even the implied warranty of
! 16: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 17: GNU General Public License for more details.
! 18:
! 19: You should have received a copy of the GNU General Public License
! 20: along with this program. If not, see <http://www.gnu.org/licenses/>. */
! 21:
! 22: /* As a special exception, you may create a larger work that contains
! 23: part or all of the Bison parser skeleton and distribute that work
! 24: under terms of your choice, so long as that work isn't itself a
! 25: parser generator using the skeleton or a modified version thereof
! 26: as a parser skeleton. Alternatively, if you modify or redistribute
! 27: the parser skeleton itself, you may (at your option) remove this
! 28: special exception, which will cause the skeleton and the resulting
! 29: Bison output files to be licensed under the GNU General Public
! 30: License without this special exception.
! 31:
! 32: This special exception was added by the Free Software Foundation in
! 33: version 2.2 of Bison. */
! 34:
! 35: /* C LALR(1) parser skeleton written by Richard Stallman, by
! 36: simplifying the original so-called "semantic" parser. */
! 37:
! 38: /* All symbols defined below should begin with yy or YY, to avoid
! 39: infringing on user name space. This should be done even for local
! 40: variables, as they might otherwise be expanded by user macros.
! 41: There are some unavoidable exceptions within include files to
! 42: define necessary library symbols; they are noted "INFRINGES ON
! 43: USER NAME SPACE" below. */
! 44:
! 45: /* Identify Bison output. */
! 46: #define YYBISON 1
! 47:
! 48: /* Bison version. */
! 49: #define YYBISON_VERSION "2.4.1"
! 50:
! 51: /* Skeleton name. */
! 52: #define YYSKELETON_NAME "yacc.c"
! 53:
! 54: /* Pure parsers. */
! 55: #define YYPURE 0
! 56:
! 57: /* Push parsers. */
! 58: #define YYPUSH 0
! 59:
! 60: /* Pull parsers. */
! 61: #define YYPULL 1
! 62:
! 63: /* Using locations. */
! 64: #define YYLSP_NEEDED 0
! 65:
! 66: /* Substitute the variable and function names. */
! 67: #define yyparse __libipsecparse
! 68: #define yylex __libipseclex
! 69: #define yyerror __libipsecerror
! 70: #define yylval __libipseclval
! 71: #define yychar __libipsecchar
! 72: #define yydebug __libipsecdebug
! 73: #define yynerrs __libipsecnerrs
! 74:
! 75:
! 76: /* Copy the first part of user declarations. */
! 77:
! 78: /* Line 189 of yacc.c */
! 79: #line 65 "policy_parse.y"
! 80:
! 81: #ifdef HAVE_CONFIG_H
! 82: #include "config.h"
! 83: #endif
! 84:
! 85: #include <sys/types.h>
! 86: #include <sys/param.h>
! 87: #include <sys/socket.h>
! 88:
! 89: #include <netinet/in.h>
! 90: #include PATH_IPSEC_H
! 91:
! 92: #include <stdlib.h>
! 93: #include <stdio.h>
! 94: #include <string.h>
! 95: #include <netdb.h>
! 96:
! 97: #include <errno.h>
! 98:
! 99: #include "config.h"
! 100:
! 101: #include "ipsec_strerror.h"
! 102: #include "libpfkey.h"
! 103:
! 104: #ifndef INT32_MAX
! 105: #define INT32_MAX (0xffffffff)
! 106: #endif
! 107:
! 108: #ifndef INT32_MIN
! 109: #define INT32_MIN (-INT32_MAX-1)
! 110: #endif
! 111:
! 112: #define ATOX(c) \
! 113: (isdigit(c) ? (c - '0') : (isupper(c) ? (c - 'A' + 10) : (c - 'a' + 10) ))
! 114:
! 115: static u_int8_t *pbuf = NULL; /* sadb_x_policy buffer */
! 116: static int tlen = 0; /* total length of pbuf */
! 117: static int offset = 0; /* offset of pbuf */
! 118: static int p_dir, p_type, p_protocol, p_mode, p_level, p_reqid;
! 119: static u_int32_t p_priority = 0;
! 120: static long p_priority_offset = 0;
! 121: static struct sockaddr *p_src = NULL;
! 122: static struct sockaddr *p_dst = NULL;
! 123:
! 124: struct _val;
! 125: extern void yyerror __P((char *msg));
! 126: static struct sockaddr *parse_sockaddr __P((struct _val *addrbuf,
! 127: struct _val *portbuf));
! 128: static int rule_check __P((void));
! 129: static int init_x_policy __P((void));
! 130: static int set_x_request __P((struct sockaddr *, struct sockaddr *));
! 131: static int set_sockaddr __P((struct sockaddr *));
! 132: static void policy_parse_request_init __P((void));
! 133: static void *policy_parse __P((const char *, int));
! 134:
! 135: extern void __policy__strbuffer__init__ __P((const char *));
! 136: extern void __policy__strbuffer__free__ __P((void));
! 137: extern int yyparse __P((void));
! 138: extern int yylex __P((void));
! 139:
! 140: extern char *__libipsectext; /*XXX*/
! 141:
! 142:
! 143:
! 144: /* Line 189 of yacc.c */
! 145: #line 146 "policy_parse.c"
! 146:
! 147: /* Enabling traces. */
! 148: #ifndef YYDEBUG
! 149: # define YYDEBUG 0
! 150: #endif
! 151:
! 152: /* Enabling verbose error messages. */
! 153: #ifdef YYERROR_VERBOSE
! 154: # undef YYERROR_VERBOSE
! 155: # define YYERROR_VERBOSE 1
! 156: #else
! 157: # define YYERROR_VERBOSE 0
! 158: #endif
! 159:
! 160: /* Enabling the token table. */
! 161: #ifndef YYTOKEN_TABLE
! 162: # define YYTOKEN_TABLE 0
! 163: #endif
! 164:
! 165:
! 166: /* Tokens. */
! 167: #ifndef YYTOKENTYPE
! 168: # define YYTOKENTYPE
! 169: /* Put the tokens into the symbol table, so that GDB and other debuggers
! 170: know about them. */
! 171: enum yytokentype {
! 172: DIR = 258,
! 173: PRIORITY = 259,
! 174: PLUS = 260,
! 175: PRIO_BASE = 261,
! 176: PRIO_OFFSET = 262,
! 177: ACTION = 263,
! 178: PROTOCOL = 264,
! 179: MODE = 265,
! 180: LEVEL = 266,
! 181: LEVEL_SPECIFY = 267,
! 182: IPADDRESS = 268,
! 183: PORT = 269,
! 184: ME = 270,
! 185: ANY = 271,
! 186: SLASH = 272,
! 187: HYPHEN = 273
! 188: };
! 189: #endif
! 190: /* Tokens. */
! 191: #define DIR 258
! 192: #define PRIORITY 259
! 193: #define PLUS 260
! 194: #define PRIO_BASE 261
! 195: #define PRIO_OFFSET 262
! 196: #define ACTION 263
! 197: #define PROTOCOL 264
! 198: #define MODE 265
! 199: #define LEVEL 266
! 200: #define LEVEL_SPECIFY 267
! 201: #define IPADDRESS 268
! 202: #define PORT 269
! 203: #define ME 270
! 204: #define ANY 271
! 205: #define SLASH 272
! 206: #define HYPHEN 273
! 207:
! 208:
! 209:
! 210:
! 211: #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
! 212: typedef union YYSTYPE
! 213: {
! 214:
! 215: /* Line 214 of yacc.c */
! 216: #line 129 "policy_parse.y"
! 217:
! 218: u_int num;
! 219: u_int32_t num32;
! 220: struct _val {
! 221: int len;
! 222: char *buf;
! 223: } val;
! 224:
! 225:
! 226:
! 227: /* Line 214 of yacc.c */
! 228: #line 229 "policy_parse.c"
! 229: } YYSTYPE;
! 230: # define YYSTYPE_IS_TRIVIAL 1
! 231: # define yystype YYSTYPE /* obsolescent; will be withdrawn */
! 232: # define YYSTYPE_IS_DECLARED 1
! 233: #endif
! 234:
! 235:
! 236: /* Copy the second part of user declarations. */
! 237:
! 238:
! 239: /* Line 264 of yacc.c */
! 240: #line 241 "policy_parse.c"
! 241:
! 242: #ifdef short
! 243: # undef short
! 244: #endif
! 245:
! 246: #ifdef YYTYPE_UINT8
! 247: typedef YYTYPE_UINT8 yytype_uint8;
! 248: #else
! 249: typedef unsigned char yytype_uint8;
! 250: #endif
! 251:
! 252: #ifdef YYTYPE_INT8
! 253: typedef YYTYPE_INT8 yytype_int8;
! 254: #elif (defined __STDC__ || defined __C99__FUNC__ \
! 255: || defined __cplusplus || defined _MSC_VER)
! 256: typedef signed char yytype_int8;
! 257: #else
! 258: typedef short int yytype_int8;
! 259: #endif
! 260:
! 261: #ifdef YYTYPE_UINT16
! 262: typedef YYTYPE_UINT16 yytype_uint16;
! 263: #else
! 264: typedef unsigned short int yytype_uint16;
! 265: #endif
! 266:
! 267: #ifdef YYTYPE_INT16
! 268: typedef YYTYPE_INT16 yytype_int16;
! 269: #else
! 270: typedef short int yytype_int16;
! 271: #endif
! 272:
! 273: #ifndef YYSIZE_T
! 274: # ifdef __SIZE_TYPE__
! 275: # define YYSIZE_T __SIZE_TYPE__
! 276: # elif defined size_t
! 277: # define YYSIZE_T size_t
! 278: # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
! 279: || defined __cplusplus || defined _MSC_VER)
! 280: # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
! 281: # define YYSIZE_T size_t
! 282: # else
! 283: # define YYSIZE_T unsigned int
! 284: # endif
! 285: #endif
! 286:
! 287: #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
! 288:
! 289: #ifndef YY_
! 290: # if YYENABLE_NLS
! 291: # if ENABLE_NLS
! 292: # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
! 293: # define YY_(msgid) dgettext ("bison-runtime", msgid)
! 294: # endif
! 295: # endif
! 296: # ifndef YY_
! 297: # define YY_(msgid) msgid
! 298: # endif
! 299: #endif
! 300:
! 301: /* Suppress unused-variable warnings by "using" E. */
! 302: #if ! defined lint || defined __GNUC__
! 303: # define YYUSE(e) ((void) (e))
! 304: #else
! 305: # define YYUSE(e) /* empty */
! 306: #endif
! 307:
! 308: /* Identity function, used to suppress warnings about constant conditions. */
! 309: #ifndef lint
! 310: # define YYID(n) (n)
! 311: #else
! 312: #if (defined __STDC__ || defined __C99__FUNC__ \
! 313: || defined __cplusplus || defined _MSC_VER)
! 314: static int
! 315: YYID (int yyi)
! 316: #else
! 317: static int
! 318: YYID (yyi)
! 319: int yyi;
! 320: #endif
! 321: {
! 322: return yyi;
! 323: }
! 324: #endif
! 325:
! 326: #if ! defined yyoverflow || YYERROR_VERBOSE
! 327:
! 328: /* The parser invokes alloca or malloc; define the necessary symbols. */
! 329:
! 330: # ifdef YYSTACK_USE_ALLOCA
! 331: # if YYSTACK_USE_ALLOCA
! 332: # ifdef __GNUC__
! 333: # define YYSTACK_ALLOC __builtin_alloca
! 334: # elif defined __BUILTIN_VA_ARG_INCR
! 335: # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
! 336: # elif defined _AIX
! 337: # define YYSTACK_ALLOC __alloca
! 338: # elif defined _MSC_VER
! 339: # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
! 340: # define alloca _alloca
! 341: # else
! 342: # define YYSTACK_ALLOC alloca
! 343: # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
! 344: || defined __cplusplus || defined _MSC_VER)
! 345: # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
! 346: # ifndef _STDLIB_H
! 347: # define _STDLIB_H 1
! 348: # endif
! 349: # endif
! 350: # endif
! 351: # endif
! 352: # endif
! 353:
! 354: # ifdef YYSTACK_ALLOC
! 355: /* Pacify GCC's `empty if-body' warning. */
! 356: # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
! 357: # ifndef YYSTACK_ALLOC_MAXIMUM
! 358: /* The OS might guarantee only one guard page at the bottom of the stack,
! 359: and a page size can be as small as 4096 bytes. So we cannot safely
! 360: invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
! 361: to allow for a few compiler-allocated temporary stack slots. */
! 362: # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
! 363: # endif
! 364: # else
! 365: # define YYSTACK_ALLOC YYMALLOC
! 366: # define YYSTACK_FREE YYFREE
! 367: # ifndef YYSTACK_ALLOC_MAXIMUM
! 368: # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
! 369: # endif
! 370: # if (defined __cplusplus && ! defined _STDLIB_H \
! 371: && ! ((defined YYMALLOC || defined malloc) \
! 372: && (defined YYFREE || defined free)))
! 373: # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
! 374: # ifndef _STDLIB_H
! 375: # define _STDLIB_H 1
! 376: # endif
! 377: # endif
! 378: # ifndef YYMALLOC
! 379: # define YYMALLOC malloc
! 380: # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
! 381: || defined __cplusplus || defined _MSC_VER)
! 382: void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
! 383: # endif
! 384: # endif
! 385: # ifndef YYFREE
! 386: # define YYFREE free
! 387: # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
! 388: || defined __cplusplus || defined _MSC_VER)
! 389: void free (void *); /* INFRINGES ON USER NAME SPACE */
! 390: # endif
! 391: # endif
! 392: # endif
! 393: #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
! 394:
! 395:
! 396: #if (! defined yyoverflow \
! 397: && (! defined __cplusplus \
! 398: || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
! 399:
! 400: /* A type that is properly aligned for any stack member. */
! 401: union yyalloc
! 402: {
! 403: yytype_int16 yyss_alloc;
! 404: YYSTYPE yyvs_alloc;
! 405: };
! 406:
! 407: /* The size of the maximum gap between one aligned stack and the next. */
! 408: # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
! 409:
! 410: /* The size of an array large to enough to hold all stacks, each with
! 411: N elements. */
! 412: # define YYSTACK_BYTES(N) \
! 413: ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
! 414: + YYSTACK_GAP_MAXIMUM)
! 415:
! 416: /* Copy COUNT objects from FROM to TO. The source and destination do
! 417: not overlap. */
! 418: # ifndef YYCOPY
! 419: # if defined __GNUC__ && 1 < __GNUC__
! 420: # define YYCOPY(To, From, Count) \
! 421: __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
! 422: # else
! 423: # define YYCOPY(To, From, Count) \
! 424: do \
! 425: { \
! 426: YYSIZE_T yyi; \
! 427: for (yyi = 0; yyi < (Count); yyi++) \
! 428: (To)[yyi] = (From)[yyi]; \
! 429: } \
! 430: while (YYID (0))
! 431: # endif
! 432: # endif
! 433:
! 434: /* Relocate STACK from its old location to the new one. The
! 435: local variables YYSIZE and YYSTACKSIZE give the old and new number of
! 436: elements in the stack, and YYPTR gives the new location of the
! 437: stack. Advance YYPTR to a properly aligned location for the next
! 438: stack. */
! 439: # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
! 440: do \
! 441: { \
! 442: YYSIZE_T yynewbytes; \
! 443: YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
! 444: Stack = &yyptr->Stack_alloc; \
! 445: yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
! 446: yyptr += yynewbytes / sizeof (*yyptr); \
! 447: } \
! 448: while (YYID (0))
! 449:
! 450: #endif
! 451:
! 452: /* YYFINAL -- State number of the termination state. */
! 453: #define YYFINAL 5
! 454: /* YYLAST -- Last index in YYTABLE. */
! 455: #define YYLAST 48
! 456:
! 457: /* YYNTOKENS -- Number of terminals. */
! 458: #define YYNTOKENS 19
! 459: /* YYNNTS -- Number of nonterminals. */
! 460: #define YYNNTS 16
! 461: /* YYNRULES -- Number of rules. */
! 462: #define YYNRULES 34
! 463: /* YYNRULES -- Number of states. */
! 464: #define YYNSTATES 60
! 465:
! 466: /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
! 467: #define YYUNDEFTOK 2
! 468: #define YYMAXUTOK 273
! 469:
! 470: #define YYTRANSLATE(YYX) \
! 471: ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
! 472:
! 473: /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
! 474: static const yytype_uint8 yytranslate[] =
! 475: {
! 476: 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 477: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 478: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 479: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 480: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 481: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 482: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 483: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 484: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 485: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 486: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 487: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 488: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 489: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 490: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 491: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 492: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 493: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 494: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 495: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 496: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 497: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 498: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 499: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 500: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 501: 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
! 502: 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
! 503: 15, 16, 17, 18
! 504: };
! 505:
! 506: #if YYDEBUG
! 507: /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
! 508: YYRHS. */
! 509: static const yytype_uint8 yyprhs[] =
! 510: {
! 511: 0, 0, 3, 4, 9, 10, 17, 18, 26, 27,
! 512: 34, 35, 44, 45, 54, 56, 57, 60, 68, 75,
! 513: 81, 86, 93, 97, 100, 102, 104, 106, 108, 110,
! 514: 111, 116, 117, 124, 128
! 515: };
! 516:
! 517: /* YYRHS -- A `-1'-separated list of the rules' RHS. */
! 518: static const yytype_int8 yyrhs[] =
! 519: {
! 520: 20, 0, -1, -1, 3, 8, 21, 27, -1, -1,
! 521: 3, 4, 7, 8, 22, 27, -1, -1, 3, 4,
! 522: 18, 7, 8, 23, 27, -1, -1, 3, 4, 6,
! 523: 8, 24, 27, -1, -1, 3, 4, 6, 5, 7,
! 524: 8, 25, 27, -1, -1, 3, 4, 6, 18, 7,
! 525: 8, 26, 27, -1, 3, -1, -1, 27, 28, -1,
! 526: 29, 17, 30, 17, 32, 17, 31, -1, 29, 17,
! 527: 30, 17, 32, 17, -1, 29, 17, 30, 17, 32,
! 528: -1, 29, 17, 30, 17, -1, 29, 17, 30, 17,
! 529: 17, 31, -1, 29, 17, 30, -1, 29, 17, -1,
! 530: 29, -1, 9, -1, 10, -1, 11, -1, 12, -1,
! 531: -1, 13, 33, 18, 13, -1, -1, 13, 14, 34,
! 532: 18, 13, 14, -1, 15, 18, 16, -1, 16, 18,
! 533: 15, -1
! 534: };
! 535:
! 536: /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
! 537: static const yytype_uint16 yyrline[] =
! 538: {
! 539: 0, 151, 151, 150, 166, 165, 185, 184, 207, 206,
! 540: 218, 217, 240, 239, 261, 273, 275, 287, 288, 289,
! 541: 290, 291, 292, 293, 297, 304, 308, 312, 316, 323,
! 542: 323, 334, 334, 345, 351
! 543: };
! 544: #endif
! 545:
! 546: #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
! 547: /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
! 548: First, the terminals, then, starting at YYNTOKENS, nonterminals. */
! 549: static const char *const yytname[] =
! 550: {
! 551: "$end", "error", "$undefined", "DIR", "PRIORITY", "PLUS", "PRIO_BASE",
! 552: "PRIO_OFFSET", "ACTION", "PROTOCOL", "MODE", "LEVEL", "LEVEL_SPECIFY",
! 553: "IPADDRESS", "PORT", "ME", "ANY", "SLASH", "HYPHEN", "$accept",
! 554: "policy_spec", "$@1", "$@2", "$@3", "$@4", "$@5", "$@6", "rules", "rule",
! 555: "protocol", "mode", "level", "addresses", "$@7", "$@8", 0
! 556: };
! 557: #endif
! 558:
! 559: # ifdef YYPRINT
! 560: /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
! 561: token YYLEX-NUM. */
! 562: static const yytype_uint16 yytoknum[] =
! 563: {
! 564: 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
! 565: 265, 266, 267, 268, 269, 270, 271, 272, 273
! 566: };
! 567: # endif
! 568:
! 569: /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
! 570: static const yytype_uint8 yyr1[] =
! 571: {
! 572: 0, 19, 21, 20, 22, 20, 23, 20, 24, 20,
! 573: 25, 20, 26, 20, 20, 27, 27, 28, 28, 28,
! 574: 28, 28, 28, 28, 28, 29, 30, 31, 31, 33,
! 575: 32, 34, 32, 32, 32
! 576: };
! 577:
! 578: /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
! 579: static const yytype_uint8 yyr2[] =
! 580: {
! 581: 0, 2, 0, 4, 0, 6, 0, 7, 0, 6,
! 582: 0, 8, 0, 8, 1, 0, 2, 7, 6, 5,
! 583: 4, 6, 3, 2, 1, 1, 1, 1, 1, 0,
! 584: 4, 0, 6, 3, 3
! 585: };
! 586:
! 587: /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
! 588: STATE-NUM when YYTABLE doesn't specify something else to do. Zero
! 589: means the default is an error. */
! 590: static const yytype_uint8 yydefact[] =
! 591: {
! 592: 0, 14, 0, 0, 2, 1, 0, 0, 0, 15,
! 593: 0, 8, 0, 4, 0, 3, 0, 15, 0, 15,
! 594: 6, 25, 16, 24, 10, 9, 12, 5, 15, 23,
! 595: 15, 15, 7, 26, 22, 11, 13, 20, 29, 0,
! 596: 0, 0, 19, 31, 0, 0, 0, 27, 28, 21,
! 597: 18, 0, 0, 33, 34, 17, 0, 30, 0, 32
! 598: };
! 599:
! 600: /* YYDEFGOTO[NTERM-NUM]. */
! 601: static const yytype_int8 yydefgoto[] =
! 602: {
! 603: -1, 2, 9, 19, 28, 17, 30, 31, 15, 22,
! 604: 23, 34, 49, 42, 44, 51
! 605: };
! 606:
! 607: /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
! 608: STATE-NUM. */
! 609: #define YYPACT_NINF -18
! 610: static const yytype_int8 yypact[] =
! 611: {
! 612: 6, -3, 4, 1, -18, -18, -2, 2, 8, -18,
! 613: 10, -18, 18, -18, 19, 3, 20, -18, 21, -18,
! 614: -18, -18, -18, 9, -18, 3, -18, 3, -18, 22,
! 615: -18, -18, 3, -18, 13, 3, 3, 5, 17, 15,
! 616: 16, 12, 23, -18, 24, 25, 28, -18, -18, -18,
! 617: 12, 26, 32, -18, -18, -18, 33, -18, 34, -18
! 618: };
! 619:
! 620: /* YYPGOTO[NTERM-NUM]. */
! 621: static const yytype_int8 yypgoto[] =
! 622: {
! 623: -18, -18, -18, -18, -18, -18, -18, -18, -17, -18,
! 624: -18, -18, -15, -18, -18, -18
! 625: };
! 626:
! 627: /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
! 628: positive, shift that token. If negative, reduce the rule which
! 629: number is the opposite. If zero, do what YYDEFACT says.
! 630: If YYTABLE_NINF, syntax error. */
! 631: #define YYTABLE_NINF -1
! 632: static const yytype_uint8 yytable[] =
! 633: {
! 634: 25, 3, 27, 10, 5, 4, 11, 6, 7, 1,
! 635: 13, 32, 21, 35, 36, 14, 12, 16, 38, 8,
! 636: 39, 40, 41, 47, 48, 18, 29, 20, 24, 26,
! 637: 37, 43, 33, 45, 46, 55, 0, 0, 0, 0,
! 638: 50, 53, 52, 54, 56, 57, 58, 0, 59
! 639: };
! 640:
! 641: static const yytype_int8 yycheck[] =
! 642: {
! 643: 17, 4, 19, 5, 0, 8, 8, 6, 7, 3,
! 644: 8, 28, 9, 30, 31, 7, 18, 7, 13, 18,
! 645: 15, 16, 17, 11, 12, 7, 17, 8, 8, 8,
! 646: 17, 14, 10, 18, 18, 50, -1, -1, -1, -1,
! 647: 17, 16, 18, 15, 18, 13, 13, -1, 14
! 648: };
! 649:
! 650: /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
! 651: symbol of state STATE-NUM. */
! 652: static const yytype_uint8 yystos[] =
! 653: {
! 654: 0, 3, 20, 4, 8, 0, 6, 7, 18, 21,
! 655: 5, 8, 18, 8, 7, 27, 7, 24, 7, 22,
! 656: 8, 9, 28, 29, 8, 27, 8, 27, 23, 17,
! 657: 25, 26, 27, 10, 30, 27, 27, 17, 13, 15,
! 658: 16, 17, 32, 14, 33, 18, 18, 11, 12, 31,
! 659: 17, 34, 18, 16, 15, 31, 18, 13, 13, 14
! 660: };
! 661:
! 662: #define yyerrok (yyerrstatus = 0)
! 663: #define yyclearin (yychar = YYEMPTY)
! 664: #define YYEMPTY (-2)
! 665: #define YYEOF 0
! 666:
! 667: #define YYACCEPT goto yyacceptlab
! 668: #define YYABORT goto yyabortlab
! 669: #define YYERROR goto yyerrorlab
! 670:
! 671:
! 672: /* Like YYERROR except do call yyerror. This remains here temporarily
! 673: to ease the transition to the new meaning of YYERROR, for GCC.
! 674: Once GCC version 2 has supplanted version 1, this can go. */
! 675:
! 676: #define YYFAIL goto yyerrlab
! 677:
! 678: #define YYRECOVERING() (!!yyerrstatus)
! 679:
! 680: #define YYBACKUP(Token, Value) \
! 681: do \
! 682: if (yychar == YYEMPTY && yylen == 1) \
! 683: { \
! 684: yychar = (Token); \
! 685: yylval = (Value); \
! 686: yytoken = YYTRANSLATE (yychar); \
! 687: YYPOPSTACK (1); \
! 688: goto yybackup; \
! 689: } \
! 690: else \
! 691: { \
! 692: yyerror (YY_("syntax error: cannot back up")); \
! 693: YYERROR; \
! 694: } \
! 695: while (YYID (0))
! 696:
! 697:
! 698: #define YYTERROR 1
! 699: #define YYERRCODE 256
! 700:
! 701:
! 702: /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
! 703: If N is 0, then set CURRENT to the empty location which ends
! 704: the previous symbol: RHS[0] (always defined). */
! 705:
! 706: #define YYRHSLOC(Rhs, K) ((Rhs)[K])
! 707: #ifndef YYLLOC_DEFAULT
! 708: # define YYLLOC_DEFAULT(Current, Rhs, N) \
! 709: do \
! 710: if (YYID (N)) \
! 711: { \
! 712: (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
! 713: (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
! 714: (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
! 715: (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
! 716: } \
! 717: else \
! 718: { \
! 719: (Current).first_line = (Current).last_line = \
! 720: YYRHSLOC (Rhs, 0).last_line; \
! 721: (Current).first_column = (Current).last_column = \
! 722: YYRHSLOC (Rhs, 0).last_column; \
! 723: } \
! 724: while (YYID (0))
! 725: #endif
! 726:
! 727:
! 728: /* YY_LOCATION_PRINT -- Print the location on the stream.
! 729: This macro was not mandated originally: define only if we know
! 730: we won't break user code: when these are the locations we know. */
! 731:
! 732: #ifndef YY_LOCATION_PRINT
! 733: # if YYLTYPE_IS_TRIVIAL
! 734: # define YY_LOCATION_PRINT(File, Loc) \
! 735: fprintf (File, "%d.%d-%d.%d", \
! 736: (Loc).first_line, (Loc).first_column, \
! 737: (Loc).last_line, (Loc).last_column)
! 738: # else
! 739: # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
! 740: # endif
! 741: #endif
! 742:
! 743:
! 744: /* YYLEX -- calling `yylex' with the right arguments. */
! 745:
! 746: #ifdef YYLEX_PARAM
! 747: # define YYLEX yylex (YYLEX_PARAM)
! 748: #else
! 749: # define YYLEX yylex ()
! 750: #endif
! 751:
! 752: /* Enable debugging if requested. */
! 753: #if YYDEBUG
! 754:
! 755: # ifndef YYFPRINTF
! 756: # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
! 757: # define YYFPRINTF fprintf
! 758: # endif
! 759:
! 760: # define YYDPRINTF(Args) \
! 761: do { \
! 762: if (yydebug) \
! 763: YYFPRINTF Args; \
! 764: } while (YYID (0))
! 765:
! 766: # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
! 767: do { \
! 768: if (yydebug) \
! 769: { \
! 770: YYFPRINTF (stderr, "%s ", Title); \
! 771: yy_symbol_print (stderr, \
! 772: Type, Value); \
! 773: YYFPRINTF (stderr, "\n"); \
! 774: } \
! 775: } while (YYID (0))
! 776:
! 777:
! 778: /*--------------------------------.
! 779: | Print this symbol on YYOUTPUT. |
! 780: `--------------------------------*/
! 781:
! 782: /*ARGSUSED*/
! 783: #if (defined __STDC__ || defined __C99__FUNC__ \
! 784: || defined __cplusplus || defined _MSC_VER)
! 785: static void
! 786: yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
! 787: #else
! 788: static void
! 789: yy_symbol_value_print (yyoutput, yytype, yyvaluep)
! 790: FILE *yyoutput;
! 791: int yytype;
! 792: YYSTYPE const * const yyvaluep;
! 793: #endif
! 794: {
! 795: if (!yyvaluep)
! 796: return;
! 797: # ifdef YYPRINT
! 798: if (yytype < YYNTOKENS)
! 799: YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
! 800: # else
! 801: YYUSE (yyoutput);
! 802: # endif
! 803: switch (yytype)
! 804: {
! 805: default:
! 806: break;
! 807: }
! 808: }
! 809:
! 810:
! 811: /*--------------------------------.
! 812: | Print this symbol on YYOUTPUT. |
! 813: `--------------------------------*/
! 814:
! 815: #if (defined __STDC__ || defined __C99__FUNC__ \
! 816: || defined __cplusplus || defined _MSC_VER)
! 817: static void
! 818: yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
! 819: #else
! 820: static void
! 821: yy_symbol_print (yyoutput, yytype, yyvaluep)
! 822: FILE *yyoutput;
! 823: int yytype;
! 824: YYSTYPE const * const yyvaluep;
! 825: #endif
! 826: {
! 827: if (yytype < YYNTOKENS)
! 828: YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
! 829: else
! 830: YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
! 831:
! 832: yy_symbol_value_print (yyoutput, yytype, yyvaluep);
! 833: YYFPRINTF (yyoutput, ")");
! 834: }
! 835:
! 836: /*------------------------------------------------------------------.
! 837: | yy_stack_print -- Print the state stack from its BOTTOM up to its |
! 838: | TOP (included). |
! 839: `------------------------------------------------------------------*/
! 840:
! 841: #if (defined __STDC__ || defined __C99__FUNC__ \
! 842: || defined __cplusplus || defined _MSC_VER)
! 843: static void
! 844: yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
! 845: #else
! 846: static void
! 847: yy_stack_print (yybottom, yytop)
! 848: yytype_int16 *yybottom;
! 849: yytype_int16 *yytop;
! 850: #endif
! 851: {
! 852: YYFPRINTF (stderr, "Stack now");
! 853: for (; yybottom <= yytop; yybottom++)
! 854: {
! 855: int yybot = *yybottom;
! 856: YYFPRINTF (stderr, " %d", yybot);
! 857: }
! 858: YYFPRINTF (stderr, "\n");
! 859: }
! 860:
! 861: # define YY_STACK_PRINT(Bottom, Top) \
! 862: do { \
! 863: if (yydebug) \
! 864: yy_stack_print ((Bottom), (Top)); \
! 865: } while (YYID (0))
! 866:
! 867:
! 868: /*------------------------------------------------.
! 869: | Report that the YYRULE is going to be reduced. |
! 870: `------------------------------------------------*/
! 871:
! 872: #if (defined __STDC__ || defined __C99__FUNC__ \
! 873: || defined __cplusplus || defined _MSC_VER)
! 874: static void
! 875: yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
! 876: #else
! 877: static void
! 878: yy_reduce_print (yyvsp, yyrule)
! 879: YYSTYPE *yyvsp;
! 880: int yyrule;
! 881: #endif
! 882: {
! 883: int yynrhs = yyr2[yyrule];
! 884: int yyi;
! 885: unsigned long int yylno = yyrline[yyrule];
! 886: YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
! 887: yyrule - 1, yylno);
! 888: /* The symbols being reduced. */
! 889: for (yyi = 0; yyi < yynrhs; yyi++)
! 890: {
! 891: YYFPRINTF (stderr, " $%d = ", yyi + 1);
! 892: yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
! 893: &(yyvsp[(yyi + 1) - (yynrhs)])
! 894: );
! 895: YYFPRINTF (stderr, "\n");
! 896: }
! 897: }
! 898:
! 899: # define YY_REDUCE_PRINT(Rule) \
! 900: do { \
! 901: if (yydebug) \
! 902: yy_reduce_print (yyvsp, Rule); \
! 903: } while (YYID (0))
! 904:
! 905: /* Nonzero means print parse trace. It is left uninitialized so that
! 906: multiple parsers can coexist. */
! 907: int yydebug;
! 908: #else /* !YYDEBUG */
! 909: # define YYDPRINTF(Args)
! 910: # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
! 911: # define YY_STACK_PRINT(Bottom, Top)
! 912: # define YY_REDUCE_PRINT(Rule)
! 913: #endif /* !YYDEBUG */
! 914:
! 915:
! 916: /* YYINITDEPTH -- initial size of the parser's stacks. */
! 917: #ifndef YYINITDEPTH
! 918: # define YYINITDEPTH 200
! 919: #endif
! 920:
! 921: /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
! 922: if the built-in stack extension method is used).
! 923:
! 924: Do not make this value too large; the results are undefined if
! 925: YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
! 926: evaluated with infinite-precision integer arithmetic. */
! 927:
! 928: #ifndef YYMAXDEPTH
! 929: # define YYMAXDEPTH 10000
! 930: #endif
! 931:
! 932:
! 933:
! 934: #if YYERROR_VERBOSE
! 935:
! 936: # ifndef yystrlen
! 937: # if defined __GLIBC__ && defined _STRING_H
! 938: # define yystrlen strlen
! 939: # else
! 940: /* Return the length of YYSTR. */
! 941: #if (defined __STDC__ || defined __C99__FUNC__ \
! 942: || defined __cplusplus || defined _MSC_VER)
! 943: static YYSIZE_T
! 944: yystrlen (const char *yystr)
! 945: #else
! 946: static YYSIZE_T
! 947: yystrlen (yystr)
! 948: const char *yystr;
! 949: #endif
! 950: {
! 951: YYSIZE_T yylen;
! 952: for (yylen = 0; yystr[yylen]; yylen++)
! 953: continue;
! 954: return yylen;
! 955: }
! 956: # endif
! 957: # endif
! 958:
! 959: # ifndef yystpcpy
! 960: # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
! 961: # define yystpcpy stpcpy
! 962: # else
! 963: /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
! 964: YYDEST. */
! 965: #if (defined __STDC__ || defined __C99__FUNC__ \
! 966: || defined __cplusplus || defined _MSC_VER)
! 967: static char *
! 968: yystpcpy (char *yydest, const char *yysrc)
! 969: #else
! 970: static char *
! 971: yystpcpy (yydest, yysrc)
! 972: char *yydest;
! 973: const char *yysrc;
! 974: #endif
! 975: {
! 976: char *yyd = yydest;
! 977: const char *yys = yysrc;
! 978:
! 979: while ((*yyd++ = *yys++) != '\0')
! 980: continue;
! 981:
! 982: return yyd - 1;
! 983: }
! 984: # endif
! 985: # endif
! 986:
! 987: # ifndef yytnamerr
! 988: /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
! 989: quotes and backslashes, so that it's suitable for yyerror. The
! 990: heuristic is that double-quoting is unnecessary unless the string
! 991: contains an apostrophe, a comma, or backslash (other than
! 992: backslash-backslash). YYSTR is taken from yytname. If YYRES is
! 993: null, do not copy; instead, return the length of what the result
! 994: would have been. */
! 995: static YYSIZE_T
! 996: yytnamerr (char *yyres, const char *yystr)
! 997: {
! 998: if (*yystr == '"')
! 999: {
! 1000: YYSIZE_T yyn = 0;
! 1001: char const *yyp = yystr;
! 1002:
! 1003: for (;;)
! 1004: switch (*++yyp)
! 1005: {
! 1006: case '\'':
! 1007: case ',':
! 1008: goto do_not_strip_quotes;
! 1009:
! 1010: case '\\':
! 1011: if (*++yyp != '\\')
! 1012: goto do_not_strip_quotes;
! 1013: /* Fall through. */
! 1014: default:
! 1015: if (yyres)
! 1016: yyres[yyn] = *yyp;
! 1017: yyn++;
! 1018: break;
! 1019:
! 1020: case '"':
! 1021: if (yyres)
! 1022: yyres[yyn] = '\0';
! 1023: return yyn;
! 1024: }
! 1025: do_not_strip_quotes: ;
! 1026: }
! 1027:
! 1028: if (! yyres)
! 1029: return yystrlen (yystr);
! 1030:
! 1031: return yystpcpy (yyres, yystr) - yyres;
! 1032: }
! 1033: # endif
! 1034:
! 1035: /* Copy into YYRESULT an error message about the unexpected token
! 1036: YYCHAR while in state YYSTATE. Return the number of bytes copied,
! 1037: including the terminating null byte. If YYRESULT is null, do not
! 1038: copy anything; just return the number of bytes that would be
! 1039: copied. As a special case, return 0 if an ordinary "syntax error"
! 1040: message will do. Return YYSIZE_MAXIMUM if overflow occurs during
! 1041: size calculation. */
! 1042: static YYSIZE_T
! 1043: yysyntax_error (char *yyresult, int yystate, int yychar)
! 1044: {
! 1045: int yyn = yypact[yystate];
! 1046:
! 1047: if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
! 1048: return 0;
! 1049: else
! 1050: {
! 1051: int yytype = YYTRANSLATE (yychar);
! 1052: YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
! 1053: YYSIZE_T yysize = yysize0;
! 1054: YYSIZE_T yysize1;
! 1055: int yysize_overflow = 0;
! 1056: enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
! 1057: char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
! 1058: int yyx;
! 1059:
! 1060: # if 0
! 1061: /* This is so xgettext sees the translatable formats that are
! 1062: constructed on the fly. */
! 1063: YY_("syntax error, unexpected %s");
! 1064: YY_("syntax error, unexpected %s, expecting %s");
! 1065: YY_("syntax error, unexpected %s, expecting %s or %s");
! 1066: YY_("syntax error, unexpected %s, expecting %s or %s or %s");
! 1067: YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
! 1068: # endif
! 1069: char *yyfmt;
! 1070: char const *yyf;
! 1071: static char const yyunexpected[] = "syntax error, unexpected %s";
! 1072: static char const yyexpecting[] = ", expecting %s";
! 1073: static char const yyor[] = " or %s";
! 1074: char yyformat[sizeof yyunexpected
! 1075: + sizeof yyexpecting - 1
! 1076: + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
! 1077: * (sizeof yyor - 1))];
! 1078: char const *yyprefix = yyexpecting;
! 1079:
! 1080: /* Start YYX at -YYN if negative to avoid negative indexes in
! 1081: YYCHECK. */
! 1082: int yyxbegin = yyn < 0 ? -yyn : 0;
! 1083:
! 1084: /* Stay within bounds of both yycheck and yytname. */
! 1085: int yychecklim = YYLAST - yyn + 1;
! 1086: int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
! 1087: int yycount = 1;
! 1088:
! 1089: yyarg[0] = yytname[yytype];
! 1090: yyfmt = yystpcpy (yyformat, yyunexpected);
! 1091:
! 1092: for (yyx = yyxbegin; yyx < yyxend; ++yyx)
! 1093: if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
! 1094: {
! 1095: if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
! 1096: {
! 1097: yycount = 1;
! 1098: yysize = yysize0;
! 1099: yyformat[sizeof yyunexpected - 1] = '\0';
! 1100: break;
! 1101: }
! 1102: yyarg[yycount++] = yytname[yyx];
! 1103: yysize1 = yysize + yytnamerr (0, yytname[yyx]);
! 1104: yysize_overflow |= (yysize1 < yysize);
! 1105: yysize = yysize1;
! 1106: yyfmt = yystpcpy (yyfmt, yyprefix);
! 1107: yyprefix = yyor;
! 1108: }
! 1109:
! 1110: yyf = YY_(yyformat);
! 1111: yysize1 = yysize + yystrlen (yyf);
! 1112: yysize_overflow |= (yysize1 < yysize);
! 1113: yysize = yysize1;
! 1114:
! 1115: if (yysize_overflow)
! 1116: return YYSIZE_MAXIMUM;
! 1117:
! 1118: if (yyresult)
! 1119: {
! 1120: /* Avoid sprintf, as that infringes on the user's name space.
! 1121: Don't have undefined behavior even if the translation
! 1122: produced a string with the wrong number of "%s"s. */
! 1123: char *yyp = yyresult;
! 1124: int yyi = 0;
! 1125: while ((*yyp = *yyf) != '\0')
! 1126: {
! 1127: if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
! 1128: {
! 1129: yyp += yytnamerr (yyp, yyarg[yyi++]);
! 1130: yyf += 2;
! 1131: }
! 1132: else
! 1133: {
! 1134: yyp++;
! 1135: yyf++;
! 1136: }
! 1137: }
! 1138: }
! 1139: return yysize;
! 1140: }
! 1141: }
! 1142: #endif /* YYERROR_VERBOSE */
! 1143:
! 1144:
! 1145: /*-----------------------------------------------.
! 1146: | Release the memory associated to this symbol. |
! 1147: `-----------------------------------------------*/
! 1148:
! 1149: /*ARGSUSED*/
! 1150: #if (defined __STDC__ || defined __C99__FUNC__ \
! 1151: || defined __cplusplus || defined _MSC_VER)
! 1152: static void
! 1153: yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
! 1154: #else
! 1155: static void
! 1156: yydestruct (yymsg, yytype, yyvaluep)
! 1157: const char *yymsg;
! 1158: int yytype;
! 1159: YYSTYPE *yyvaluep;
! 1160: #endif
! 1161: {
! 1162: YYUSE (yyvaluep);
! 1163:
! 1164: if (!yymsg)
! 1165: yymsg = "Deleting";
! 1166: YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
! 1167:
! 1168: switch (yytype)
! 1169: {
! 1170:
! 1171: default:
! 1172: break;
! 1173: }
! 1174: }
! 1175:
! 1176: /* Prevent warnings from -Wmissing-prototypes. */
! 1177: #ifdef YYPARSE_PARAM
! 1178: #if defined __STDC__ || defined __cplusplus
! 1179: int yyparse (void *YYPARSE_PARAM);
! 1180: #else
! 1181: int yyparse ();
! 1182: #endif
! 1183: #else /* ! YYPARSE_PARAM */
! 1184: #if defined __STDC__ || defined __cplusplus
! 1185: int yyparse (void);
! 1186: #else
! 1187: int yyparse ();
! 1188: #endif
! 1189: #endif /* ! YYPARSE_PARAM */
! 1190:
! 1191:
! 1192: /* The lookahead symbol. */
! 1193: int yychar;
! 1194:
! 1195: /* The semantic value of the lookahead symbol. */
! 1196: YYSTYPE yylval;
! 1197:
! 1198: /* Number of syntax errors so far. */
! 1199: int yynerrs;
! 1200:
! 1201:
! 1202:
! 1203: /*-------------------------.
! 1204: | yyparse or yypush_parse. |
! 1205: `-------------------------*/
! 1206:
! 1207: #ifdef YYPARSE_PARAM
! 1208: #if (defined __STDC__ || defined __C99__FUNC__ \
! 1209: || defined __cplusplus || defined _MSC_VER)
! 1210: int
! 1211: yyparse (void *YYPARSE_PARAM)
! 1212: #else
! 1213: int
! 1214: yyparse (YYPARSE_PARAM)
! 1215: void *YYPARSE_PARAM;
! 1216: #endif
! 1217: #else /* ! YYPARSE_PARAM */
! 1218: #if (defined __STDC__ || defined __C99__FUNC__ \
! 1219: || defined __cplusplus || defined _MSC_VER)
! 1220: int
! 1221: yyparse (void)
! 1222: #else
! 1223: int
! 1224: yyparse ()
! 1225:
! 1226: #endif
! 1227: #endif
! 1228: {
! 1229:
! 1230:
! 1231: int yystate;
! 1232: /* Number of tokens to shift before error messages enabled. */
! 1233: int yyerrstatus;
! 1234:
! 1235: /* The stacks and their tools:
! 1236: `yyss': related to states.
! 1237: `yyvs': related to semantic values.
! 1238:
! 1239: Refer to the stacks thru separate pointers, to allow yyoverflow
! 1240: to reallocate them elsewhere. */
! 1241:
! 1242: /* The state stack. */
! 1243: yytype_int16 yyssa[YYINITDEPTH];
! 1244: yytype_int16 *yyss;
! 1245: yytype_int16 *yyssp;
! 1246:
! 1247: /* The semantic value stack. */
! 1248: YYSTYPE yyvsa[YYINITDEPTH];
! 1249: YYSTYPE *yyvs;
! 1250: YYSTYPE *yyvsp;
! 1251:
! 1252: YYSIZE_T yystacksize;
! 1253:
! 1254: int yyn;
! 1255: int yyresult;
! 1256: /* Lookahead token as an internal (translated) token number. */
! 1257: int yytoken;
! 1258: /* The variables used to return semantic value and location from the
! 1259: action routines. */
! 1260: YYSTYPE yyval;
! 1261:
! 1262: #if YYERROR_VERBOSE
! 1263: /* Buffer for error messages, and its allocated size. */
! 1264: char yymsgbuf[128];
! 1265: char *yymsg = yymsgbuf;
! 1266: YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
! 1267: #endif
! 1268:
! 1269: #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
! 1270:
! 1271: /* The number of symbols on the RHS of the reduced rule.
! 1272: Keep to zero when no symbol should be popped. */
! 1273: int yylen = 0;
! 1274:
! 1275: yytoken = 0;
! 1276: yyss = yyssa;
! 1277: yyvs = yyvsa;
! 1278: yystacksize = YYINITDEPTH;
! 1279:
! 1280: YYDPRINTF ((stderr, "Starting parse\n"));
! 1281:
! 1282: yystate = 0;
! 1283: yyerrstatus = 0;
! 1284: yynerrs = 0;
! 1285: yychar = YYEMPTY; /* Cause a token to be read. */
! 1286:
! 1287: /* Initialize stack pointers.
! 1288: Waste one element of value and location stack
! 1289: so that they stay on the same level as the state stack.
! 1290: The wasted elements are never initialized. */
! 1291: yyssp = yyss;
! 1292: yyvsp = yyvs;
! 1293:
! 1294: goto yysetstate;
! 1295:
! 1296: /*------------------------------------------------------------.
! 1297: | yynewstate -- Push a new state, which is found in yystate. |
! 1298: `------------------------------------------------------------*/
! 1299: yynewstate:
! 1300: /* In all cases, when you get here, the value and location stacks
! 1301: have just been pushed. So pushing a state here evens the stacks. */
! 1302: yyssp++;
! 1303:
! 1304: yysetstate:
! 1305: *yyssp = yystate;
! 1306:
! 1307: if (yyss + yystacksize - 1 <= yyssp)
! 1308: {
! 1309: /* Get the current used size of the three stacks, in elements. */
! 1310: YYSIZE_T yysize = yyssp - yyss + 1;
! 1311:
! 1312: #ifdef yyoverflow
! 1313: {
! 1314: /* Give user a chance to reallocate the stack. Use copies of
! 1315: these so that the &'s don't force the real ones into
! 1316: memory. */
! 1317: YYSTYPE *yyvs1 = yyvs;
! 1318: yytype_int16 *yyss1 = yyss;
! 1319:
! 1320: /* Each stack pointer address is followed by the size of the
! 1321: data in use in that stack, in bytes. This used to be a
! 1322: conditional around just the two extra args, but that might
! 1323: be undefined if yyoverflow is a macro. */
! 1324: yyoverflow (YY_("memory exhausted"),
! 1325: &yyss1, yysize * sizeof (*yyssp),
! 1326: &yyvs1, yysize * sizeof (*yyvsp),
! 1327: &yystacksize);
! 1328:
! 1329: yyss = yyss1;
! 1330: yyvs = yyvs1;
! 1331: }
! 1332: #else /* no yyoverflow */
! 1333: # ifndef YYSTACK_RELOCATE
! 1334: goto yyexhaustedlab;
! 1335: # else
! 1336: /* Extend the stack our own way. */
! 1337: if (YYMAXDEPTH <= yystacksize)
! 1338: goto yyexhaustedlab;
! 1339: yystacksize *= 2;
! 1340: if (YYMAXDEPTH < yystacksize)
! 1341: yystacksize = YYMAXDEPTH;
! 1342:
! 1343: {
! 1344: yytype_int16 *yyss1 = yyss;
! 1345: union yyalloc *yyptr =
! 1346: (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
! 1347: if (! yyptr)
! 1348: goto yyexhaustedlab;
! 1349: YYSTACK_RELOCATE (yyss_alloc, yyss);
! 1350: YYSTACK_RELOCATE (yyvs_alloc, yyvs);
! 1351: # undef YYSTACK_RELOCATE
! 1352: if (yyss1 != yyssa)
! 1353: YYSTACK_FREE (yyss1);
! 1354: }
! 1355: # endif
! 1356: #endif /* no yyoverflow */
! 1357:
! 1358: yyssp = yyss + yysize - 1;
! 1359: yyvsp = yyvs + yysize - 1;
! 1360:
! 1361: YYDPRINTF ((stderr, "Stack size increased to %lu\n",
! 1362: (unsigned long int) yystacksize));
! 1363:
! 1364: if (yyss + yystacksize - 1 <= yyssp)
! 1365: YYABORT;
! 1366: }
! 1367:
! 1368: YYDPRINTF ((stderr, "Entering state %d\n", yystate));
! 1369:
! 1370: if (yystate == YYFINAL)
! 1371: YYACCEPT;
! 1372:
! 1373: goto yybackup;
! 1374:
! 1375: /*-----------.
! 1376: | yybackup. |
! 1377: `-----------*/
! 1378: yybackup:
! 1379:
! 1380: /* Do appropriate processing given the current state. Read a
! 1381: lookahead token if we need one and don't already have one. */
! 1382:
! 1383: /* First try to decide what to do without reference to lookahead token. */
! 1384: yyn = yypact[yystate];
! 1385: if (yyn == YYPACT_NINF)
! 1386: goto yydefault;
! 1387:
! 1388: /* Not known => get a lookahead token if don't already have one. */
! 1389:
! 1390: /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
! 1391: if (yychar == YYEMPTY)
! 1392: {
! 1393: YYDPRINTF ((stderr, "Reading a token: "));
! 1394: yychar = YYLEX;
! 1395: }
! 1396:
! 1397: if (yychar <= YYEOF)
! 1398: {
! 1399: yychar = yytoken = YYEOF;
! 1400: YYDPRINTF ((stderr, "Now at end of input.\n"));
! 1401: }
! 1402: else
! 1403: {
! 1404: yytoken = YYTRANSLATE (yychar);
! 1405: YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
! 1406: }
! 1407:
! 1408: /* If the proper action on seeing token YYTOKEN is to reduce or to
! 1409: detect an error, take that action. */
! 1410: yyn += yytoken;
! 1411: if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
! 1412: goto yydefault;
! 1413: yyn = yytable[yyn];
! 1414: if (yyn <= 0)
! 1415: {
! 1416: if (yyn == 0 || yyn == YYTABLE_NINF)
! 1417: goto yyerrlab;
! 1418: yyn = -yyn;
! 1419: goto yyreduce;
! 1420: }
! 1421:
! 1422: /* Count tokens shifted since error; after three, turn off error
! 1423: status. */
! 1424: if (yyerrstatus)
! 1425: yyerrstatus--;
! 1426:
! 1427: /* Shift the lookahead token. */
! 1428: YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
! 1429:
! 1430: /* Discard the shifted token. */
! 1431: yychar = YYEMPTY;
! 1432:
! 1433: yystate = yyn;
! 1434: *++yyvsp = yylval;
! 1435:
! 1436: goto yynewstate;
! 1437:
! 1438:
! 1439: /*-----------------------------------------------------------.
! 1440: | yydefault -- do the default action for the current state. |
! 1441: `-----------------------------------------------------------*/
! 1442: yydefault:
! 1443: yyn = yydefact[yystate];
! 1444: if (yyn == 0)
! 1445: goto yyerrlab;
! 1446: goto yyreduce;
! 1447:
! 1448:
! 1449: /*-----------------------------.
! 1450: | yyreduce -- Do a reduction. |
! 1451: `-----------------------------*/
! 1452: yyreduce:
! 1453: /* yyn is the number of a rule to reduce with. */
! 1454: yylen = yyr2[yyn];
! 1455:
! 1456: /* If YYLEN is nonzero, implement the default value of the action:
! 1457: `$$ = $1'.
! 1458:
! 1459: Otherwise, the following line sets YYVAL to garbage.
! 1460: This behavior is undocumented and Bison
! 1461: users should not rely upon it. Assigning to YYVAL
! 1462: unconditionally makes the parser a bit smaller, and it avoids a
! 1463: GCC warning that YYVAL may be used uninitialized. */
! 1464: yyval = yyvsp[1-yylen];
! 1465:
! 1466:
! 1467: YY_REDUCE_PRINT (yyn);
! 1468: switch (yyn)
! 1469: {
! 1470: case 2:
! 1471:
! 1472: /* Line 1455 of yacc.c */
! 1473: #line 151 "policy_parse.y"
! 1474: {
! 1475: p_dir = (yyvsp[(1) - (2)].num);
! 1476: p_type = (yyvsp[(2) - (2)].num);
! 1477:
! 1478: #ifdef HAVE_PFKEY_POLICY_PRIORITY
! 1479: p_priority = PRIORITY_DEFAULT;
! 1480: #else
! 1481: p_priority = 0;
! 1482: #endif
! 1483:
! 1484: if (init_x_policy())
! 1485: return -1;
! 1486: }
! 1487: break;
! 1488:
! 1489: case 4:
! 1490:
! 1491: /* Line 1455 of yacc.c */
! 1492: #line 166 "policy_parse.y"
! 1493: {
! 1494: p_dir = (yyvsp[(1) - (4)].num);
! 1495: p_type = (yyvsp[(4) - (4)].num);
! 1496: p_priority_offset = -atol((yyvsp[(3) - (4)].val).buf);
! 1497:
! 1498: errno = 0;
! 1499: if (errno != 0 || p_priority_offset < INT32_MIN)
! 1500: {
! 1501: __ipsec_errcode = EIPSEC_INVAL_PRIORITY_OFFSET;
! 1502: return -1;
! 1503: }
! 1504:
! 1505: p_priority = PRIORITY_DEFAULT + (u_int32_t) p_priority_offset;
! 1506:
! 1507: if (init_x_policy())
! 1508: return -1;
! 1509: }
! 1510: break;
! 1511:
! 1512: case 6:
! 1513:
! 1514: /* Line 1455 of yacc.c */
! 1515: #line 185 "policy_parse.y"
! 1516: {
! 1517: p_dir = (yyvsp[(1) - (5)].num);
! 1518: p_type = (yyvsp[(5) - (5)].num);
! 1519:
! 1520: errno = 0;
! 1521: p_priority_offset = atol((yyvsp[(4) - (5)].val).buf);
! 1522:
! 1523: if (errno != 0 || p_priority_offset > INT32_MAX)
! 1524: {
! 1525: __ipsec_errcode = EIPSEC_INVAL_PRIORITY_OFFSET;
! 1526: return -1;
! 1527: }
! 1528:
! 1529: /* negative input value means lower priority, therefore higher
! 1530: actual value so that is closer to the end of the list */
! 1531: p_priority = PRIORITY_DEFAULT + (u_int32_t) p_priority_offset;
! 1532:
! 1533: if (init_x_policy())
! 1534: return -1;
! 1535: }
! 1536: break;
! 1537:
! 1538: case 8:
! 1539:
! 1540: /* Line 1455 of yacc.c */
! 1541: #line 207 "policy_parse.y"
! 1542: {
! 1543: p_dir = (yyvsp[(1) - (4)].num);
! 1544: p_type = (yyvsp[(4) - (4)].num);
! 1545:
! 1546: p_priority = (yyvsp[(3) - (4)].num32);
! 1547:
! 1548: if (init_x_policy())
! 1549: return -1;
! 1550: }
! 1551: break;
! 1552:
! 1553: case 10:
! 1554:
! 1555: /* Line 1455 of yacc.c */
! 1556: #line 218 "policy_parse.y"
! 1557: {
! 1558: p_dir = (yyvsp[(1) - (6)].num);
! 1559: p_type = (yyvsp[(6) - (6)].num);
! 1560:
! 1561: errno = 0;
! 1562: p_priority_offset = atol((yyvsp[(5) - (6)].val).buf);
! 1563:
! 1564: if (errno != 0 || p_priority_offset > PRIORITY_OFFSET_NEGATIVE_MAX)
! 1565: {
! 1566: __ipsec_errcode = EIPSEC_INVAL_PRIORITY_BASE_OFFSET;
! 1567: return -1;
! 1568: }
! 1569:
! 1570: /* adding value means higher priority, therefore lower
! 1571: actual value so that is closer to the beginning of the list */
! 1572: p_priority = (yyvsp[(3) - (6)].num32) - (u_int32_t) p_priority_offset;
! 1573:
! 1574: if (init_x_policy())
! 1575: return -1;
! 1576: }
! 1577: break;
! 1578:
! 1579: case 12:
! 1580:
! 1581: /* Line 1455 of yacc.c */
! 1582: #line 240 "policy_parse.y"
! 1583: {
! 1584: p_dir = (yyvsp[(1) - (6)].num);
! 1585: p_type = (yyvsp[(6) - (6)].num);
! 1586:
! 1587: errno = 0;
! 1588: p_priority_offset = atol((yyvsp[(5) - (6)].val).buf);
! 1589:
! 1590: if (errno != 0 || p_priority_offset > PRIORITY_OFFSET_POSITIVE_MAX)
! 1591: {
! 1592: __ipsec_errcode = EIPSEC_INVAL_PRIORITY_BASE_OFFSET;
! 1593: return -1;
! 1594: }
! 1595:
! 1596: /* subtracting value means lower priority, therefore higher
! 1597: actual value so that is closer to the end of the list */
! 1598: p_priority = (yyvsp[(3) - (6)].num32) + (u_int32_t) p_priority_offset;
! 1599:
! 1600: if (init_x_policy())
! 1601: return -1;
! 1602: }
! 1603: break;
! 1604:
! 1605: case 14:
! 1606:
! 1607: /* Line 1455 of yacc.c */
! 1608: #line 262 "policy_parse.y"
! 1609: {
! 1610: p_dir = (yyvsp[(1) - (1)].num);
! 1611: p_type = 0; /* ignored it by kernel */
! 1612:
! 1613: p_priority = 0;
! 1614:
! 1615: if (init_x_policy())
! 1616: return -1;
! 1617: }
! 1618: break;
! 1619:
! 1620: case 16:
! 1621:
! 1622: /* Line 1455 of yacc.c */
! 1623: #line 275 "policy_parse.y"
! 1624: {
! 1625: if (rule_check() < 0)
! 1626: return -1;
! 1627:
! 1628: if (set_x_request(p_src, p_dst) < 0)
! 1629: return -1;
! 1630:
! 1631: policy_parse_request_init();
! 1632: }
! 1633: break;
! 1634:
! 1635: case 23:
! 1636:
! 1637: /* Line 1455 of yacc.c */
! 1638: #line 293 "policy_parse.y"
! 1639: {
! 1640: __ipsec_errcode = EIPSEC_FEW_ARGUMENTS;
! 1641: return -1;
! 1642: }
! 1643: break;
! 1644:
! 1645: case 24:
! 1646:
! 1647: /* Line 1455 of yacc.c */
! 1648: #line 297 "policy_parse.y"
! 1649: {
! 1650: __ipsec_errcode = EIPSEC_FEW_ARGUMENTS;
! 1651: return -1;
! 1652: }
! 1653: break;
! 1654:
! 1655: case 25:
! 1656:
! 1657: /* Line 1455 of yacc.c */
! 1658: #line 304 "policy_parse.y"
! 1659: { p_protocol = (yyvsp[(1) - (1)].num); }
! 1660: break;
! 1661:
! 1662: case 26:
! 1663:
! 1664: /* Line 1455 of yacc.c */
! 1665: #line 308 "policy_parse.y"
! 1666: { p_mode = (yyvsp[(1) - (1)].num); }
! 1667: break;
! 1668:
! 1669: case 27:
! 1670:
! 1671: /* Line 1455 of yacc.c */
! 1672: #line 312 "policy_parse.y"
! 1673: {
! 1674: p_level = (yyvsp[(1) - (1)].num);
! 1675: p_reqid = 0;
! 1676: }
! 1677: break;
! 1678:
! 1679: case 28:
! 1680:
! 1681: /* Line 1455 of yacc.c */
! 1682: #line 316 "policy_parse.y"
! 1683: {
! 1684: p_level = IPSEC_LEVEL_UNIQUE;
! 1685: p_reqid = atol((yyvsp[(1) - (1)].val).buf); /* atol() is good. */
! 1686: }
! 1687: break;
! 1688:
! 1689: case 29:
! 1690:
! 1691: /* Line 1455 of yacc.c */
! 1692: #line 323 "policy_parse.y"
! 1693: {
! 1694: p_src = parse_sockaddr(&(yyvsp[(1) - (1)].val), NULL);
! 1695: if (p_src == NULL)
! 1696: return -1;
! 1697: }
! 1698: break;
! 1699:
! 1700: case 30:
! 1701:
! 1702: /* Line 1455 of yacc.c */
! 1703: #line 329 "policy_parse.y"
! 1704: {
! 1705: p_dst = parse_sockaddr(&(yyvsp[(4) - (4)].val), NULL);
! 1706: if (p_dst == NULL)
! 1707: return -1;
! 1708: }
! 1709: break;
! 1710:
! 1711: case 31:
! 1712:
! 1713: /* Line 1455 of yacc.c */
! 1714: #line 334 "policy_parse.y"
! 1715: {
! 1716: p_src = parse_sockaddr(&(yyvsp[(1) - (2)].val), &(yyvsp[(2) - (2)].val));
! 1717: if (p_src == NULL)
! 1718: return -1;
! 1719: }
! 1720: break;
! 1721:
! 1722: case 32:
! 1723:
! 1724: /* Line 1455 of yacc.c */
! 1725: #line 340 "policy_parse.y"
! 1726: {
! 1727: p_dst = parse_sockaddr(&(yyvsp[(5) - (6)].val), &(yyvsp[(6) - (6)].val));
! 1728: if (p_dst == NULL)
! 1729: return -1;
! 1730: }
! 1731: break;
! 1732:
! 1733: case 33:
! 1734:
! 1735: /* Line 1455 of yacc.c */
! 1736: #line 345 "policy_parse.y"
! 1737: {
! 1738: if (p_dir != IPSEC_DIR_OUTBOUND) {
! 1739: __ipsec_errcode = EIPSEC_INVAL_DIR;
! 1740: return -1;
! 1741: }
! 1742: }
! 1743: break;
! 1744:
! 1745: case 34:
! 1746:
! 1747: /* Line 1455 of yacc.c */
! 1748: #line 351 "policy_parse.y"
! 1749: {
! 1750: if (p_dir != IPSEC_DIR_INBOUND) {
! 1751: __ipsec_errcode = EIPSEC_INVAL_DIR;
! 1752: return -1;
! 1753: }
! 1754: }
! 1755: break;
! 1756:
! 1757:
! 1758:
! 1759: /* Line 1455 of yacc.c */
! 1760: #line 1761 "policy_parse.c"
! 1761: default: break;
! 1762: }
! 1763: YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
! 1764:
! 1765: YYPOPSTACK (yylen);
! 1766: yylen = 0;
! 1767: YY_STACK_PRINT (yyss, yyssp);
! 1768:
! 1769: *++yyvsp = yyval;
! 1770:
! 1771: /* Now `shift' the result of the reduction. Determine what state
! 1772: that goes to, based on the state we popped back to and the rule
! 1773: number reduced by. */
! 1774:
! 1775: yyn = yyr1[yyn];
! 1776:
! 1777: yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
! 1778: if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
! 1779: yystate = yytable[yystate];
! 1780: else
! 1781: yystate = yydefgoto[yyn - YYNTOKENS];
! 1782:
! 1783: goto yynewstate;
! 1784:
! 1785:
! 1786: /*------------------------------------.
! 1787: | yyerrlab -- here on detecting error |
! 1788: `------------------------------------*/
! 1789: yyerrlab:
! 1790: /* If not already recovering from an error, report this error. */
! 1791: if (!yyerrstatus)
! 1792: {
! 1793: ++yynerrs;
! 1794: #if ! YYERROR_VERBOSE
! 1795: yyerror (YY_("syntax error"));
! 1796: #else
! 1797: {
! 1798: YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
! 1799: if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
! 1800: {
! 1801: YYSIZE_T yyalloc = 2 * yysize;
! 1802: if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
! 1803: yyalloc = YYSTACK_ALLOC_MAXIMUM;
! 1804: if (yymsg != yymsgbuf)
! 1805: YYSTACK_FREE (yymsg);
! 1806: yymsg = (char *) YYSTACK_ALLOC (yyalloc);
! 1807: if (yymsg)
! 1808: yymsg_alloc = yyalloc;
! 1809: else
! 1810: {
! 1811: yymsg = yymsgbuf;
! 1812: yymsg_alloc = sizeof yymsgbuf;
! 1813: }
! 1814: }
! 1815:
! 1816: if (0 < yysize && yysize <= yymsg_alloc)
! 1817: {
! 1818: (void) yysyntax_error (yymsg, yystate, yychar);
! 1819: yyerror (yymsg);
! 1820: }
! 1821: else
! 1822: {
! 1823: yyerror (YY_("syntax error"));
! 1824: if (yysize != 0)
! 1825: goto yyexhaustedlab;
! 1826: }
! 1827: }
! 1828: #endif
! 1829: }
! 1830:
! 1831:
! 1832:
! 1833: if (yyerrstatus == 3)
! 1834: {
! 1835: /* If just tried and failed to reuse lookahead token after an
! 1836: error, discard it. */
! 1837:
! 1838: if (yychar <= YYEOF)
! 1839: {
! 1840: /* Return failure if at end of input. */
! 1841: if (yychar == YYEOF)
! 1842: YYABORT;
! 1843: }
! 1844: else
! 1845: {
! 1846: yydestruct ("Error: discarding",
! 1847: yytoken, &yylval);
! 1848: yychar = YYEMPTY;
! 1849: }
! 1850: }
! 1851:
! 1852: /* Else will try to reuse lookahead token after shifting the error
! 1853: token. */
! 1854: goto yyerrlab1;
! 1855:
! 1856:
! 1857: /*---------------------------------------------------.
! 1858: | yyerrorlab -- error raised explicitly by YYERROR. |
! 1859: `---------------------------------------------------*/
! 1860: yyerrorlab:
! 1861:
! 1862: /* Pacify compilers like GCC when the user code never invokes
! 1863: YYERROR and the label yyerrorlab therefore never appears in user
! 1864: code. */
! 1865: if (/*CONSTCOND*/ 0)
! 1866: goto yyerrorlab;
! 1867:
! 1868: /* Do not reclaim the symbols of the rule which action triggered
! 1869: this YYERROR. */
! 1870: YYPOPSTACK (yylen);
! 1871: yylen = 0;
! 1872: YY_STACK_PRINT (yyss, yyssp);
! 1873: yystate = *yyssp;
! 1874: goto yyerrlab1;
! 1875:
! 1876:
! 1877: /*-------------------------------------------------------------.
! 1878: | yyerrlab1 -- common code for both syntax error and YYERROR. |
! 1879: `-------------------------------------------------------------*/
! 1880: yyerrlab1:
! 1881: yyerrstatus = 3; /* Each real token shifted decrements this. */
! 1882:
! 1883: for (;;)
! 1884: {
! 1885: yyn = yypact[yystate];
! 1886: if (yyn != YYPACT_NINF)
! 1887: {
! 1888: yyn += YYTERROR;
! 1889: if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
! 1890: {
! 1891: yyn = yytable[yyn];
! 1892: if (0 < yyn)
! 1893: break;
! 1894: }
! 1895: }
! 1896:
! 1897: /* Pop the current state because it cannot handle the error token. */
! 1898: if (yyssp == yyss)
! 1899: YYABORT;
! 1900:
! 1901:
! 1902: yydestruct ("Error: popping",
! 1903: yystos[yystate], yyvsp);
! 1904: YYPOPSTACK (1);
! 1905: yystate = *yyssp;
! 1906: YY_STACK_PRINT (yyss, yyssp);
! 1907: }
! 1908:
! 1909: *++yyvsp = yylval;
! 1910:
! 1911:
! 1912: /* Shift the error token. */
! 1913: YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
! 1914:
! 1915: yystate = yyn;
! 1916: goto yynewstate;
! 1917:
! 1918:
! 1919: /*-------------------------------------.
! 1920: | yyacceptlab -- YYACCEPT comes here. |
! 1921: `-------------------------------------*/
! 1922: yyacceptlab:
! 1923: yyresult = 0;
! 1924: goto yyreturn;
! 1925:
! 1926: /*-----------------------------------.
! 1927: | yyabortlab -- YYABORT comes here. |
! 1928: `-----------------------------------*/
! 1929: yyabortlab:
! 1930: yyresult = 1;
! 1931: goto yyreturn;
! 1932:
! 1933: #if !defined(yyoverflow) || YYERROR_VERBOSE
! 1934: /*-------------------------------------------------.
! 1935: | yyexhaustedlab -- memory exhaustion comes here. |
! 1936: `-------------------------------------------------*/
! 1937: yyexhaustedlab:
! 1938: yyerror (YY_("memory exhausted"));
! 1939: yyresult = 2;
! 1940: /* Fall through. */
! 1941: #endif
! 1942:
! 1943: yyreturn:
! 1944: if (yychar != YYEMPTY)
! 1945: yydestruct ("Cleanup: discarding lookahead",
! 1946: yytoken, &yylval);
! 1947: /* Do not reclaim the symbols of the rule which action triggered
! 1948: this YYABORT or YYACCEPT. */
! 1949: YYPOPSTACK (yylen);
! 1950: YY_STACK_PRINT (yyss, yyssp);
! 1951: while (yyssp != yyss)
! 1952: {
! 1953: yydestruct ("Cleanup: popping",
! 1954: yystos[*yyssp], yyvsp);
! 1955: YYPOPSTACK (1);
! 1956: }
! 1957: #ifndef yyoverflow
! 1958: if (yyss != yyssa)
! 1959: YYSTACK_FREE (yyss);
! 1960: #endif
! 1961: #if YYERROR_VERBOSE
! 1962: if (yymsg != yymsgbuf)
! 1963: YYSTACK_FREE (yymsg);
! 1964: #endif
! 1965: /* Make sure YYID is used. */
! 1966: return YYID (yyresult);
! 1967: }
! 1968:
! 1969:
! 1970:
! 1971: /* Line 1675 of yacc.c */
! 1972: #line 362 "policy_parse.y"
! 1973:
! 1974:
! 1975: void
! 1976: yyerror(msg)
! 1977: char *msg;
! 1978: {
! 1979: fprintf(stderr, "libipsec: %s while parsing \"%s\"\n",
! 1980: msg, __libipsectext);
! 1981:
! 1982: return;
! 1983: }
! 1984:
! 1985: static struct sockaddr *
! 1986: parse_sockaddr(addrbuf, portbuf)
! 1987: struct _val *addrbuf;
! 1988: struct _val *portbuf;
! 1989: {
! 1990: struct addrinfo hints, *res;
! 1991: char *addr;
! 1992: char *serv = NULL;
! 1993: int error;
! 1994: struct sockaddr *newaddr = NULL;
! 1995:
! 1996: if ((addr = malloc(addrbuf->len + 1)) == NULL) {
! 1997: yyerror("malloc failed");
! 1998: __ipsec_set_strerror(strerror(errno));
! 1999: return NULL;
! 2000: }
! 2001:
! 2002: if (portbuf && ((serv = malloc(portbuf->len + 1)) == NULL)) {
! 2003: free(addr);
! 2004: yyerror("malloc failed");
! 2005: __ipsec_set_strerror(strerror(errno));
! 2006: return NULL;
! 2007: }
! 2008:
! 2009: strncpy(addr, addrbuf->buf, addrbuf->len);
! 2010: addr[addrbuf->len] = '\0';
! 2011:
! 2012: if (portbuf) {
! 2013: strncpy(serv, portbuf->buf, portbuf->len);
! 2014: serv[portbuf->len] = '\0';
! 2015: }
! 2016:
! 2017: memset(&hints, 0, sizeof(hints));
! 2018: hints.ai_family = PF_UNSPEC;
! 2019: hints.ai_flags = AI_NUMERICHOST;
! 2020: hints.ai_socktype = SOCK_DGRAM;
! 2021: error = getaddrinfo(addr, serv, &hints, &res);
! 2022: free(addr);
! 2023: if (serv != NULL)
! 2024: free(serv);
! 2025: if (error != 0) {
! 2026: yyerror("invalid IP address");
! 2027: __ipsec_set_strerror(gai_strerror(error));
! 2028: return NULL;
! 2029: }
! 2030:
! 2031: if (res->ai_addr == NULL) {
! 2032: yyerror("invalid IP address");
! 2033: __ipsec_set_strerror(gai_strerror(error));
! 2034: return NULL;
! 2035: }
! 2036:
! 2037: newaddr = malloc(res->ai_addrlen);
! 2038: if (newaddr == NULL) {
! 2039: __ipsec_errcode = EIPSEC_NO_BUFS;
! 2040: freeaddrinfo(res);
! 2041: return NULL;
! 2042: }
! 2043: memcpy(newaddr, res->ai_addr, res->ai_addrlen);
! 2044:
! 2045: freeaddrinfo(res);
! 2046:
! 2047: __ipsec_errcode = EIPSEC_NO_ERROR;
! 2048: return newaddr;
! 2049: }
! 2050:
! 2051: static int
! 2052: rule_check()
! 2053: {
! 2054: if (p_type == IPSEC_POLICY_IPSEC) {
! 2055: if (p_protocol == IPPROTO_IP) {
! 2056: __ipsec_errcode = EIPSEC_NO_PROTO;
! 2057: return -1;
! 2058: }
! 2059:
! 2060: if (p_mode != IPSEC_MODE_TRANSPORT
! 2061: && p_mode != IPSEC_MODE_TUNNEL) {
! 2062: __ipsec_errcode = EIPSEC_INVAL_MODE;
! 2063: return -1;
! 2064: }
! 2065:
! 2066: if (p_src == NULL && p_dst == NULL) {
! 2067: if (p_mode != IPSEC_MODE_TRANSPORT) {
! 2068: __ipsec_errcode = EIPSEC_INVAL_ADDRESS;
! 2069: return -1;
! 2070: }
! 2071: }
! 2072: else if (p_src->sa_family != p_dst->sa_family) {
! 2073: __ipsec_errcode = EIPSEC_FAMILY_MISMATCH;
! 2074: return -1;
! 2075: }
! 2076: }
! 2077:
! 2078: __ipsec_errcode = EIPSEC_NO_ERROR;
! 2079: return 0;
! 2080: }
! 2081:
! 2082: static int
! 2083: init_x_policy()
! 2084: {
! 2085: struct sadb_x_policy *p;
! 2086:
! 2087: if (pbuf) {
! 2088: free(pbuf);
! 2089: tlen = 0;
! 2090: }
! 2091: pbuf = malloc(sizeof(struct sadb_x_policy));
! 2092: if (pbuf == NULL) {
! 2093: __ipsec_errcode = EIPSEC_NO_BUFS;
! 2094: return -1;
! 2095: }
! 2096: tlen = sizeof(struct sadb_x_policy);
! 2097:
! 2098: memset(pbuf, 0, tlen);
! 2099: p = (struct sadb_x_policy *)pbuf;
! 2100: p->sadb_x_policy_len = 0; /* must update later */
! 2101: p->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
! 2102: p->sadb_x_policy_type = p_type;
! 2103: p->sadb_x_policy_dir = p_dir;
! 2104: p->sadb_x_policy_id = 0;
! 2105: #ifdef HAVE_PFKEY_POLICY_PRIORITY
! 2106: p->sadb_x_policy_priority = p_priority;
! 2107: #else
! 2108: /* fail if given a priority and libipsec was not compiled with
! 2109: priority support */
! 2110: if (p_priority != 0)
! 2111: {
! 2112: __ipsec_errcode = EIPSEC_PRIORITY_NOT_COMPILED;
! 2113: return -1;
! 2114: }
! 2115: #endif
! 2116:
! 2117: offset = tlen;
! 2118:
! 2119: __ipsec_errcode = EIPSEC_NO_ERROR;
! 2120: return 0;
! 2121: }
! 2122:
! 2123: static int
! 2124: set_x_request(src, dst)
! 2125: struct sockaddr *src, *dst;
! 2126: {
! 2127: struct sadb_x_ipsecrequest *p;
! 2128: int reqlen;
! 2129: u_int8_t *n;
! 2130:
! 2131: reqlen = sizeof(*p)
! 2132: + (src ? sysdep_sa_len(src) : 0)
! 2133: + (dst ? sysdep_sa_len(dst) : 0);
! 2134: tlen += reqlen; /* increment to total length */
! 2135:
! 2136: n = realloc(pbuf, tlen);
! 2137: if (n == NULL) {
! 2138: __ipsec_errcode = EIPSEC_NO_BUFS;
! 2139: return -1;
! 2140: }
! 2141: pbuf = n;
! 2142:
! 2143: p = (struct sadb_x_ipsecrequest *)&pbuf[offset];
! 2144: p->sadb_x_ipsecrequest_len = reqlen;
! 2145: p->sadb_x_ipsecrequest_proto = p_protocol;
! 2146: p->sadb_x_ipsecrequest_mode = p_mode;
! 2147: p->sadb_x_ipsecrequest_level = p_level;
! 2148: p->sadb_x_ipsecrequest_reqid = p_reqid;
! 2149: offset += sizeof(*p);
! 2150:
! 2151: if (set_sockaddr(src) || set_sockaddr(dst))
! 2152: return -1;
! 2153:
! 2154: __ipsec_errcode = EIPSEC_NO_ERROR;
! 2155: return 0;
! 2156: }
! 2157:
! 2158: static int
! 2159: set_sockaddr(addr)
! 2160: struct sockaddr *addr;
! 2161: {
! 2162: if (addr == NULL) {
! 2163: __ipsec_errcode = EIPSEC_NO_ERROR;
! 2164: return 0;
! 2165: }
! 2166:
! 2167: /* tlen has already incremented */
! 2168:
! 2169: memcpy(&pbuf[offset], addr, sysdep_sa_len(addr));
! 2170:
! 2171: offset += sysdep_sa_len(addr);
! 2172:
! 2173: __ipsec_errcode = EIPSEC_NO_ERROR;
! 2174: return 0;
! 2175: }
! 2176:
! 2177: static void
! 2178: policy_parse_request_init()
! 2179: {
! 2180: p_protocol = IPPROTO_IP;
! 2181: p_mode = IPSEC_MODE_ANY;
! 2182: p_level = IPSEC_LEVEL_DEFAULT;
! 2183: p_reqid = 0;
! 2184: if (p_src != NULL) {
! 2185: free(p_src);
! 2186: p_src = NULL;
! 2187: }
! 2188: if (p_dst != NULL) {
! 2189: free(p_dst);
! 2190: p_dst = NULL;
! 2191: }
! 2192:
! 2193: return;
! 2194: }
! 2195:
! 2196: static void *
! 2197: policy_parse(msg, msglen)
! 2198: const char *msg;
! 2199: int msglen;
! 2200: {
! 2201: int error;
! 2202:
! 2203: pbuf = NULL;
! 2204: tlen = 0;
! 2205:
! 2206: /* initialize */
! 2207: p_dir = IPSEC_DIR_INVALID;
! 2208: p_type = IPSEC_POLICY_DISCARD;
! 2209: policy_parse_request_init();
! 2210: __policy__strbuffer__init__(msg);
! 2211:
! 2212: error = yyparse(); /* it must be set errcode. */
! 2213: __policy__strbuffer__free__();
! 2214:
! 2215: if (error) {
! 2216: if (pbuf != NULL)
! 2217: free(pbuf);
! 2218: return NULL;
! 2219: }
! 2220:
! 2221: /* update total length */
! 2222: ((struct sadb_x_policy *)pbuf)->sadb_x_policy_len = PFKEY_UNIT64(tlen);
! 2223:
! 2224: __ipsec_errcode = EIPSEC_NO_ERROR;
! 2225:
! 2226: return pbuf;
! 2227: }
! 2228:
! 2229: ipsec_policy_t
! 2230: ipsec_set_policy(msg, msglen)
! 2231: __ipsec_const char *msg;
! 2232: int msglen;
! 2233: {
! 2234: caddr_t policy;
! 2235:
! 2236: policy = policy_parse(msg, msglen);
! 2237: if (policy == NULL) {
! 2238: if (__ipsec_errcode == EIPSEC_NO_ERROR)
! 2239: __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
! 2240: return NULL;
! 2241: }
! 2242:
! 2243: __ipsec_errcode = EIPSEC_NO_ERROR;
! 2244: return policy;
! 2245: }
! 2246:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to policy_parse.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ipsec-tools / src / libipsec