Return to parse.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ipsec-tools / src / setkey |
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: ! 67: ! 68: /* Copy the first part of user declarations. */ ! 69: ! 70: /* Line 189 of yacc.c */ ! 71: #line 34 "parse.y" ! 72: ! 73: #ifdef HAVE_CONFIG_H ! 74: #include "config.h" ! 75: #endif ! 76: ! 77: #include <sys/types.h> ! 78: #include <sys/param.h> ! 79: #include <sys/socket.h> ! 80: ! 81: #include <netinet/in.h> ! 82: #include <net/pfkeyv2.h> ! 83: #include PATH_IPSEC_H ! 84: #include <arpa/inet.h> ! 85: ! 86: #include <string.h> ! 87: #include <unistd.h> ! 88: #include <stdio.h> ! 89: #include <netdb.h> ! 90: #include <ctype.h> ! 91: #include <errno.h> ! 92: #include <stdlib.h> ! 93: ! 94: #include "libpfkey.h" ! 95: #include "vchar.h" ! 96: #include "extern.h" ! 97: ! 98: #define DEFAULT_NATT_PORT 4500 ! 99: ! 100: #ifndef UDP_ENCAP_ESPINUDP ! 101: #define UDP_ENCAP_ESPINUDP 2 ! 102: #endif ! 103: ! 104: #define ATOX(c) \ ! 105: (isdigit((int)c) ? (c - '0') : \ ! 106: (isupper((int)c) ? (c - 'A' + 10) : (c - 'a' + 10))) ! 107: ! 108: u_int32_t p_spi; ! 109: u_int p_ext, p_alg_enc, p_alg_auth, p_replay, p_mode; ! 110: u_int32_t p_reqid; ! 111: u_int p_key_enc_len, p_key_auth_len; ! 112: const char *p_key_enc; ! 113: const char *p_key_auth; ! 114: time_t p_lt_hard, p_lt_soft; ! 115: size_t p_lb_hard, p_lb_soft; ! 116: ! 117: struct security_ctx { ! 118: u_int8_t doi; ! 119: u_int8_t alg; ! 120: u_int16_t len; ! 121: char *buf; ! 122: }; ! 123: ! 124: struct security_ctx sec_ctx; ! 125: ! 126: static u_int p_natt_type; ! 127: static struct addrinfo * p_natt_oa = NULL; ! 128: ! 129: static int p_aiflags = 0, p_aifamily = PF_UNSPEC; ! 130: ! 131: static struct addrinfo *parse_addr __P((char *, char *)); ! 132: static int fix_portstr __P((int, vchar_t *, vchar_t *, vchar_t *)); ! 133: static int setvarbuf __P((char *, int *, struct sadb_ext *, int, ! 134: const void *, int)); ! 135: void parse_init __P((void)); ! 136: void free_buffer __P((void)); ! 137: ! 138: int setkeymsg0 __P((struct sadb_msg *, unsigned int, unsigned int, size_t)); ! 139: static int setkeymsg_spdaddr __P((unsigned int, unsigned int, vchar_t *, ! 140: struct addrinfo *, int, struct addrinfo *, int)); ! 141: static int setkeymsg_spdaddr_tag __P((unsigned int, char *, vchar_t *)); ! 142: static int setkeymsg_addr __P((unsigned int, unsigned int, ! 143: struct addrinfo *, struct addrinfo *, int)); ! 144: static int setkeymsg_add __P((unsigned int, unsigned int, ! 145: struct addrinfo *, struct addrinfo *)); ! 146: ! 147: ! 148: /* Line 189 of yacc.c */ ! 149: #line 150 "parse.c" ! 150: ! 151: /* Enabling traces. */ ! 152: #ifndef YYDEBUG ! 153: # define YYDEBUG 0 ! 154: #endif ! 155: ! 156: /* Enabling verbose error messages. */ ! 157: #ifdef YYERROR_VERBOSE ! 158: # undef YYERROR_VERBOSE ! 159: # define YYERROR_VERBOSE 1 ! 160: #else ! 161: # define YYERROR_VERBOSE 0 ! 162: #endif ! 163: ! 164: /* Enabling the token table. */ ! 165: #ifndef YYTOKEN_TABLE ! 166: # define YYTOKEN_TABLE 0 ! 167: #endif ! 168: ! 169: ! 170: /* Tokens. */ ! 171: #ifndef YYTOKENTYPE ! 172: # define YYTOKENTYPE ! 173: /* Put the tokens into the symbol table, so that GDB and other debuggers ! 174: know about them. */ ! 175: enum yytokentype { ! 176: EOT = 258, ! 177: SLASH = 259, ! 178: BLCL = 260, ! 179: ELCL = 261, ! 180: ADD = 262, ! 181: GET = 263, ! 182: DELETE = 264, ! 183: DELETEALL = 265, ! 184: FLUSH = 266, ! 185: DUMP = 267, ! 186: EXIT = 268, ! 187: PR_ESP = 269, ! 188: PR_AH = 270, ! 189: PR_IPCOMP = 271, ! 190: PR_ESPUDP = 272, ! 191: PR_TCP = 273, ! 192: F_PROTOCOL = 274, ! 193: F_AUTH = 275, ! 194: F_ENC = 276, ! 195: F_REPLAY = 277, ! 196: F_COMP = 278, ! 197: F_RAWCPI = 279, ! 198: F_MODE = 280, ! 199: MODE = 281, ! 200: F_REQID = 282, ! 201: F_EXT = 283, ! 202: EXTENSION = 284, ! 203: NOCYCLICSEQ = 285, ! 204: ALG_AUTH = 286, ! 205: ALG_AUTH_NOKEY = 287, ! 206: ALG_ENC = 288, ! 207: ALG_ENC_NOKEY = 289, ! 208: ALG_ENC_DESDERIV = 290, ! 209: ALG_ENC_DES32IV = 291, ! 210: ALG_ENC_OLD = 292, ! 211: ALG_COMP = 293, ! 212: F_LIFETIME_HARD = 294, ! 213: F_LIFETIME_SOFT = 295, ! 214: F_LIFEBYTE_HARD = 296, ! 215: F_LIFEBYTE_SOFT = 297, ! 216: DECSTRING = 298, ! 217: QUOTEDSTRING = 299, ! 218: HEXSTRING = 300, ! 219: STRING = 301, ! 220: ANY = 302, ! 221: SPDADD = 303, ! 222: SPDUPDATE = 304, ! 223: SPDDELETE = 305, ! 224: SPDDUMP = 306, ! 225: SPDFLUSH = 307, ! 226: F_POLICY = 308, ! 227: PL_REQUESTS = 309, ! 228: F_AIFLAGS = 310, ! 229: TAGGED = 311, ! 230: SECURITY_CTX = 312 ! 231: }; ! 232: #endif ! 233: /* Tokens. */ ! 234: #define EOT 258 ! 235: #define SLASH 259 ! 236: #define BLCL 260 ! 237: #define ELCL 261 ! 238: #define ADD 262 ! 239: #define GET 263 ! 240: #define DELETE 264 ! 241: #define DELETEALL 265 ! 242: #define FLUSH 266 ! 243: #define DUMP 267 ! 244: #define EXIT 268 ! 245: #define PR_ESP 269 ! 246: #define PR_AH 270 ! 247: #define PR_IPCOMP 271 ! 248: #define PR_ESPUDP 272 ! 249: #define PR_TCP 273 ! 250: #define F_PROTOCOL 274 ! 251: #define F_AUTH 275 ! 252: #define F_ENC 276 ! 253: #define F_REPLAY 277 ! 254: #define F_COMP 278 ! 255: #define F_RAWCPI 279 ! 256: #define F_MODE 280 ! 257: #define MODE 281 ! 258: #define F_REQID 282 ! 259: #define F_EXT 283 ! 260: #define EXTENSION 284 ! 261: #define NOCYCLICSEQ 285 ! 262: #define ALG_AUTH 286 ! 263: #define ALG_AUTH_NOKEY 287 ! 264: #define ALG_ENC 288 ! 265: #define ALG_ENC_NOKEY 289 ! 266: #define ALG_ENC_DESDERIV 290 ! 267: #define ALG_ENC_DES32IV 291 ! 268: #define ALG_ENC_OLD 292 ! 269: #define ALG_COMP 293 ! 270: #define F_LIFETIME_HARD 294 ! 271: #define F_LIFETIME_SOFT 295 ! 272: #define F_LIFEBYTE_HARD 296 ! 273: #define F_LIFEBYTE_SOFT 297 ! 274: #define DECSTRING 298 ! 275: #define QUOTEDSTRING 299 ! 276: #define HEXSTRING 300 ! 277: #define STRING 301 ! 278: #define ANY 302 ! 279: #define SPDADD 303 ! 280: #define SPDUPDATE 304 ! 281: #define SPDDELETE 305 ! 282: #define SPDDUMP 306 ! 283: #define SPDFLUSH 307 ! 284: #define F_POLICY 308 ! 285: #define PL_REQUESTS 309 ! 286: #define F_AIFLAGS 310 ! 287: #define TAGGED 311 ! 288: #define SECURITY_CTX 312 ! 289: ! 290: ! 291: ! 292: ! 293: #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED ! 294: typedef union YYSTYPE ! 295: { ! 296: ! 297: /* Line 214 of yacc.c */ ! 298: #line 110 "parse.y" ! 299: ! 300: int num; ! 301: unsigned long ulnum; ! 302: vchar_t val; ! 303: struct addrinfo *res; ! 304: ! 305: ! 306: ! 307: /* Line 214 of yacc.c */ ! 308: #line 309 "parse.c" ! 309: } YYSTYPE; ! 310: # define YYSTYPE_IS_TRIVIAL 1 ! 311: # define yystype YYSTYPE /* obsolescent; will be withdrawn */ ! 312: # define YYSTYPE_IS_DECLARED 1 ! 313: #endif ! 314: ! 315: ! 316: /* Copy the second part of user declarations. */ ! 317: ! 318: ! 319: /* Line 264 of yacc.c */ ! 320: #line 321 "parse.c" ! 321: ! 322: #ifdef short ! 323: # undef short ! 324: #endif ! 325: ! 326: #ifdef YYTYPE_UINT8 ! 327: typedef YYTYPE_UINT8 yytype_uint8; ! 328: #else ! 329: typedef unsigned char yytype_uint8; ! 330: #endif ! 331: ! 332: #ifdef YYTYPE_INT8 ! 333: typedef YYTYPE_INT8 yytype_int8; ! 334: #elif (defined __STDC__ || defined __C99__FUNC__ \ ! 335: || defined __cplusplus || defined _MSC_VER) ! 336: typedef signed char yytype_int8; ! 337: #else ! 338: typedef short int yytype_int8; ! 339: #endif ! 340: ! 341: #ifdef YYTYPE_UINT16 ! 342: typedef YYTYPE_UINT16 yytype_uint16; ! 343: #else ! 344: typedef unsigned short int yytype_uint16; ! 345: #endif ! 346: ! 347: #ifdef YYTYPE_INT16 ! 348: typedef YYTYPE_INT16 yytype_int16; ! 349: #else ! 350: typedef short int yytype_int16; ! 351: #endif ! 352: ! 353: #ifndef YYSIZE_T ! 354: # ifdef __SIZE_TYPE__ ! 355: # define YYSIZE_T __SIZE_TYPE__ ! 356: # elif defined size_t ! 357: # define YYSIZE_T size_t ! 358: # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ ! 359: || defined __cplusplus || defined _MSC_VER) ! 360: # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ ! 361: # define YYSIZE_T size_t ! 362: # else ! 363: # define YYSIZE_T unsigned int ! 364: # endif ! 365: #endif ! 366: ! 367: #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) ! 368: ! 369: #ifndef YY_ ! 370: # if YYENABLE_NLS ! 371: # if ENABLE_NLS ! 372: # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ ! 373: # define YY_(msgid) dgettext ("bison-runtime", msgid) ! 374: # endif ! 375: # endif ! 376: # ifndef YY_ ! 377: # define YY_(msgid) msgid ! 378: # endif ! 379: #endif ! 380: ! 381: /* Suppress unused-variable warnings by "using" E. */ ! 382: #if ! defined lint || defined __GNUC__ ! 383: # define YYUSE(e) ((void) (e)) ! 384: #else ! 385: # define YYUSE(e) /* empty */ ! 386: #endif ! 387: ! 388: /* Identity function, used to suppress warnings about constant conditions. */ ! 389: #ifndef lint ! 390: # define YYID(n) (n) ! 391: #else ! 392: #if (defined __STDC__ || defined __C99__FUNC__ \ ! 393: || defined __cplusplus || defined _MSC_VER) ! 394: static int ! 395: YYID (int yyi) ! 396: #else ! 397: static int ! 398: YYID (yyi) ! 399: int yyi; ! 400: #endif ! 401: { ! 402: return yyi; ! 403: } ! 404: #endif ! 405: ! 406: #if ! defined yyoverflow || YYERROR_VERBOSE ! 407: ! 408: /* The parser invokes alloca or malloc; define the necessary symbols. */ ! 409: ! 410: # ifdef YYSTACK_USE_ALLOCA ! 411: # if YYSTACK_USE_ALLOCA ! 412: # ifdef __GNUC__ ! 413: # define YYSTACK_ALLOC __builtin_alloca ! 414: # elif defined __BUILTIN_VA_ARG_INCR ! 415: # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ ! 416: # elif defined _AIX ! 417: # define YYSTACK_ALLOC __alloca ! 418: # elif defined _MSC_VER ! 419: # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ ! 420: # define alloca _alloca ! 421: # else ! 422: # define YYSTACK_ALLOC alloca ! 423: # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ ! 424: || defined __cplusplus || defined _MSC_VER) ! 425: # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ ! 426: # ifndef _STDLIB_H ! 427: # define _STDLIB_H 1 ! 428: # endif ! 429: # endif ! 430: # endif ! 431: # endif ! 432: # endif ! 433: ! 434: # ifdef YYSTACK_ALLOC ! 435: /* Pacify GCC's `empty if-body' warning. */ ! 436: # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) ! 437: # ifndef YYSTACK_ALLOC_MAXIMUM ! 438: /* The OS might guarantee only one guard page at the bottom of the stack, ! 439: and a page size can be as small as 4096 bytes. So we cannot safely ! 440: invoke alloca (N) if N exceeds 4096. Use a slightly smaller number ! 441: to allow for a few compiler-allocated temporary stack slots. */ ! 442: # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ ! 443: # endif ! 444: # else ! 445: # define YYSTACK_ALLOC YYMALLOC ! 446: # define YYSTACK_FREE YYFREE ! 447: # ifndef YYSTACK_ALLOC_MAXIMUM ! 448: # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM ! 449: # endif ! 450: # if (defined __cplusplus && ! defined _STDLIB_H \ ! 451: && ! ((defined YYMALLOC || defined malloc) \ ! 452: && (defined YYFREE || defined free))) ! 453: # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ ! 454: # ifndef _STDLIB_H ! 455: # define _STDLIB_H 1 ! 456: # endif ! 457: # endif ! 458: # ifndef YYMALLOC ! 459: # define YYMALLOC malloc ! 460: # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ ! 461: || defined __cplusplus || defined _MSC_VER) ! 462: void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ ! 463: # endif ! 464: # endif ! 465: # ifndef YYFREE ! 466: # define YYFREE free ! 467: # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ ! 468: || defined __cplusplus || defined _MSC_VER) ! 469: void free (void *); /* INFRINGES ON USER NAME SPACE */ ! 470: # endif ! 471: # endif ! 472: # endif ! 473: #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ ! 474: ! 475: ! 476: #if (! defined yyoverflow \ ! 477: && (! defined __cplusplus \ ! 478: || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) ! 479: ! 480: /* A type that is properly aligned for any stack member. */ ! 481: union yyalloc ! 482: { ! 483: yytype_int16 yyss_alloc; ! 484: YYSTYPE yyvs_alloc; ! 485: }; ! 486: ! 487: /* The size of the maximum gap between one aligned stack and the next. */ ! 488: # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) ! 489: ! 490: /* The size of an array large to enough to hold all stacks, each with ! 491: N elements. */ ! 492: # define YYSTACK_BYTES(N) \ ! 493: ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ ! 494: + YYSTACK_GAP_MAXIMUM) ! 495: ! 496: /* Copy COUNT objects from FROM to TO. The source and destination do ! 497: not overlap. */ ! 498: # ifndef YYCOPY ! 499: # if defined __GNUC__ && 1 < __GNUC__ ! 500: # define YYCOPY(To, From, Count) \ ! 501: __builtin_memcpy (To, From, (Count) * sizeof (*(From))) ! 502: # else ! 503: # define YYCOPY(To, From, Count) \ ! 504: do \ ! 505: { \ ! 506: YYSIZE_T yyi; \ ! 507: for (yyi = 0; yyi < (Count); yyi++) \ ! 508: (To)[yyi] = (From)[yyi]; \ ! 509: } \ ! 510: while (YYID (0)) ! 511: # endif ! 512: # endif ! 513: ! 514: /* Relocate STACK from its old location to the new one. The ! 515: local variables YYSIZE and YYSTACKSIZE give the old and new number of ! 516: elements in the stack, and YYPTR gives the new location of the ! 517: stack. Advance YYPTR to a properly aligned location for the next ! 518: stack. */ ! 519: # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ ! 520: do \ ! 521: { \ ! 522: YYSIZE_T yynewbytes; \ ! 523: YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ ! 524: Stack = &yyptr->Stack_alloc; \ ! 525: yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ ! 526: yyptr += yynewbytes / sizeof (*yyptr); \ ! 527: } \ ! 528: while (YYID (0)) ! 529: ! 530: #endif ! 531: ! 532: /* YYFINAL -- State number of the termination state. */ ! 533: #define YYFINAL 2 ! 534: /* YYLAST -- Last index in YYTABLE. */ ! 535: #define YYLAST 174 ! 536: ! 537: /* YYNTOKENS -- Number of terminals. */ ! 538: #define YYNTOKENS 58 ! 539: /* YYNNTS -- Number of nonterminals. */ ! 540: #define YYNNTS 37 ! 541: /* YYNRULES -- Number of rules. */ ! 542: #define YYNRULES 90 ! 543: /* YYNRULES -- Number of states. */ ! 544: #define YYNSTATES 188 ! 545: ! 546: /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ ! 547: #define YYUNDEFTOK 2 ! 548: #define YYMAXUTOK 312 ! 549: ! 550: #define YYTRANSLATE(YYX) \ ! 551: ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) ! 552: ! 553: /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ ! 554: static const yytype_uint8 yytranslate[] = ! 555: { ! 556: 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 557: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 558: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 559: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 560: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 561: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 562: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 563: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 564: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 565: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 566: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 567: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 568: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 569: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 570: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 571: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 572: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 573: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 574: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 575: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 576: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 577: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 578: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 579: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 580: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 581: 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, ! 582: 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, ! 583: 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, ! 584: 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, ! 585: 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, ! 586: 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, ! 587: 55, 56, 57 ! 588: }; ! 589: ! 590: #if YYDEBUG ! 591: /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in ! 592: YYRHS. */ ! 593: static const yytype_uint16 yyprhs[] = ! 594: { ! 595: 0, 0, 3, 4, 7, 9, 11, 13, 15, 17, ! 596: 19, 21, 23, 25, 27, 29, 31, 41, 50, 57, ! 597: 66, 70, 74, 75, 77, 79, 81, 83, 86, 88, ! 598: 90, 92, 94, 96, 98, 103, 106, 109, 112, 116, ! 599: 118, 121, 123, 126, 129, 132, 134, 136, 138, 139, ! 600: 142, 145, 148, 151, 154, 157, 160, 163, 166, 169, ! 601: 172, 177, 191, 197, 211, 217, 231, 234, 237, 238, ! 602: 241, 243, 245, 247, 250, 251, 254, 255, 259, 263, ! 603: 267, 269, 271, 273, 275, 276, 278, 279, 284, 287, ! 604: 289 ! 605: }; ! 606: ! 607: /* YYRHS -- A `-1'-separated list of the rules' RHS. */ ! 608: static const yytype_int8 yyrhs[] = ! 609: { ! 610: 59, 0, -1, -1, 59, 60, -1, 61, -1, 64, ! 611: -1, 62, -1, 63, -1, 65, -1, 66, -1, 94, ! 612: -1, 78, -1, 79, -1, 80, -1, 81, -1, 82, ! 613: -1, 7, 83, 86, 86, 67, 68, 76, 69, 3, ! 614: -1, 9, 83, 86, 86, 67, 68, 76, 3, -1, ! 615: 10, 83, 85, 85, 67, 3, -1, 8, 83, 86, ! 616: 86, 67, 68, 76, 3, -1, 11, 67, 3, -1, ! 617: 12, 67, 3, -1, -1, 14, -1, 15, -1, 16, ! 618: -1, 17, -1, 17, 85, -1, 18, -1, 43, -1, ! 619: 45, -1, 70, -1, 71, -1, 72, -1, 21, 73, ! 620: 20, 74, -1, 21, 73, -1, 20, 74, -1, 23, ! 621: 38, -1, 23, 38, 24, -1, 34, -1, 33, 75, ! 622: -1, 37, -1, 35, 75, -1, 36, 75, -1, 31, ! 623: 75, -1, 32, -1, 44, -1, 45, -1, -1, 76, ! 624: 77, -1, 28, 29, -1, 28, 30, -1, 25, 26, ! 625: -1, 25, 47, -1, 27, 43, -1, 22, 43, -1, ! 626: 39, 43, -1, 40, 43, -1, 41, 43, -1, 42, ! 627: 43, -1, 57, 43, 43, 44, -1, 48, 83, 46, ! 628: 87, 88, 46, 87, 88, 89, 90, 91, 92, 3, ! 629: -1, 48, 56, 44, 92, 3, -1, 49, 83, 46, ! 630: 87, 88, 46, 87, 88, 89, 90, 91, 92, 3, ! 631: -1, 49, 56, 44, 92, 3, -1, 50, 83, 46, ! 632: 87, 88, 46, 87, 88, 89, 90, 91, 92, 3, ! 633: -1, 51, 3, -1, 52, 3, -1, -1, 83, 84, ! 634: -1, 55, -1, 46, -1, 46, -1, 46, 88, -1, ! 635: -1, 4, 43, -1, -1, 5, 47, 6, -1, 5, ! 636: 43, 6, -1, 5, 46, 6, -1, 43, -1, 47, ! 637: -1, 18, -1, 46, -1, -1, 46, -1, -1, 57, ! 638: 43, 43, 44, -1, 53, 93, -1, 54, -1, 13, ! 639: 3, -1 ! 640: }; ! 641: ! 642: /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ ! 643: static const yytype_uint16 yyrline[] = ! 644: { ! 645: 0, 151, 151, 153, 161, 162, 163, 164, 165, 166, ! 646: 167, 168, 169, 170, 171, 172, 178, 190, 209, 237, ! 647: 252, 262, 272, 275, 283, 291, 295, 302, 309, 318, ! 648: 319, 340, 341, 342, 346, 347, 351, 355, 363, 375, ! 649: 390, 405, 421, 442, 466, 491, 504, 508, 537, 539, ! 650: 543, 544, 545, 546, 547, 548, 557, 558, 559, 560, ! 651: 561, 573, 606, 619, 652, 664, 696, 707, 716, 718, ! 652: 722, 747, 758, 766, 777, 778, 783, 791, 800, 811, ! 653: 818, 819, 820, 823, 846, 850, 861, 863, 872, 896, ! 654: 901 ! 655: }; ! 656: #endif ! 657: ! 658: #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE ! 659: /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. ! 660: First, the terminals, then, starting at YYNTOKENS, nonterminals. */ ! 661: static const char *const yytname[] = ! 662: { ! 663: "$end", "error", "$undefined", "EOT", "SLASH", "BLCL", "ELCL", "ADD", ! 664: "GET", "DELETE", "DELETEALL", "FLUSH", "DUMP", "EXIT", "PR_ESP", "PR_AH", ! 665: "PR_IPCOMP", "PR_ESPUDP", "PR_TCP", "F_PROTOCOL", "F_AUTH", "F_ENC", ! 666: "F_REPLAY", "F_COMP", "F_RAWCPI", "F_MODE", "MODE", "F_REQID", "F_EXT", ! 667: "EXTENSION", "NOCYCLICSEQ", "ALG_AUTH", "ALG_AUTH_NOKEY", "ALG_ENC", ! 668: "ALG_ENC_NOKEY", "ALG_ENC_DESDERIV", "ALG_ENC_DES32IV", "ALG_ENC_OLD", ! 669: "ALG_COMP", "F_LIFETIME_HARD", "F_LIFETIME_SOFT", "F_LIFEBYTE_HARD", ! 670: "F_LIFEBYTE_SOFT", "DECSTRING", "QUOTEDSTRING", "HEXSTRING", "STRING", ! 671: "ANY", "SPDADD", "SPDUPDATE", "SPDDELETE", "SPDDUMP", "SPDFLUSH", ! 672: "F_POLICY", "PL_REQUESTS", "F_AIFLAGS", "TAGGED", "SECURITY_CTX", ! 673: "$accept", "commands", "command", "add_command", "delete_command", ! 674: "deleteall_command", "get_command", "flush_command", "dump_command", ! 675: "protocol_spec", "spi", "algorithm_spec", "esp_spec", "ah_spec", ! 676: "ipcomp_spec", "enc_alg", "auth_alg", "key_string", "extension_spec", ! 677: "extension", "spdadd_command", "spdupdate_command", "spddelete_command", ! 678: "spddump_command", "spdflush_command", "ipaddropts", "ipaddropt", ! 679: "ipaddr", "ipandport", "prefix", "portstr", "upper_spec", ! 680: "upper_misc_spec", "context_spec", "policy_spec", "policy_requests", ! 681: "exit_command", 0 ! 682: }; ! 683: #endif ! 684: ! 685: # ifdef YYPRINT ! 686: /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to ! 687: token YYLEX-NUM. */ ! 688: static const yytype_uint16 yytoknum[] = ! 689: { ! 690: 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, ! 691: 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, ! 692: 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, ! 693: 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, ! 694: 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, ! 695: 305, 306, 307, 308, 309, 310, 311, 312 ! 696: }; ! 697: # endif ! 698: ! 699: /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ ! 700: static const yytype_uint8 yyr1[] = ! 701: { ! 702: 0, 58, 59, 59, 60, 60, 60, 60, 60, 60, ! 703: 60, 60, 60, 60, 60, 60, 61, 62, 63, 64, ! 704: 65, 66, 67, 67, 67, 67, 67, 67, 67, 68, ! 705: 68, 69, 69, 69, 70, 70, 71, 72, 72, 73, ! 706: 73, 73, 73, 73, 74, 74, 75, 75, 76, 76, ! 707: 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, ! 708: 77, 78, 78, 79, 79, 80, 81, 82, 83, 83, ! 709: 84, 85, 86, 86, 87, 87, 88, 88, 88, 88, ! 710: 89, 89, 89, 89, 90, 90, 91, 91, 92, 93, ! 711: 94 ! 712: }; ! 713: ! 714: /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ ! 715: static const yytype_uint8 yyr2[] = ! 716: { ! 717: 0, 2, 0, 2, 1, 1, 1, 1, 1, 1, ! 718: 1, 1, 1, 1, 1, 1, 9, 8, 6, 8, ! 719: 3, 3, 0, 1, 1, 1, 1, 2, 1, 1, ! 720: 1, 1, 1, 1, 4, 2, 2, 2, 3, 1, ! 721: 2, 1, 2, 2, 2, 1, 1, 1, 0, 2, ! 722: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 723: 4, 13, 5, 13, 5, 13, 2, 2, 0, 2, ! 724: 1, 1, 1, 2, 0, 2, 0, 3, 3, 3, ! 725: 1, 1, 1, 1, 0, 1, 0, 4, 2, 1, ! 726: 2 ! 727: }; ! 728: ! 729: /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state ! 730: STATE-NUM when YYTABLE doesn't specify something else to do. Zero ! 731: means the default is an error. */ ! 732: static const yytype_uint8 yydefact[] = ! 733: { ! 734: 2, 0, 1, 68, 68, 68, 68, 22, 22, 0, ! 735: 68, 68, 68, 0, 0, 3, 4, 6, 7, 5, ! 736: 8, 9, 11, 12, 13, 14, 15, 10, 0, 0, ! 737: 0, 0, 23, 24, 25, 26, 28, 0, 0, 90, ! 738: 0, 0, 0, 0, 0, 66, 67, 72, 70, 69, ! 739: 0, 0, 0, 71, 0, 27, 20, 21, 0, 74, ! 740: 0, 74, 74, 0, 73, 22, 22, 22, 22, 0, ! 741: 0, 0, 76, 0, 76, 76, 0, 0, 0, 0, ! 742: 0, 0, 0, 89, 88, 62, 75, 0, 64, 0, ! 743: 0, 78, 79, 77, 29, 30, 48, 48, 48, 18, ! 744: 74, 74, 74, 0, 0, 0, 76, 76, 76, 0, ! 745: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 746: 0, 0, 31, 32, 33, 49, 19, 17, 0, 0, ! 747: 0, 0, 45, 36, 0, 39, 0, 0, 41, 35, ! 748: 55, 37, 52, 53, 54, 50, 51, 56, 57, 58, ! 749: 59, 0, 16, 82, 80, 83, 81, 84, 84, 84, ! 750: 46, 47, 44, 40, 42, 43, 0, 38, 0, 85, ! 751: 86, 86, 86, 34, 60, 0, 0, 0, 0, 0, ! 752: 0, 0, 0, 0, 61, 63, 65, 87 ! 753: }; ! 754: ! 755: /* YYDEFGOTO[NTERM-NUM]. */ ! 756: static const yytype_int16 yydefgoto[] = ! 757: { ! 758: -1, 1, 15, 16, 17, 18, 19, 20, 21, 37, ! 759: 96, 121, 122, 123, 124, 139, 133, 162, 103, 125, ! 760: 22, 23, 24, 25, 26, 28, 49, 54, 50, 72, ! 761: 64, 157, 170, 176, 70, 84, 27 ! 762: }; ! 763: ! 764: /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing ! 765: STATE-NUM. */ ! 766: #define YYPACT_NINF -61 ! 767: static const yytype_int16 yypact[] = ! 768: { ! 769: -61, 3, -61, -61, -61, -61, -61, 96, 96, 17, ! 770: -12, 1, -61, 78, 106, -61, -61, -61, -61, -61, ! 771: -61, -61, -61, -61, -61, -61, -61, -61, -38, -38, ! 772: -38, 29, -61, -61, -61, 69, -61, 122, 130, -61, ! 773: 92, 31, 93, 39, 49, -61, -61, 133, -61, -61, ! 774: 94, 94, 94, -61, 69, -61, -61, -61, 88, 135, ! 775: 88, 135, 135, -24, -61, 96, 96, 96, 96, 89, ! 776: 139, 101, 133, 142, 133, 133, 140, 141, 143, 81, ! 777: 81, 81, 145, -61, -61, -61, -61, 104, -61, 105, ! 778: 107, -61, -61, -61, -61, -61, -61, -61, -61, -61, ! 779: 135, 135, 135, 51, -1, 6, 133, 133, 133, -26, ! 780: 86, 109, 116, -22, 112, 13, 113, 114, 115, 117, ! 781: 118, 156, -61, -61, -61, -61, -61, -61, -11, -11, ! 782: -11, 5, -61, -61, 5, -61, 5, 5, -61, 144, ! 783: -61, 138, -61, -61, -61, -61, -61, -61, -61, -61, ! 784: -61, 120, -61, -61, -61, -61, -61, 119, 119, 119, ! 785: -61, -61, -61, -61, -61, -61, -26, -61, 123, -61, ! 786: 111, 111, 111, -61, -61, 126, 88, 88, 88, 127, ! 787: 163, 168, 169, 129, -61, -61, -61, -61 ! 788: }; ! 789: ! 790: /* YYPGOTO[NTERM-NUM]. */ ! 791: static const yytype_int8 yypgoto[] = ! 792: { ! 793: -61, -61, -61, -61, -61, -61, -61, -61, -61, -7, ! 794: 22, -61, -61, -61, -61, -61, 8, -54, 30, -61, ! 795: -61, -61, -61, -61, -61, 95, -61, -17, 37, -32, ! 796: -10, 0, -27, -37, -60, -61, -61 ! 797: }; ! 798: ! 799: /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If ! 800: positive, shift that token. If negative, reduce the rule which ! 801: number is the opposite. If zero, do what YYDEFACT says. ! 802: If YYTABLE_NINF, syntax error. */ ! 803: #define YYTABLE_NINF -1 ! 804: static const yytype_uint8 yytable[] = ! 805: { ! 806: 73, 38, 126, 2, 142, 131, 132, 153, 47, 127, ! 807: 3, 4, 5, 6, 7, 8, 9, 48, 55, 76, ! 808: 39, 111, 77, 78, 113, 143, 114, 115, 111, 74, ! 809: 75, 113, 154, 114, 115, 155, 156, 68, 116, 117, ! 810: 118, 119, 145, 146, 40, 116, 117, 118, 119, 160, ! 811: 161, 10, 11, 12, 13, 14, 120, 42, 79, 80, ! 812: 81, 82, 87, 120, 89, 90, 51, 52, 106, 107, ! 813: 108, 109, 110, 111, 112, 53, 113, 59, 114, 115, ! 814: 163, 45, 164, 165, 48, 61, 48, 65, 66, 67, ! 815: 116, 117, 118, 119, 48, 62, 128, 129, 130, 29, ! 816: 30, 31, 97, 98, 48, 41, 43, 44, 120, 46, ! 817: 32, 33, 34, 35, 36, 53, 180, 181, 182, 134, ! 818: 135, 136, 137, 138, 94, 56, 95, 104, 105, 158, ! 819: 159, 171, 172, 57, 177, 178, 58, 60, 63, 71, ! 820: 47, 69, 85, 83, 86, 88, 91, 92, 99, 93, ! 821: 100, 101, 140, 102, 141, 144, 147, 148, 149, 152, ! 822: 150, 151, 167, 168, 166, 169, 184, 174, 175, 179, ! 823: 183, 185, 186, 187, 173 ! 824: }; ! 825: ! 826: static const yytype_uint8 yycheck[] = ! 827: { ! 828: 60, 8, 3, 0, 26, 31, 32, 18, 46, 3, ! 829: 7, 8, 9, 10, 11, 12, 13, 55, 35, 43, ! 830: 3, 22, 46, 47, 25, 47, 27, 28, 22, 61, ! 831: 62, 25, 43, 27, 28, 46, 47, 54, 39, 40, ! 832: 41, 42, 29, 30, 56, 39, 40, 41, 42, 44, ! 833: 45, 48, 49, 50, 51, 52, 57, 56, 65, 66, ! 834: 67, 68, 72, 57, 74, 75, 29, 30, 100, 101, ! 835: 102, 20, 21, 22, 23, 46, 25, 46, 27, 28, ! 836: 134, 3, 136, 137, 55, 46, 55, 50, 51, 52, ! 837: 39, 40, 41, 42, 55, 46, 106, 107, 108, 4, ! 838: 5, 6, 80, 81, 55, 10, 11, 12, 57, 3, ! 839: 14, 15, 16, 17, 18, 46, 176, 177, 178, 33, ! 840: 34, 35, 36, 37, 43, 3, 45, 97, 98, 129, ! 841: 130, 158, 159, 3, 171, 172, 44, 44, 5, 4, ! 842: 46, 53, 3, 54, 43, 3, 6, 6, 3, 6, ! 843: 46, 46, 43, 46, 38, 43, 43, 43, 43, 3, ! 844: 43, 43, 24, 43, 20, 46, 3, 44, 57, 43, ! 845: 43, 3, 3, 44, 166 ! 846: }; ! 847: ! 848: /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing ! 849: symbol of state STATE-NUM. */ ! 850: static const yytype_uint8 yystos[] = ! 851: { ! 852: 0, 59, 0, 7, 8, 9, 10, 11, 12, 13, ! 853: 48, 49, 50, 51, 52, 60, 61, 62, 63, 64, ! 854: 65, 66, 78, 79, 80, 81, 82, 94, 83, 83, ! 855: 83, 83, 14, 15, 16, 17, 18, 67, 67, 3, ! 856: 56, 83, 56, 83, 83, 3, 3, 46, 55, 84, ! 857: 86, 86, 86, 46, 85, 85, 3, 3, 44, 46, ! 858: 44, 46, 46, 5, 88, 86, 86, 86, 85, 53, ! 859: 92, 4, 87, 92, 87, 87, 43, 46, 47, 67, ! 860: 67, 67, 67, 54, 93, 3, 43, 88, 3, 88, ! 861: 88, 6, 6, 6, 43, 45, 68, 68, 68, 3, ! 862: 46, 46, 46, 76, 76, 76, 87, 87, 87, 20, ! 863: 21, 22, 23, 25, 27, 28, 39, 40, 41, 42, ! 864: 57, 69, 70, 71, 72, 77, 3, 3, 88, 88, ! 865: 88, 31, 32, 74, 33, 34, 35, 36, 37, 73, ! 866: 43, 38, 26, 47, 43, 29, 30, 43, 43, 43, ! 867: 43, 43, 3, 18, 43, 46, 47, 89, 89, 89, ! 868: 44, 45, 75, 75, 75, 75, 20, 24, 43, 46, ! 869: 90, 90, 90, 74, 44, 57, 91, 91, 91, 43, ! 870: 92, 92, 92, 43, 3, 3, 3, 44 ! 871: }; ! 872: ! 873: #define yyerrok (yyerrstatus = 0) ! 874: #define yyclearin (yychar = YYEMPTY) ! 875: #define YYEMPTY (-2) ! 876: #define YYEOF 0 ! 877: ! 878: #define YYACCEPT goto yyacceptlab ! 879: #define YYABORT goto yyabortlab ! 880: #define YYERROR goto yyerrorlab ! 881: ! 882: ! 883: /* Like YYERROR except do call yyerror. This remains here temporarily ! 884: to ease the transition to the new meaning of YYERROR, for GCC. ! 885: Once GCC version 2 has supplanted version 1, this can go. */ ! 886: ! 887: #define YYFAIL goto yyerrlab ! 888: ! 889: #define YYRECOVERING() (!!yyerrstatus) ! 890: ! 891: #define YYBACKUP(Token, Value) \ ! 892: do \ ! 893: if (yychar == YYEMPTY && yylen == 1) \ ! 894: { \ ! 895: yychar = (Token); \ ! 896: yylval = (Value); \ ! 897: yytoken = YYTRANSLATE (yychar); \ ! 898: YYPOPSTACK (1); \ ! 899: goto yybackup; \ ! 900: } \ ! 901: else \ ! 902: { \ ! 903: yyerror (YY_("syntax error: cannot back up")); \ ! 904: YYERROR; \ ! 905: } \ ! 906: while (YYID (0)) ! 907: ! 908: ! 909: #define YYTERROR 1 ! 910: #define YYERRCODE 256 ! 911: ! 912: ! 913: /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. ! 914: If N is 0, then set CURRENT to the empty location which ends ! 915: the previous symbol: RHS[0] (always defined). */ ! 916: ! 917: #define YYRHSLOC(Rhs, K) ((Rhs)[K]) ! 918: #ifndef YYLLOC_DEFAULT ! 919: # define YYLLOC_DEFAULT(Current, Rhs, N) \ ! 920: do \ ! 921: if (YYID (N)) \ ! 922: { \ ! 923: (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ ! 924: (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ ! 925: (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ ! 926: (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ ! 927: } \ ! 928: else \ ! 929: { \ ! 930: (Current).first_line = (Current).last_line = \ ! 931: YYRHSLOC (Rhs, 0).last_line; \ ! 932: (Current).first_column = (Current).last_column = \ ! 933: YYRHSLOC (Rhs, 0).last_column; \ ! 934: } \ ! 935: while (YYID (0)) ! 936: #endif ! 937: ! 938: ! 939: /* YY_LOCATION_PRINT -- Print the location on the stream. ! 940: This macro was not mandated originally: define only if we know ! 941: we won't break user code: when these are the locations we know. */ ! 942: ! 943: #ifndef YY_LOCATION_PRINT ! 944: # if YYLTYPE_IS_TRIVIAL ! 945: # define YY_LOCATION_PRINT(File, Loc) \ ! 946: fprintf (File, "%d.%d-%d.%d", \ ! 947: (Loc).first_line, (Loc).first_column, \ ! 948: (Loc).last_line, (Loc).last_column) ! 949: # else ! 950: # define YY_LOCATION_PRINT(File, Loc) ((void) 0) ! 951: # endif ! 952: #endif ! 953: ! 954: ! 955: /* YYLEX -- calling `yylex' with the right arguments. */ ! 956: ! 957: #ifdef YYLEX_PARAM ! 958: # define YYLEX yylex (YYLEX_PARAM) ! 959: #else ! 960: # define YYLEX yylex () ! 961: #endif ! 962: ! 963: /* Enable debugging if requested. */ ! 964: #if YYDEBUG ! 965: ! 966: # ifndef YYFPRINTF ! 967: # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ ! 968: # define YYFPRINTF fprintf ! 969: # endif ! 970: ! 971: # define YYDPRINTF(Args) \ ! 972: do { \ ! 973: if (yydebug) \ ! 974: YYFPRINTF Args; \ ! 975: } while (YYID (0)) ! 976: ! 977: # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ ! 978: do { \ ! 979: if (yydebug) \ ! 980: { \ ! 981: YYFPRINTF (stderr, "%s ", Title); \ ! 982: yy_symbol_print (stderr, \ ! 983: Type, Value); \ ! 984: YYFPRINTF (stderr, "\n"); \ ! 985: } \ ! 986: } while (YYID (0)) ! 987: ! 988: ! 989: /*--------------------------------. ! 990: | Print this symbol on YYOUTPUT. | ! 991: `--------------------------------*/ ! 992: ! 993: /*ARGSUSED*/ ! 994: #if (defined __STDC__ || defined __C99__FUNC__ \ ! 995: || defined __cplusplus || defined _MSC_VER) ! 996: static void ! 997: yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) ! 998: #else ! 999: static void ! 1000: yy_symbol_value_print (yyoutput, yytype, yyvaluep) ! 1001: FILE *yyoutput; ! 1002: int yytype; ! 1003: YYSTYPE const * const yyvaluep; ! 1004: #endif ! 1005: { ! 1006: if (!yyvaluep) ! 1007: return; ! 1008: # ifdef YYPRINT ! 1009: if (yytype < YYNTOKENS) ! 1010: YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); ! 1011: # else ! 1012: YYUSE (yyoutput); ! 1013: # endif ! 1014: switch (yytype) ! 1015: { ! 1016: default: ! 1017: break; ! 1018: } ! 1019: } ! 1020: ! 1021: ! 1022: /*--------------------------------. ! 1023: | Print this symbol on YYOUTPUT. | ! 1024: `--------------------------------*/ ! 1025: ! 1026: #if (defined __STDC__ || defined __C99__FUNC__ \ ! 1027: || defined __cplusplus || defined _MSC_VER) ! 1028: static void ! 1029: yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) ! 1030: #else ! 1031: static void ! 1032: yy_symbol_print (yyoutput, yytype, yyvaluep) ! 1033: FILE *yyoutput; ! 1034: int yytype; ! 1035: YYSTYPE const * const yyvaluep; ! 1036: #endif ! 1037: { ! 1038: if (yytype < YYNTOKENS) ! 1039: YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); ! 1040: else ! 1041: YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); ! 1042: ! 1043: yy_symbol_value_print (yyoutput, yytype, yyvaluep); ! 1044: YYFPRINTF (yyoutput, ")"); ! 1045: } ! 1046: ! 1047: /*------------------------------------------------------------------. ! 1048: | yy_stack_print -- Print the state stack from its BOTTOM up to its | ! 1049: | TOP (included). | ! 1050: `------------------------------------------------------------------*/ ! 1051: ! 1052: #if (defined __STDC__ || defined __C99__FUNC__ \ ! 1053: || defined __cplusplus || defined _MSC_VER) ! 1054: static void ! 1055: yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) ! 1056: #else ! 1057: static void ! 1058: yy_stack_print (yybottom, yytop) ! 1059: yytype_int16 *yybottom; ! 1060: yytype_int16 *yytop; ! 1061: #endif ! 1062: { ! 1063: YYFPRINTF (stderr, "Stack now"); ! 1064: for (; yybottom <= yytop; yybottom++) ! 1065: { ! 1066: int yybot = *yybottom; ! 1067: YYFPRINTF (stderr, " %d", yybot); ! 1068: } ! 1069: YYFPRINTF (stderr, "\n"); ! 1070: } ! 1071: ! 1072: # define YY_STACK_PRINT(Bottom, Top) \ ! 1073: do { \ ! 1074: if (yydebug) \ ! 1075: yy_stack_print ((Bottom), (Top)); \ ! 1076: } while (YYID (0)) ! 1077: ! 1078: ! 1079: /*------------------------------------------------. ! 1080: | Report that the YYRULE is going to be reduced. | ! 1081: `------------------------------------------------*/ ! 1082: ! 1083: #if (defined __STDC__ || defined __C99__FUNC__ \ ! 1084: || defined __cplusplus || defined _MSC_VER) ! 1085: static void ! 1086: yy_reduce_print (YYSTYPE *yyvsp, int yyrule) ! 1087: #else ! 1088: static void ! 1089: yy_reduce_print (yyvsp, yyrule) ! 1090: YYSTYPE *yyvsp; ! 1091: int yyrule; ! 1092: #endif ! 1093: { ! 1094: int yynrhs = yyr2[yyrule]; ! 1095: int yyi; ! 1096: unsigned long int yylno = yyrline[yyrule]; ! 1097: YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", ! 1098: yyrule - 1, yylno); ! 1099: /* The symbols being reduced. */ ! 1100: for (yyi = 0; yyi < yynrhs; yyi++) ! 1101: { ! 1102: YYFPRINTF (stderr, " $%d = ", yyi + 1); ! 1103: yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], ! 1104: &(yyvsp[(yyi + 1) - (yynrhs)]) ! 1105: ); ! 1106: YYFPRINTF (stderr, "\n"); ! 1107: } ! 1108: } ! 1109: ! 1110: # define YY_REDUCE_PRINT(Rule) \ ! 1111: do { \ ! 1112: if (yydebug) \ ! 1113: yy_reduce_print (yyvsp, Rule); \ ! 1114: } while (YYID (0)) ! 1115: ! 1116: /* Nonzero means print parse trace. It is left uninitialized so that ! 1117: multiple parsers can coexist. */ ! 1118: int yydebug; ! 1119: #else /* !YYDEBUG */ ! 1120: # define YYDPRINTF(Args) ! 1121: # define YY_SYMBOL_PRINT(Title, Type, Value, Location) ! 1122: # define YY_STACK_PRINT(Bottom, Top) ! 1123: # define YY_REDUCE_PRINT(Rule) ! 1124: #endif /* !YYDEBUG */ ! 1125: ! 1126: ! 1127: /* YYINITDEPTH -- initial size of the parser's stacks. */ ! 1128: #ifndef YYINITDEPTH ! 1129: # define YYINITDEPTH 200 ! 1130: #endif ! 1131: ! 1132: /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only ! 1133: if the built-in stack extension method is used). ! 1134: ! 1135: Do not make this value too large; the results are undefined if ! 1136: YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) ! 1137: evaluated with infinite-precision integer arithmetic. */ ! 1138: ! 1139: #ifndef YYMAXDEPTH ! 1140: # define YYMAXDEPTH 10000 ! 1141: #endif ! 1142: ! 1143: ! 1144: ! 1145: #if YYERROR_VERBOSE ! 1146: ! 1147: # ifndef yystrlen ! 1148: # if defined __GLIBC__ && defined _STRING_H ! 1149: # define yystrlen strlen ! 1150: # else ! 1151: /* Return the length of YYSTR. */ ! 1152: #if (defined __STDC__ || defined __C99__FUNC__ \ ! 1153: || defined __cplusplus || defined _MSC_VER) ! 1154: static YYSIZE_T ! 1155: yystrlen (const char *yystr) ! 1156: #else ! 1157: static YYSIZE_T ! 1158: yystrlen (yystr) ! 1159: const char *yystr; ! 1160: #endif ! 1161: { ! 1162: YYSIZE_T yylen; ! 1163: for (yylen = 0; yystr[yylen]; yylen++) ! 1164: continue; ! 1165: return yylen; ! 1166: } ! 1167: # endif ! 1168: # endif ! 1169: ! 1170: # ifndef yystpcpy ! 1171: # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE ! 1172: # define yystpcpy stpcpy ! 1173: # else ! 1174: /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in ! 1175: YYDEST. */ ! 1176: #if (defined __STDC__ || defined __C99__FUNC__ \ ! 1177: || defined __cplusplus || defined _MSC_VER) ! 1178: static char * ! 1179: yystpcpy (char *yydest, const char *yysrc) ! 1180: #else ! 1181: static char * ! 1182: yystpcpy (yydest, yysrc) ! 1183: char *yydest; ! 1184: const char *yysrc; ! 1185: #endif ! 1186: { ! 1187: char *yyd = yydest; ! 1188: const char *yys = yysrc; ! 1189: ! 1190: while ((*yyd++ = *yys++) != '\0') ! 1191: continue; ! 1192: ! 1193: return yyd - 1; ! 1194: } ! 1195: # endif ! 1196: # endif ! 1197: ! 1198: # ifndef yytnamerr ! 1199: /* Copy to YYRES the contents of YYSTR after stripping away unnecessary ! 1200: quotes and backslashes, so that it's suitable for yyerror. The ! 1201: heuristic is that double-quoting is unnecessary unless the string ! 1202: contains an apostrophe, a comma, or backslash (other than ! 1203: backslash-backslash). YYSTR is taken from yytname. If YYRES is ! 1204: null, do not copy; instead, return the length of what the result ! 1205: would have been. */ ! 1206: static YYSIZE_T ! 1207: yytnamerr (char *yyres, const char *yystr) ! 1208: { ! 1209: if (*yystr == '"') ! 1210: { ! 1211: YYSIZE_T yyn = 0; ! 1212: char const *yyp = yystr; ! 1213: ! 1214: for (;;) ! 1215: switch (*++yyp) ! 1216: { ! 1217: case '\'': ! 1218: case ',': ! 1219: goto do_not_strip_quotes; ! 1220: ! 1221: case '\\': ! 1222: if (*++yyp != '\\') ! 1223: goto do_not_strip_quotes; ! 1224: /* Fall through. */ ! 1225: default: ! 1226: if (yyres) ! 1227: yyres[yyn] = *yyp; ! 1228: yyn++; ! 1229: break; ! 1230: ! 1231: case '"': ! 1232: if (yyres) ! 1233: yyres[yyn] = '\0'; ! 1234: return yyn; ! 1235: } ! 1236: do_not_strip_quotes: ; ! 1237: } ! 1238: ! 1239: if (! yyres) ! 1240: return yystrlen (yystr); ! 1241: ! 1242: return yystpcpy (yyres, yystr) - yyres; ! 1243: } ! 1244: # endif ! 1245: ! 1246: /* Copy into YYRESULT an error message about the unexpected token ! 1247: YYCHAR while in state YYSTATE. Return the number of bytes copied, ! 1248: including the terminating null byte. If YYRESULT is null, do not ! 1249: copy anything; just return the number of bytes that would be ! 1250: copied. As a special case, return 0 if an ordinary "syntax error" ! 1251: message will do. Return YYSIZE_MAXIMUM if overflow occurs during ! 1252: size calculation. */ ! 1253: static YYSIZE_T ! 1254: yysyntax_error (char *yyresult, int yystate, int yychar) ! 1255: { ! 1256: int yyn = yypact[yystate]; ! 1257: ! 1258: if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) ! 1259: return 0; ! 1260: else ! 1261: { ! 1262: int yytype = YYTRANSLATE (yychar); ! 1263: YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); ! 1264: YYSIZE_T yysize = yysize0; ! 1265: YYSIZE_T yysize1; ! 1266: int yysize_overflow = 0; ! 1267: enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; ! 1268: char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; ! 1269: int yyx; ! 1270: ! 1271: # if 0 ! 1272: /* This is so xgettext sees the translatable formats that are ! 1273: constructed on the fly. */ ! 1274: YY_("syntax error, unexpected %s"); ! 1275: YY_("syntax error, unexpected %s, expecting %s"); ! 1276: YY_("syntax error, unexpected %s, expecting %s or %s"); ! 1277: YY_("syntax error, unexpected %s, expecting %s or %s or %s"); ! 1278: YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); ! 1279: # endif ! 1280: char *yyfmt; ! 1281: char const *yyf; ! 1282: static char const yyunexpected[] = "syntax error, unexpected %s"; ! 1283: static char const yyexpecting[] = ", expecting %s"; ! 1284: static char const yyor[] = " or %s"; ! 1285: char yyformat[sizeof yyunexpected ! 1286: + sizeof yyexpecting - 1 ! 1287: + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) ! 1288: * (sizeof yyor - 1))]; ! 1289: char const *yyprefix = yyexpecting; ! 1290: ! 1291: /* Start YYX at -YYN if negative to avoid negative indexes in ! 1292: YYCHECK. */ ! 1293: int yyxbegin = yyn < 0 ? -yyn : 0; ! 1294: ! 1295: /* Stay within bounds of both yycheck and yytname. */ ! 1296: int yychecklim = YYLAST - yyn + 1; ! 1297: int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ! 1298: int yycount = 1; ! 1299: ! 1300: yyarg[0] = yytname[yytype]; ! 1301: yyfmt = yystpcpy (yyformat, yyunexpected); ! 1302: ! 1303: for (yyx = yyxbegin; yyx < yyxend; ++yyx) ! 1304: if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) ! 1305: { ! 1306: if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ! 1307: { ! 1308: yycount = 1; ! 1309: yysize = yysize0; ! 1310: yyformat[sizeof yyunexpected - 1] = '\0'; ! 1311: break; ! 1312: } ! 1313: yyarg[yycount++] = yytname[yyx]; ! 1314: yysize1 = yysize + yytnamerr (0, yytname[yyx]); ! 1315: yysize_overflow |= (yysize1 < yysize); ! 1316: yysize = yysize1; ! 1317: yyfmt = yystpcpy (yyfmt, yyprefix); ! 1318: yyprefix = yyor; ! 1319: } ! 1320: ! 1321: yyf = YY_(yyformat); ! 1322: yysize1 = yysize + yystrlen (yyf); ! 1323: yysize_overflow |= (yysize1 < yysize); ! 1324: yysize = yysize1; ! 1325: ! 1326: if (yysize_overflow) ! 1327: return YYSIZE_MAXIMUM; ! 1328: ! 1329: if (yyresult) ! 1330: { ! 1331: /* Avoid sprintf, as that infringes on the user's name space. ! 1332: Don't have undefined behavior even if the translation ! 1333: produced a string with the wrong number of "%s"s. */ ! 1334: char *yyp = yyresult; ! 1335: int yyi = 0; ! 1336: while ((*yyp = *yyf) != '\0') ! 1337: { ! 1338: if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) ! 1339: { ! 1340: yyp += yytnamerr (yyp, yyarg[yyi++]); ! 1341: yyf += 2; ! 1342: } ! 1343: else ! 1344: { ! 1345: yyp++; ! 1346: yyf++; ! 1347: } ! 1348: } ! 1349: } ! 1350: return yysize; ! 1351: } ! 1352: } ! 1353: #endif /* YYERROR_VERBOSE */ ! 1354: ! 1355: ! 1356: /*-----------------------------------------------. ! 1357: | Release the memory associated to this symbol. | ! 1358: `-----------------------------------------------*/ ! 1359: ! 1360: /*ARGSUSED*/ ! 1361: #if (defined __STDC__ || defined __C99__FUNC__ \ ! 1362: || defined __cplusplus || defined _MSC_VER) ! 1363: static void ! 1364: yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) ! 1365: #else ! 1366: static void ! 1367: yydestruct (yymsg, yytype, yyvaluep) ! 1368: const char *yymsg; ! 1369: int yytype; ! 1370: YYSTYPE *yyvaluep; ! 1371: #endif ! 1372: { ! 1373: YYUSE (yyvaluep); ! 1374: ! 1375: if (!yymsg) ! 1376: yymsg = "Deleting"; ! 1377: YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); ! 1378: ! 1379: switch (yytype) ! 1380: { ! 1381: ! 1382: default: ! 1383: break; ! 1384: } ! 1385: } ! 1386: ! 1387: /* Prevent warnings from -Wmissing-prototypes. */ ! 1388: #ifdef YYPARSE_PARAM ! 1389: #if defined __STDC__ || defined __cplusplus ! 1390: int yyparse (void *YYPARSE_PARAM); ! 1391: #else ! 1392: int yyparse (); ! 1393: #endif ! 1394: #else /* ! YYPARSE_PARAM */ ! 1395: #if defined __STDC__ || defined __cplusplus ! 1396: int yyparse (void); ! 1397: #else ! 1398: int yyparse (); ! 1399: #endif ! 1400: #endif /* ! YYPARSE_PARAM */ ! 1401: ! 1402: ! 1403: /* The lookahead symbol. */ ! 1404: int yychar; ! 1405: ! 1406: /* The semantic value of the lookahead symbol. */ ! 1407: YYSTYPE yylval; ! 1408: ! 1409: /* Number of syntax errors so far. */ ! 1410: int yynerrs; ! 1411: ! 1412: ! 1413: ! 1414: /*-------------------------. ! 1415: | yyparse or yypush_parse. | ! 1416: `-------------------------*/ ! 1417: ! 1418: #ifdef YYPARSE_PARAM ! 1419: #if (defined __STDC__ || defined __C99__FUNC__ \ ! 1420: || defined __cplusplus || defined _MSC_VER) ! 1421: int ! 1422: yyparse (void *YYPARSE_PARAM) ! 1423: #else ! 1424: int ! 1425: yyparse (YYPARSE_PARAM) ! 1426: void *YYPARSE_PARAM; ! 1427: #endif ! 1428: #else /* ! YYPARSE_PARAM */ ! 1429: #if (defined __STDC__ || defined __C99__FUNC__ \ ! 1430: || defined __cplusplus || defined _MSC_VER) ! 1431: int ! 1432: yyparse (void) ! 1433: #else ! 1434: int ! 1435: yyparse () ! 1436: ! 1437: #endif ! 1438: #endif ! 1439: { ! 1440: ! 1441: ! 1442: int yystate; ! 1443: /* Number of tokens to shift before error messages enabled. */ ! 1444: int yyerrstatus; ! 1445: ! 1446: /* The stacks and their tools: ! 1447: `yyss': related to states. ! 1448: `yyvs': related to semantic values. ! 1449: ! 1450: Refer to the stacks thru separate pointers, to allow yyoverflow ! 1451: to reallocate them elsewhere. */ ! 1452: ! 1453: /* The state stack. */ ! 1454: yytype_int16 yyssa[YYINITDEPTH]; ! 1455: yytype_int16 *yyss; ! 1456: yytype_int16 *yyssp; ! 1457: ! 1458: /* The semantic value stack. */ ! 1459: YYSTYPE yyvsa[YYINITDEPTH]; ! 1460: YYSTYPE *yyvs; ! 1461: YYSTYPE *yyvsp; ! 1462: ! 1463: YYSIZE_T yystacksize; ! 1464: ! 1465: int yyn; ! 1466: int yyresult; ! 1467: /* Lookahead token as an internal (translated) token number. */ ! 1468: int yytoken; ! 1469: /* The variables used to return semantic value and location from the ! 1470: action routines. */ ! 1471: YYSTYPE yyval; ! 1472: ! 1473: #if YYERROR_VERBOSE ! 1474: /* Buffer for error messages, and its allocated size. */ ! 1475: char yymsgbuf[128]; ! 1476: char *yymsg = yymsgbuf; ! 1477: YYSIZE_T yymsg_alloc = sizeof yymsgbuf; ! 1478: #endif ! 1479: ! 1480: #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ! 1481: ! 1482: /* The number of symbols on the RHS of the reduced rule. ! 1483: Keep to zero when no symbol should be popped. */ ! 1484: int yylen = 0; ! 1485: ! 1486: yytoken = 0; ! 1487: yyss = yyssa; ! 1488: yyvs = yyvsa; ! 1489: yystacksize = YYINITDEPTH; ! 1490: ! 1491: YYDPRINTF ((stderr, "Starting parse\n")); ! 1492: ! 1493: yystate = 0; ! 1494: yyerrstatus = 0; ! 1495: yynerrs = 0; ! 1496: yychar = YYEMPTY; /* Cause a token to be read. */ ! 1497: ! 1498: /* Initialize stack pointers. ! 1499: Waste one element of value and location stack ! 1500: so that they stay on the same level as the state stack. ! 1501: The wasted elements are never initialized. */ ! 1502: yyssp = yyss; ! 1503: yyvsp = yyvs; ! 1504: ! 1505: goto yysetstate; ! 1506: ! 1507: /*------------------------------------------------------------. ! 1508: | yynewstate -- Push a new state, which is found in yystate. | ! 1509: `------------------------------------------------------------*/ ! 1510: yynewstate: ! 1511: /* In all cases, when you get here, the value and location stacks ! 1512: have just been pushed. So pushing a state here evens the stacks. */ ! 1513: yyssp++; ! 1514: ! 1515: yysetstate: ! 1516: *yyssp = yystate; ! 1517: ! 1518: if (yyss + yystacksize - 1 <= yyssp) ! 1519: { ! 1520: /* Get the current used size of the three stacks, in elements. */ ! 1521: YYSIZE_T yysize = yyssp - yyss + 1; ! 1522: ! 1523: #ifdef yyoverflow ! 1524: { ! 1525: /* Give user a chance to reallocate the stack. Use copies of ! 1526: these so that the &'s don't force the real ones into ! 1527: memory. */ ! 1528: YYSTYPE *yyvs1 = yyvs; ! 1529: yytype_int16 *yyss1 = yyss; ! 1530: ! 1531: /* Each stack pointer address is followed by the size of the ! 1532: data in use in that stack, in bytes. This used to be a ! 1533: conditional around just the two extra args, but that might ! 1534: be undefined if yyoverflow is a macro. */ ! 1535: yyoverflow (YY_("memory exhausted"), ! 1536: &yyss1, yysize * sizeof (*yyssp), ! 1537: &yyvs1, yysize * sizeof (*yyvsp), ! 1538: &yystacksize); ! 1539: ! 1540: yyss = yyss1; ! 1541: yyvs = yyvs1; ! 1542: } ! 1543: #else /* no yyoverflow */ ! 1544: # ifndef YYSTACK_RELOCATE ! 1545: goto yyexhaustedlab; ! 1546: # else ! 1547: /* Extend the stack our own way. */ ! 1548: if (YYMAXDEPTH <= yystacksize) ! 1549: goto yyexhaustedlab; ! 1550: yystacksize *= 2; ! 1551: if (YYMAXDEPTH < yystacksize) ! 1552: yystacksize = YYMAXDEPTH; ! 1553: ! 1554: { ! 1555: yytype_int16 *yyss1 = yyss; ! 1556: union yyalloc *yyptr = ! 1557: (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); ! 1558: if (! yyptr) ! 1559: goto yyexhaustedlab; ! 1560: YYSTACK_RELOCATE (yyss_alloc, yyss); ! 1561: YYSTACK_RELOCATE (yyvs_alloc, yyvs); ! 1562: # undef YYSTACK_RELOCATE ! 1563: if (yyss1 != yyssa) ! 1564: YYSTACK_FREE (yyss1); ! 1565: } ! 1566: # endif ! 1567: #endif /* no yyoverflow */ ! 1568: ! 1569: yyssp = yyss + yysize - 1; ! 1570: yyvsp = yyvs + yysize - 1; ! 1571: ! 1572: YYDPRINTF ((stderr, "Stack size increased to %lu\n", ! 1573: (unsigned long int) yystacksize)); ! 1574: ! 1575: if (yyss + yystacksize - 1 <= yyssp) ! 1576: YYABORT; ! 1577: } ! 1578: ! 1579: YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ! 1580: ! 1581: if (yystate == YYFINAL) ! 1582: YYACCEPT; ! 1583: ! 1584: goto yybackup; ! 1585: ! 1586: /*-----------. ! 1587: | yybackup. | ! 1588: `-----------*/ ! 1589: yybackup: ! 1590: ! 1591: /* Do appropriate processing given the current state. Read a ! 1592: lookahead token if we need one and don't already have one. */ ! 1593: ! 1594: /* First try to decide what to do without reference to lookahead token. */ ! 1595: yyn = yypact[yystate]; ! 1596: if (yyn == YYPACT_NINF) ! 1597: goto yydefault; ! 1598: ! 1599: /* Not known => get a lookahead token if don't already have one. */ ! 1600: ! 1601: /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ ! 1602: if (yychar == YYEMPTY) ! 1603: { ! 1604: YYDPRINTF ((stderr, "Reading a token: ")); ! 1605: yychar = YYLEX; ! 1606: } ! 1607: ! 1608: if (yychar <= YYEOF) ! 1609: { ! 1610: yychar = yytoken = YYEOF; ! 1611: YYDPRINTF ((stderr, "Now at end of input.\n")); ! 1612: } ! 1613: else ! 1614: { ! 1615: yytoken = YYTRANSLATE (yychar); ! 1616: YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); ! 1617: } ! 1618: ! 1619: /* If the proper action on seeing token YYTOKEN is to reduce or to ! 1620: detect an error, take that action. */ ! 1621: yyn += yytoken; ! 1622: if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ! 1623: goto yydefault; ! 1624: yyn = yytable[yyn]; ! 1625: if (yyn <= 0) ! 1626: { ! 1627: if (yyn == 0 || yyn == YYTABLE_NINF) ! 1628: goto yyerrlab; ! 1629: yyn = -yyn; ! 1630: goto yyreduce; ! 1631: } ! 1632: ! 1633: /* Count tokens shifted since error; after three, turn off error ! 1634: status. */ ! 1635: if (yyerrstatus) ! 1636: yyerrstatus--; ! 1637: ! 1638: /* Shift the lookahead token. */ ! 1639: YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); ! 1640: ! 1641: /* Discard the shifted token. */ ! 1642: yychar = YYEMPTY; ! 1643: ! 1644: yystate = yyn; ! 1645: *++yyvsp = yylval; ! 1646: ! 1647: goto yynewstate; ! 1648: ! 1649: ! 1650: /*-----------------------------------------------------------. ! 1651: | yydefault -- do the default action for the current state. | ! 1652: `-----------------------------------------------------------*/ ! 1653: yydefault: ! 1654: yyn = yydefact[yystate]; ! 1655: if (yyn == 0) ! 1656: goto yyerrlab; ! 1657: goto yyreduce; ! 1658: ! 1659: ! 1660: /*-----------------------------. ! 1661: | yyreduce -- Do a reduction. | ! 1662: `-----------------------------*/ ! 1663: yyreduce: ! 1664: /* yyn is the number of a rule to reduce with. */ ! 1665: yylen = yyr2[yyn]; ! 1666: ! 1667: /* If YYLEN is nonzero, implement the default value of the action: ! 1668: `$$ = $1'. ! 1669: ! 1670: Otherwise, the following line sets YYVAL to garbage. ! 1671: This behavior is undocumented and Bison ! 1672: users should not rely upon it. Assigning to YYVAL ! 1673: unconditionally makes the parser a bit smaller, and it avoids a ! 1674: GCC warning that YYVAL may be used uninitialized. */ ! 1675: yyval = yyvsp[1-yylen]; ! 1676: ! 1677: ! 1678: YY_REDUCE_PRINT (yyn); ! 1679: switch (yyn) ! 1680: { ! 1681: case 3: ! 1682: ! 1683: /* Line 1455 of yacc.c */ ! 1684: #line 154 "parse.y" ! 1685: { ! 1686: free_buffer(); ! 1687: parse_init(); ! 1688: } ! 1689: break; ! 1690: ! 1691: case 16: ! 1692: ! 1693: /* Line 1455 of yacc.c */ ! 1694: #line 179 "parse.y" ! 1695: { ! 1696: int status; ! 1697: ! 1698: status = setkeymsg_add(SADB_ADD, (yyvsp[(5) - (9)].num), (yyvsp[(3) - (9)].res), (yyvsp[(4) - (9)].res)); ! 1699: if (status < 0) ! 1700: return -1; ! 1701: } ! 1702: break; ! 1703: ! 1704: case 17: ! 1705: ! 1706: /* Line 1455 of yacc.c */ ! 1707: #line 191 "parse.y" ! 1708: { ! 1709: int status; ! 1710: ! 1711: if ((yyvsp[(3) - (8)].res)->ai_next || (yyvsp[(4) - (8)].res)->ai_next) { ! 1712: yyerror("multiple address specified"); ! 1713: return -1; ! 1714: } ! 1715: if (p_mode != IPSEC_MODE_ANY) ! 1716: yyerror("WARNING: mode is obsolete"); ! 1717: ! 1718: status = setkeymsg_addr(SADB_DELETE, (yyvsp[(5) - (8)].num), (yyvsp[(3) - (8)].res), (yyvsp[(4) - (8)].res), 0); ! 1719: if (status < 0) ! 1720: return -1; ! 1721: } ! 1722: break; ! 1723: ! 1724: case 18: ! 1725: ! 1726: /* Line 1455 of yacc.c */ ! 1727: #line 210 "parse.y" ! 1728: { ! 1729: #ifndef __linux__ ! 1730: if (setkeymsg_addr(SADB_DELETE, (yyvsp[(5) - (6)].num), (yyvsp[(3) - (6)].res), (yyvsp[(4) - (6)].res), 1) < 0) ! 1731: return -1; ! 1732: #else /* __linux__ */ ! 1733: /* linux strictly adheres to RFC2367, and returns ! 1734: * an error if we send an SADB_DELETE request without ! 1735: * an SPI. Therefore, we must first retrieve a list ! 1736: * of SPIs for all matching SADB entries, and then ! 1737: * delete each one separately. */ ! 1738: u_int32_t *spi; ! 1739: int i, n; ! 1740: ! 1741: spi = sendkeymsg_spigrep((yyvsp[(5) - (6)].num), (yyvsp[(3) - (6)].res), (yyvsp[(4) - (6)].res), &n); ! 1742: for (i = 0; i < n; i++) { ! 1743: p_spi = spi[i]; ! 1744: if (setkeymsg_addr(SADB_DELETE, ! 1745: (yyvsp[(5) - (6)].num), (yyvsp[(3) - (6)].res), (yyvsp[(4) - (6)].res), 0) < 0) ! 1746: return -1; ! 1747: } ! 1748: free(spi); ! 1749: #endif /* __linux__ */ ! 1750: } ! 1751: break; ! 1752: ! 1753: case 19: ! 1754: ! 1755: /* Line 1455 of yacc.c */ ! 1756: #line 238 "parse.y" ! 1757: { ! 1758: int status; ! 1759: ! 1760: if (p_mode != IPSEC_MODE_ANY) ! 1761: yyerror("WARNING: mode is obsolete"); ! 1762: ! 1763: status = setkeymsg_addr(SADB_GET, (yyvsp[(5) - (8)].num), (yyvsp[(3) - (8)].res), (yyvsp[(4) - (8)].res), 0); ! 1764: if (status < 0) ! 1765: return -1; ! 1766: } ! 1767: break; ! 1768: ! 1769: case 20: ! 1770: ! 1771: /* Line 1455 of yacc.c */ ! 1772: #line 253 "parse.y" ! 1773: { ! 1774: struct sadb_msg msg; ! 1775: setkeymsg0(&msg, SADB_FLUSH, (yyvsp[(2) - (3)].num), sizeof(msg)); ! 1776: sendkeymsg((char *)&msg, sizeof(msg)); ! 1777: } ! 1778: break; ! 1779: ! 1780: case 21: ! 1781: ! 1782: /* Line 1455 of yacc.c */ ! 1783: #line 263 "parse.y" ! 1784: { ! 1785: struct sadb_msg msg; ! 1786: setkeymsg0(&msg, SADB_DUMP, (yyvsp[(2) - (3)].num), sizeof(msg)); ! 1787: sendkeymsg((char *)&msg, sizeof(msg)); ! 1788: } ! 1789: break; ! 1790: ! 1791: case 22: ! 1792: ! 1793: /* Line 1455 of yacc.c */ ! 1794: #line 272 "parse.y" ! 1795: { ! 1796: (yyval.num) = SADB_SATYPE_UNSPEC; ! 1797: } ! 1798: break; ! 1799: ! 1800: case 23: ! 1801: ! 1802: /* Line 1455 of yacc.c */ ! 1803: #line 276 "parse.y" ! 1804: { ! 1805: (yyval.num) = SADB_SATYPE_ESP; ! 1806: if ((yyvsp[(1) - (1)].num) == 1) ! 1807: p_ext |= SADB_X_EXT_OLD; ! 1808: else ! 1809: p_ext &= ~SADB_X_EXT_OLD; ! 1810: } ! 1811: break; ! 1812: ! 1813: case 24: ! 1814: ! 1815: /* Line 1455 of yacc.c */ ! 1816: #line 284 "parse.y" ! 1817: { ! 1818: (yyval.num) = SADB_SATYPE_AH; ! 1819: if ((yyvsp[(1) - (1)].num) == 1) ! 1820: p_ext |= SADB_X_EXT_OLD; ! 1821: else ! 1822: p_ext &= ~SADB_X_EXT_OLD; ! 1823: } ! 1824: break; ! 1825: ! 1826: case 25: ! 1827: ! 1828: /* Line 1455 of yacc.c */ ! 1829: #line 292 "parse.y" ! 1830: { ! 1831: (yyval.num) = SADB_X_SATYPE_IPCOMP; ! 1832: } ! 1833: break; ! 1834: ! 1835: case 26: ! 1836: ! 1837: /* Line 1455 of yacc.c */ ! 1838: #line 296 "parse.y" ! 1839: { ! 1840: (yyval.num) = SADB_SATYPE_ESP; ! 1841: p_ext &= ~SADB_X_EXT_OLD; ! 1842: p_natt_oa = 0; ! 1843: p_natt_type = UDP_ENCAP_ESPINUDP; ! 1844: } ! 1845: break; ! 1846: ! 1847: case 27: ! 1848: ! 1849: /* Line 1455 of yacc.c */ ! 1850: #line 303 "parse.y" ! 1851: { ! 1852: (yyval.num) = SADB_SATYPE_ESP; ! 1853: p_ext &= ~SADB_X_EXT_OLD; ! 1854: p_natt_oa = (yyvsp[(2) - (2)].res); ! 1855: p_natt_type = UDP_ENCAP_ESPINUDP; ! 1856: } ! 1857: break; ! 1858: ! 1859: case 28: ! 1860: ! 1861: /* Line 1455 of yacc.c */ ! 1862: #line 310 "parse.y" ! 1863: { ! 1864: #ifdef SADB_X_SATYPE_TCPSIGNATURE ! 1865: (yyval.num) = SADB_X_SATYPE_TCPSIGNATURE; ! 1866: #endif ! 1867: } ! 1868: break; ! 1869: ! 1870: case 29: ! 1871: ! 1872: /* Line 1455 of yacc.c */ ! 1873: #line 318 "parse.y" ! 1874: { p_spi = (yyvsp[(1) - (1)].ulnum); } ! 1875: break; ! 1876: ! 1877: case 30: ! 1878: ! 1879: /* Line 1455 of yacc.c */ ! 1880: #line 320 "parse.y" ! 1881: { ! 1882: char *ep; ! 1883: unsigned long v; ! 1884: ! 1885: ep = NULL; ! 1886: v = strtoul((yyvsp[(1) - (1)].val).buf, &ep, 16); ! 1887: if (!ep || *ep) { ! 1888: yyerror("invalid SPI"); ! 1889: return -1; ! 1890: } ! 1891: if (v & ~0xffffffff) { ! 1892: yyerror("SPI too big."); ! 1893: return -1; ! 1894: } ! 1895: ! 1896: p_spi = v; ! 1897: } ! 1898: break; ! 1899: ! 1900: case 37: ! 1901: ! 1902: /* Line 1455 of yacc.c */ ! 1903: #line 356 "parse.y" ! 1904: { ! 1905: if ((yyvsp[(2) - (2)].num) < 0) { ! 1906: yyerror("unsupported algorithm"); ! 1907: return -1; ! 1908: } ! 1909: p_alg_enc = (yyvsp[(2) - (2)].num); ! 1910: } ! 1911: break; ! 1912: ! 1913: case 38: ! 1914: ! 1915: /* Line 1455 of yacc.c */ ! 1916: #line 364 "parse.y" ! 1917: { ! 1918: if ((yyvsp[(2) - (3)].num) < 0) { ! 1919: yyerror("unsupported algorithm"); ! 1920: return -1; ! 1921: } ! 1922: p_alg_enc = (yyvsp[(2) - (3)].num); ! 1923: p_ext |= SADB_X_EXT_RAWCPI; ! 1924: } ! 1925: break; ! 1926: ! 1927: case 39: ! 1928: ! 1929: /* Line 1455 of yacc.c */ ! 1930: #line 375 "parse.y" ! 1931: { ! 1932: if ((yyvsp[(1) - (1)].num) < 0) { ! 1933: yyerror("unsupported algorithm"); ! 1934: return -1; ! 1935: } ! 1936: p_alg_enc = (yyvsp[(1) - (1)].num); ! 1937: ! 1938: p_key_enc_len = 0; ! 1939: p_key_enc = ""; ! 1940: if (ipsec_check_keylen(SADB_EXT_SUPPORTED_ENCRYPT, ! 1941: p_alg_enc, PFKEY_UNUNIT64(p_key_enc_len)) < 0) { ! 1942: yyerror(ipsec_strerror()); ! 1943: return -1; ! 1944: } ! 1945: } ! 1946: break; ! 1947: ! 1948: case 40: ! 1949: ! 1950: /* Line 1455 of yacc.c */ ! 1951: #line 390 "parse.y" ! 1952: { ! 1953: if ((yyvsp[(1) - (2)].num) < 0) { ! 1954: yyerror("unsupported algorithm"); ! 1955: return -1; ! 1956: } ! 1957: p_alg_enc = (yyvsp[(1) - (2)].num); ! 1958: ! 1959: p_key_enc_len = (yyvsp[(2) - (2)].val).len; ! 1960: p_key_enc = (yyvsp[(2) - (2)].val).buf; ! 1961: if (ipsec_check_keylen(SADB_EXT_SUPPORTED_ENCRYPT, ! 1962: p_alg_enc, PFKEY_UNUNIT64(p_key_enc_len)) < 0) { ! 1963: yyerror(ipsec_strerror()); ! 1964: return -1; ! 1965: } ! 1966: } ! 1967: break; ! 1968: ! 1969: case 41: ! 1970: ! 1971: /* Line 1455 of yacc.c */ ! 1972: #line 405 "parse.y" ! 1973: { ! 1974: if ((yyvsp[(1) - (1)].num) < 0) { ! 1975: yyerror("unsupported algorithm"); ! 1976: return -1; ! 1977: } ! 1978: yyerror("WARNING: obsolete algorithm"); ! 1979: p_alg_enc = (yyvsp[(1) - (1)].num); ! 1980: ! 1981: p_key_enc_len = 0; ! 1982: p_key_enc = ""; ! 1983: if (ipsec_check_keylen(SADB_EXT_SUPPORTED_ENCRYPT, ! 1984: p_alg_enc, PFKEY_UNUNIT64(p_key_enc_len)) < 0) { ! 1985: yyerror(ipsec_strerror()); ! 1986: return -1; ! 1987: } ! 1988: } ! 1989: break; ! 1990: ! 1991: case 42: ! 1992: ! 1993: /* Line 1455 of yacc.c */ ! 1994: #line 422 "parse.y" ! 1995: { ! 1996: if ((yyvsp[(1) - (2)].num) < 0) { ! 1997: yyerror("unsupported algorithm"); ! 1998: return -1; ! 1999: } ! 2000: p_alg_enc = (yyvsp[(1) - (2)].num); ! 2001: if (p_ext & SADB_X_EXT_OLD) { ! 2002: yyerror("algorithm mismatched"); ! 2003: return -1; ! 2004: } ! 2005: p_ext |= SADB_X_EXT_DERIV; ! 2006: ! 2007: p_key_enc_len = (yyvsp[(2) - (2)].val).len; ! 2008: p_key_enc = (yyvsp[(2) - (2)].val).buf; ! 2009: if (ipsec_check_keylen(SADB_EXT_SUPPORTED_ENCRYPT, ! 2010: p_alg_enc, PFKEY_UNUNIT64(p_key_enc_len)) < 0) { ! 2011: yyerror(ipsec_strerror()); ! 2012: return -1; ! 2013: } ! 2014: } ! 2015: break; ! 2016: ! 2017: case 43: ! 2018: ! 2019: /* Line 1455 of yacc.c */ ! 2020: #line 443 "parse.y" ! 2021: { ! 2022: if ((yyvsp[(1) - (2)].num) < 0) { ! 2023: yyerror("unsupported algorithm"); ! 2024: return -1; ! 2025: } ! 2026: p_alg_enc = (yyvsp[(1) - (2)].num); ! 2027: if (!(p_ext & SADB_X_EXT_OLD)) { ! 2028: yyerror("algorithm mismatched"); ! 2029: return -1; ! 2030: } ! 2031: p_ext |= SADB_X_EXT_IV4B; ! 2032: ! 2033: p_key_enc_len = (yyvsp[(2) - (2)].val).len; ! 2034: p_key_enc = (yyvsp[(2) - (2)].val).buf; ! 2035: if (ipsec_check_keylen(SADB_EXT_SUPPORTED_ENCRYPT, ! 2036: p_alg_enc, PFKEY_UNUNIT64(p_key_enc_len)) < 0) { ! 2037: yyerror(ipsec_strerror()); ! 2038: return -1; ! 2039: } ! 2040: } ! 2041: break; ! 2042: ! 2043: case 44: ! 2044: ! 2045: /* Line 1455 of yacc.c */ ! 2046: #line 466 "parse.y" ! 2047: { ! 2048: if ((yyvsp[(1) - (2)].num) < 0) { ! 2049: yyerror("unsupported algorithm"); ! 2050: return -1; ! 2051: } ! 2052: p_alg_auth = (yyvsp[(1) - (2)].num); ! 2053: ! 2054: p_key_auth_len = (yyvsp[(2) - (2)].val).len; ! 2055: p_key_auth = (yyvsp[(2) - (2)].val).buf; ! 2056: #ifdef SADB_X_AALG_TCP_MD5 ! 2057: if (p_alg_auth == SADB_X_AALG_TCP_MD5) { ! 2058: if ((p_key_auth_len < 1) || ! 2059: (p_key_auth_len > 80)) ! 2060: return -1; ! 2061: } else ! 2062: #endif ! 2063: { ! 2064: if (ipsec_check_keylen(SADB_EXT_SUPPORTED_AUTH, ! 2065: p_alg_auth, ! 2066: PFKEY_UNUNIT64(p_key_auth_len)) < 0) { ! 2067: yyerror(ipsec_strerror()); ! 2068: return -1; ! 2069: } ! 2070: } ! 2071: } ! 2072: break; ! 2073: ! 2074: case 45: ! 2075: ! 2076: /* Line 1455 of yacc.c */ ! 2077: #line 491 "parse.y" ! 2078: { ! 2079: if ((yyvsp[(1) - (1)].num) < 0) { ! 2080: yyerror("unsupported algorithm"); ! 2081: return -1; ! 2082: } ! 2083: p_alg_auth = (yyvsp[(1) - (1)].num); ! 2084: ! 2085: p_key_auth_len = 0; ! 2086: p_key_auth = NULL; ! 2087: } ! 2088: break; ! 2089: ! 2090: case 46: ! 2091: ! 2092: /* Line 1455 of yacc.c */ ! 2093: #line 505 "parse.y" ! 2094: { ! 2095: (yyval.val) = (yyvsp[(1) - (1)].val); ! 2096: } ! 2097: break; ! 2098: ! 2099: case 47: ! 2100: ! 2101: /* Line 1455 of yacc.c */ ! 2102: #line 509 "parse.y" ! 2103: { ! 2104: caddr_t pp_key; ! 2105: caddr_t bp; ! 2106: caddr_t yp = (yyvsp[(1) - (1)].val).buf; ! 2107: int l; ! 2108: ! 2109: l = strlen(yp) % 2 + strlen(yp) / 2; ! 2110: if ((pp_key = malloc(l)) == 0) { ! 2111: yyerror("not enough core"); ! 2112: return -1; ! 2113: } ! 2114: memset(pp_key, 0, l); ! 2115: ! 2116: bp = pp_key; ! 2117: if (strlen(yp) % 2) { ! 2118: *bp = ATOX(yp[0]); ! 2119: yp++, bp++; ! 2120: } ! 2121: while (*yp) { ! 2122: *bp = (ATOX(yp[0]) << 4) | ATOX(yp[1]); ! 2123: yp += 2, bp++; ! 2124: } ! 2125: ! 2126: (yyval.val).len = l; ! 2127: (yyval.val).buf = pp_key; ! 2128: } ! 2129: break; ! 2130: ! 2131: case 50: ! 2132: ! 2133: /* Line 1455 of yacc.c */ ! 2134: #line 543 "parse.y" ! 2135: { p_ext |= (yyvsp[(2) - (2)].num); } ! 2136: break; ! 2137: ! 2138: case 51: ! 2139: ! 2140: /* Line 1455 of yacc.c */ ! 2141: #line 544 "parse.y" ! 2142: { p_ext &= ~SADB_X_EXT_CYCSEQ; } ! 2143: break; ! 2144: ! 2145: case 52: ! 2146: ! 2147: /* Line 1455 of yacc.c */ ! 2148: #line 545 "parse.y" ! 2149: { p_mode = (yyvsp[(2) - (2)].num); } ! 2150: break; ! 2151: ! 2152: case 53: ! 2153: ! 2154: /* Line 1455 of yacc.c */ ! 2155: #line 546 "parse.y" ! 2156: { p_mode = IPSEC_MODE_ANY; } ! 2157: break; ! 2158: ! 2159: case 54: ! 2160: ! 2161: /* Line 1455 of yacc.c */ ! 2162: #line 547 "parse.y" ! 2163: { p_reqid = (yyvsp[(2) - (2)].ulnum); } ! 2164: break; ! 2165: ! 2166: case 55: ! 2167: ! 2168: /* Line 1455 of yacc.c */ ! 2169: #line 549 "parse.y" ! 2170: { ! 2171: if ((p_ext & SADB_X_EXT_OLD) != 0) { ! 2172: yyerror("replay prevention cannot be used with " ! 2173: "ah/esp-old"); ! 2174: return -1; ! 2175: } ! 2176: p_replay = (yyvsp[(2) - (2)].ulnum); ! 2177: } ! 2178: break; ! 2179: ! 2180: case 56: ! 2181: ! 2182: /* Line 1455 of yacc.c */ ! 2183: #line 557 "parse.y" ! 2184: { p_lt_hard = (yyvsp[(2) - (2)].ulnum); } ! 2185: break; ! 2186: ! 2187: case 57: ! 2188: ! 2189: /* Line 1455 of yacc.c */ ! 2190: #line 558 "parse.y" ! 2191: { p_lt_soft = (yyvsp[(2) - (2)].ulnum); } ! 2192: break; ! 2193: ! 2194: case 58: ! 2195: ! 2196: /* Line 1455 of yacc.c */ ! 2197: #line 559 "parse.y" ! 2198: { p_lb_hard = (yyvsp[(2) - (2)].ulnum); } ! 2199: break; ! 2200: ! 2201: case 59: ! 2202: ! 2203: /* Line 1455 of yacc.c */ ! 2204: #line 560 "parse.y" ! 2205: { p_lb_soft = (yyvsp[(2) - (2)].ulnum); } ! 2206: break; ! 2207: ! 2208: case 60: ! 2209: ! 2210: /* Line 1455 of yacc.c */ ! 2211: #line 561 "parse.y" ! 2212: { ! 2213: sec_ctx.doi = (yyvsp[(2) - (4)].ulnum); ! 2214: sec_ctx.alg = (yyvsp[(3) - (4)].ulnum); ! 2215: sec_ctx.len = (yyvsp[(4) - (4)].val).len+1; ! 2216: sec_ctx.buf = (yyvsp[(4) - (4)].val).buf; ! 2217: } ! 2218: break; ! 2219: ! 2220: case 61: ! 2221: ! 2222: /* Line 1455 of yacc.c */ ! 2223: #line 574 "parse.y" ! 2224: { ! 2225: int status; ! 2226: struct addrinfo *src, *dst; ! 2227: ! 2228: #ifdef HAVE_PFKEY_POLICY_PRIORITY ! 2229: last_msg_type = SADB_X_SPDADD; ! 2230: #endif ! 2231: ! 2232: /* fixed port fields if ulp is icmp */ ! 2233: if (fix_portstr((yyvsp[(9) - (13)].num), &(yyvsp[(10) - (13)].val), &(yyvsp[(5) - (13)].val), &(yyvsp[(8) - (13)].val))) ! 2234: return -1; ! 2235: ! 2236: src = parse_addr((yyvsp[(3) - (13)].val).buf, (yyvsp[(5) - (13)].val).buf); ! 2237: dst = parse_addr((yyvsp[(6) - (13)].val).buf, (yyvsp[(8) - (13)].val).buf); ! 2238: if (!src || !dst) { ! 2239: /* yyerror is already called */ ! 2240: return -1; ! 2241: } ! 2242: if (src->ai_next || dst->ai_next) { ! 2243: yyerror("multiple address specified"); ! 2244: freeaddrinfo(src); ! 2245: freeaddrinfo(dst); ! 2246: return -1; ! 2247: } ! 2248: ! 2249: status = setkeymsg_spdaddr(SADB_X_SPDADD, (yyvsp[(9) - (13)].num), &(yyvsp[(12) - (13)].val), ! 2250: src, (yyvsp[(4) - (13)].num), dst, (yyvsp[(7) - (13)].num)); ! 2251: freeaddrinfo(src); ! 2252: freeaddrinfo(dst); ! 2253: if (status < 0) ! 2254: return -1; ! 2255: } ! 2256: break; ! 2257: ! 2258: case 62: ! 2259: ! 2260: /* Line 1455 of yacc.c */ ! 2261: #line 607 "parse.y" ! 2262: { ! 2263: int status; ! 2264: ! 2265: status = setkeymsg_spdaddr_tag(SADB_X_SPDADD, ! 2266: (yyvsp[(3) - (5)].val).buf, &(yyvsp[(4) - (5)].val)); ! 2267: if (status < 0) ! 2268: return -1; ! 2269: } ! 2270: break; ! 2271: ! 2272: case 63: ! 2273: ! 2274: /* Line 1455 of yacc.c */ ! 2275: #line 620 "parse.y" ! 2276: { ! 2277: int status; ! 2278: struct addrinfo *src, *dst; ! 2279: ! 2280: #ifdef HAVE_PFKEY_POLICY_PRIORITY ! 2281: last_msg_type = SADB_X_SPDUPDATE; ! 2282: #endif ! 2283: ! 2284: /* fixed port fields if ulp is icmp */ ! 2285: if (fix_portstr((yyvsp[(9) - (13)].num), &(yyvsp[(10) - (13)].val), &(yyvsp[(5) - (13)].val), &(yyvsp[(8) - (13)].val))) ! 2286: return -1; ! 2287: ! 2288: src = parse_addr((yyvsp[(3) - (13)].val).buf, (yyvsp[(5) - (13)].val).buf); ! 2289: dst = parse_addr((yyvsp[(6) - (13)].val).buf, (yyvsp[(8) - (13)].val).buf); ! 2290: if (!src || !dst) { ! 2291: /* yyerror is already called */ ! 2292: return -1; ! 2293: } ! 2294: if (src->ai_next || dst->ai_next) { ! 2295: yyerror("multiple address specified"); ! 2296: freeaddrinfo(src); ! 2297: freeaddrinfo(dst); ! 2298: return -1; ! 2299: } ! 2300: ! 2301: status = setkeymsg_spdaddr(SADB_X_SPDUPDATE, (yyvsp[(9) - (13)].num), &(yyvsp[(12) - (13)].val), ! 2302: src, (yyvsp[(4) - (13)].num), dst, (yyvsp[(7) - (13)].num)); ! 2303: freeaddrinfo(src); ! 2304: freeaddrinfo(dst); ! 2305: if (status < 0) ! 2306: return -1; ! 2307: } ! 2308: break; ! 2309: ! 2310: case 64: ! 2311: ! 2312: /* Line 1455 of yacc.c */ ! 2313: #line 653 "parse.y" ! 2314: { ! 2315: int status; ! 2316: ! 2317: status = setkeymsg_spdaddr_tag(SADB_X_SPDUPDATE, ! 2318: (yyvsp[(3) - (5)].val).buf, &(yyvsp[(4) - (5)].val)); ! 2319: if (status < 0) ! 2320: return -1; ! 2321: } ! 2322: break; ! 2323: ! 2324: case 65: ! 2325: ! 2326: /* Line 1455 of yacc.c */ ! 2327: #line 665 "parse.y" ! 2328: { ! 2329: int status; ! 2330: struct addrinfo *src, *dst; ! 2331: ! 2332: /* fixed port fields if ulp is icmp */ ! 2333: if (fix_portstr((yyvsp[(9) - (13)].num), &(yyvsp[(10) - (13)].val), &(yyvsp[(5) - (13)].val), &(yyvsp[(8) - (13)].val))) ! 2334: return -1; ! 2335: ! 2336: src = parse_addr((yyvsp[(3) - (13)].val).buf, (yyvsp[(5) - (13)].val).buf); ! 2337: dst = parse_addr((yyvsp[(6) - (13)].val).buf, (yyvsp[(8) - (13)].val).buf); ! 2338: if (!src || !dst) { ! 2339: /* yyerror is already called */ ! 2340: return -1; ! 2341: } ! 2342: if (src->ai_next || dst->ai_next) { ! 2343: yyerror("multiple address specified"); ! 2344: freeaddrinfo(src); ! 2345: freeaddrinfo(dst); ! 2346: return -1; ! 2347: } ! 2348: ! 2349: status = setkeymsg_spdaddr(SADB_X_SPDDELETE, (yyvsp[(9) - (13)].num), &(yyvsp[(12) - (13)].val), ! 2350: src, (yyvsp[(4) - (13)].num), dst, (yyvsp[(7) - (13)].num)); ! 2351: freeaddrinfo(src); ! 2352: freeaddrinfo(dst); ! 2353: if (status < 0) ! 2354: return -1; ! 2355: } ! 2356: break; ! 2357: ! 2358: case 66: ! 2359: ! 2360: /* Line 1455 of yacc.c */ ! 2361: #line 697 "parse.y" ! 2362: { ! 2363: struct sadb_msg msg; ! 2364: setkeymsg0(&msg, SADB_X_SPDDUMP, SADB_SATYPE_UNSPEC, ! 2365: sizeof(msg)); ! 2366: sendkeymsg((char *)&msg, sizeof(msg)); ! 2367: } ! 2368: break; ! 2369: ! 2370: case 67: ! 2371: ! 2372: /* Line 1455 of yacc.c */ ! 2373: #line 708 "parse.y" ! 2374: { ! 2375: struct sadb_msg msg; ! 2376: setkeymsg0(&msg, SADB_X_SPDFLUSH, SADB_SATYPE_UNSPEC, ! 2377: sizeof(msg)); ! 2378: sendkeymsg((char *)&msg, sizeof(msg)); ! 2379: } ! 2380: break; ! 2381: ! 2382: case 70: ! 2383: ! 2384: /* Line 1455 of yacc.c */ ! 2385: #line 723 "parse.y" ! 2386: { ! 2387: char *p; ! 2388: ! 2389: for (p = (yyvsp[(1) - (1)].val).buf + 1; *p; p++) ! 2390: switch (*p) { ! 2391: case '4': ! 2392: p_aifamily = AF_INET; ! 2393: break; ! 2394: #ifdef INET6 ! 2395: case '6': ! 2396: p_aifamily = AF_INET6; ! 2397: break; ! 2398: #endif ! 2399: case 'n': ! 2400: p_aiflags = AI_NUMERICHOST; ! 2401: break; ! 2402: default: ! 2403: yyerror("invalid flag"); ! 2404: return -1; ! 2405: } ! 2406: } ! 2407: break; ! 2408: ! 2409: case 71: ! 2410: ! 2411: /* Line 1455 of yacc.c */ ! 2412: #line 748 "parse.y" ! 2413: { ! 2414: (yyval.res) = parse_addr((yyvsp[(1) - (1)].val).buf, NULL); ! 2415: if ((yyval.res) == NULL) { ! 2416: /* yyerror already called by parse_addr */ ! 2417: return -1; ! 2418: } ! 2419: } ! 2420: break; ! 2421: ! 2422: case 72: ! 2423: ! 2424: /* Line 1455 of yacc.c */ ! 2425: #line 759 "parse.y" ! 2426: { ! 2427: (yyval.res) = parse_addr((yyvsp[(1) - (1)].val).buf, NULL); ! 2428: if ((yyval.res) == NULL) { ! 2429: /* yyerror already called by parse_addr */ ! 2430: return -1; ! 2431: } ! 2432: } ! 2433: break; ! 2434: ! 2435: case 73: ! 2436: ! 2437: /* Line 1455 of yacc.c */ ! 2438: #line 767 "parse.y" ! 2439: { ! 2440: (yyval.res) = parse_addr((yyvsp[(1) - (2)].val).buf, (yyvsp[(2) - (2)].val).buf); ! 2441: if ((yyval.res) == NULL) { ! 2442: /* yyerror already called by parse_addr */ ! 2443: return -1; ! 2444: } ! 2445: } ! 2446: break; ! 2447: ! 2448: case 74: ! 2449: ! 2450: /* Line 1455 of yacc.c */ ! 2451: #line 777 "parse.y" ! 2452: { (yyval.num) = -1; } ! 2453: break; ! 2454: ! 2455: case 75: ! 2456: ! 2457: /* Line 1455 of yacc.c */ ! 2458: #line 778 "parse.y" ! 2459: { (yyval.num) = (yyvsp[(2) - (2)].ulnum); } ! 2460: break; ! 2461: ! 2462: case 76: ! 2463: ! 2464: /* Line 1455 of yacc.c */ ! 2465: #line 783 "parse.y" ! 2466: { ! 2467: (yyval.val).buf = strdup("0"); ! 2468: if (!(yyval.val).buf) { ! 2469: yyerror("insufficient memory"); ! 2470: return -1; ! 2471: } ! 2472: (yyval.val).len = strlen((yyval.val).buf); ! 2473: } ! 2474: break; ! 2475: ! 2476: case 77: ! 2477: ! 2478: /* Line 1455 of yacc.c */ ! 2479: #line 792 "parse.y" ! 2480: { ! 2481: (yyval.val).buf = strdup("0"); ! 2482: if (!(yyval.val).buf) { ! 2483: yyerror("insufficient memory"); ! 2484: return -1; ! 2485: } ! 2486: (yyval.val).len = strlen((yyval.val).buf); ! 2487: } ! 2488: break; ! 2489: ! 2490: case 78: ! 2491: ! 2492: /* Line 1455 of yacc.c */ ! 2493: #line 801 "parse.y" ! 2494: { ! 2495: char buf[20]; ! 2496: snprintf(buf, sizeof(buf), "%lu", (yyvsp[(2) - (3)].ulnum)); ! 2497: (yyval.val).buf = strdup(buf); ! 2498: if (!(yyval.val).buf) { ! 2499: yyerror("insufficient memory"); ! 2500: return -1; ! 2501: } ! 2502: (yyval.val).len = strlen((yyval.val).buf); ! 2503: } ! 2504: break; ! 2505: ! 2506: case 79: ! 2507: ! 2508: /* Line 1455 of yacc.c */ ! 2509: #line 812 "parse.y" ! 2510: { ! 2511: (yyval.val) = (yyvsp[(2) - (3)].val); ! 2512: } ! 2513: break; ! 2514: ! 2515: case 80: ! 2516: ! 2517: /* Line 1455 of yacc.c */ ! 2518: #line 818 "parse.y" ! 2519: { (yyval.num) = (yyvsp[(1) - (1)].ulnum); } ! 2520: break; ! 2521: ! 2522: case 81: ! 2523: ! 2524: /* Line 1455 of yacc.c */ ! 2525: #line 819 "parse.y" ! 2526: { (yyval.num) = IPSEC_ULPROTO_ANY; } ! 2527: break; ! 2528: ! 2529: case 82: ! 2530: ! 2531: /* Line 1455 of yacc.c */ ! 2532: #line 820 "parse.y" ! 2533: { ! 2534: (yyval.num) = IPPROTO_TCP; ! 2535: } ! 2536: break; ! 2537: ! 2538: case 83: ! 2539: ! 2540: /* Line 1455 of yacc.c */ ! 2541: #line 824 "parse.y" ! 2542: { ! 2543: struct protoent *ent; ! 2544: ! 2545: ent = getprotobyname((yyvsp[(1) - (1)].val).buf); ! 2546: if (ent) ! 2547: (yyval.num) = ent->p_proto; ! 2548: else { ! 2549: if (strcmp("icmp6", (yyvsp[(1) - (1)].val).buf) == 0) { ! 2550: (yyval.num) = IPPROTO_ICMPV6; ! 2551: } else if(strcmp("ip4", (yyvsp[(1) - (1)].val).buf) == 0) { ! 2552: (yyval.num) = IPPROTO_IPV4; ! 2553: } else { ! 2554: yyerror("invalid upper layer protocol"); ! 2555: return -1; ! 2556: } ! 2557: } ! 2558: endprotoent(); ! 2559: } ! 2560: break; ! 2561: ! 2562: case 84: ! 2563: ! 2564: /* Line 1455 of yacc.c */ ! 2565: #line 846 "parse.y" ! 2566: { ! 2567: (yyval.val).buf = NULL; ! 2568: (yyval.val).len = 0; ! 2569: } ! 2570: break; ! 2571: ! 2572: case 85: ! 2573: ! 2574: /* Line 1455 of yacc.c */ ! 2575: #line 851 "parse.y" ! 2576: { ! 2577: (yyval.val).buf = strdup((yyvsp[(1) - (1)].val).buf); ! 2578: if (!(yyval.val).buf) { ! 2579: yyerror("insufficient memory"); ! 2580: return -1; ! 2581: } ! 2582: (yyval.val).len = strlen((yyval.val).buf); ! 2583: } ! 2584: break; ! 2585: ! 2586: case 87: ! 2587: ! 2588: /* Line 1455 of yacc.c */ ! 2589: #line 863 "parse.y" ! 2590: { ! 2591: sec_ctx.doi = (yyvsp[(2) - (4)].ulnum); ! 2592: sec_ctx.alg = (yyvsp[(3) - (4)].ulnum); ! 2593: sec_ctx.len = (yyvsp[(4) - (4)].val).len+1; ! 2594: sec_ctx.buf = (yyvsp[(4) - (4)].val).buf; ! 2595: } ! 2596: break; ! 2597: ! 2598: case 88: ! 2599: ! 2600: /* Line 1455 of yacc.c */ ! 2601: #line 873 "parse.y" ! 2602: { ! 2603: char *policy; ! 2604: #ifdef HAVE_PFKEY_POLICY_PRIORITY ! 2605: struct sadb_x_policy *xpl; ! 2606: #endif ! 2607: ! 2608: policy = ipsec_set_policy((yyvsp[(2) - (2)].val).buf, (yyvsp[(2) - (2)].val).len); ! 2609: if (policy == NULL) { ! 2610: yyerror(ipsec_strerror()); ! 2611: return -1; ! 2612: } ! 2613: ! 2614: (yyval.val).buf = policy; ! 2615: (yyval.val).len = ipsec_get_policylen(policy); ! 2616: ! 2617: #ifdef HAVE_PFKEY_POLICY_PRIORITY ! 2618: xpl = (struct sadb_x_policy *) (yyval.val).buf; ! 2619: last_priority = xpl->sadb_x_policy_priority; ! 2620: #endif ! 2621: } ! 2622: break; ! 2623: ! 2624: case 89: ! 2625: ! 2626: /* Line 1455 of yacc.c */ ! 2627: #line 896 "parse.y" ! 2628: { (yyval.val) = (yyvsp[(1) - (1)].val); } ! 2629: break; ! 2630: ! 2631: case 90: ! 2632: ! 2633: /* Line 1455 of yacc.c */ ! 2634: #line 902 "parse.y" ! 2635: { ! 2636: exit_now = 1; ! 2637: YYACCEPT; ! 2638: } ! 2639: break; ! 2640: ! 2641: ! 2642: ! 2643: /* Line 1455 of yacc.c */ ! 2644: #line 2645 "parse.c" ! 2645: default: break; ! 2646: } ! 2647: YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); ! 2648: ! 2649: YYPOPSTACK (yylen); ! 2650: yylen = 0; ! 2651: YY_STACK_PRINT (yyss, yyssp); ! 2652: ! 2653: *++yyvsp = yyval; ! 2654: ! 2655: /* Now `shift' the result of the reduction. Determine what state ! 2656: that goes to, based on the state we popped back to and the rule ! 2657: number reduced by. */ ! 2658: ! 2659: yyn = yyr1[yyn]; ! 2660: ! 2661: yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; ! 2662: if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) ! 2663: yystate = yytable[yystate]; ! 2664: else ! 2665: yystate = yydefgoto[yyn - YYNTOKENS]; ! 2666: ! 2667: goto yynewstate; ! 2668: ! 2669: ! 2670: /*------------------------------------. ! 2671: | yyerrlab -- here on detecting error | ! 2672: `------------------------------------*/ ! 2673: yyerrlab: ! 2674: /* If not already recovering from an error, report this error. */ ! 2675: if (!yyerrstatus) ! 2676: { ! 2677: ++yynerrs; ! 2678: #if ! YYERROR_VERBOSE ! 2679: yyerror (YY_("syntax error")); ! 2680: #else ! 2681: { ! 2682: YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); ! 2683: if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) ! 2684: { ! 2685: YYSIZE_T yyalloc = 2 * yysize; ! 2686: if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) ! 2687: yyalloc = YYSTACK_ALLOC_MAXIMUM; ! 2688: if (yymsg != yymsgbuf) ! 2689: YYSTACK_FREE (yymsg); ! 2690: yymsg = (char *) YYSTACK_ALLOC (yyalloc); ! 2691: if (yymsg) ! 2692: yymsg_alloc = yyalloc; ! 2693: else ! 2694: { ! 2695: yymsg = yymsgbuf; ! 2696: yymsg_alloc = sizeof yymsgbuf; ! 2697: } ! 2698: } ! 2699: ! 2700: if (0 < yysize && yysize <= yymsg_alloc) ! 2701: { ! 2702: (void) yysyntax_error (yymsg, yystate, yychar); ! 2703: yyerror (yymsg); ! 2704: } ! 2705: else ! 2706: { ! 2707: yyerror (YY_("syntax error")); ! 2708: if (yysize != 0) ! 2709: goto yyexhaustedlab; ! 2710: } ! 2711: } ! 2712: #endif ! 2713: } ! 2714: ! 2715: ! 2716: ! 2717: if (yyerrstatus == 3) ! 2718: { ! 2719: /* If just tried and failed to reuse lookahead token after an ! 2720: error, discard it. */ ! 2721: ! 2722: if (yychar <= YYEOF) ! 2723: { ! 2724: /* Return failure if at end of input. */ ! 2725: if (yychar == YYEOF) ! 2726: YYABORT; ! 2727: } ! 2728: else ! 2729: { ! 2730: yydestruct ("Error: discarding", ! 2731: yytoken, &yylval); ! 2732: yychar = YYEMPTY; ! 2733: } ! 2734: } ! 2735: ! 2736: /* Else will try to reuse lookahead token after shifting the error ! 2737: token. */ ! 2738: goto yyerrlab1; ! 2739: ! 2740: ! 2741: /*---------------------------------------------------. ! 2742: | yyerrorlab -- error raised explicitly by YYERROR. | ! 2743: `---------------------------------------------------*/ ! 2744: yyerrorlab: ! 2745: ! 2746: /* Pacify compilers like GCC when the user code never invokes ! 2747: YYERROR and the label yyerrorlab therefore never appears in user ! 2748: code. */ ! 2749: if (/*CONSTCOND*/ 0) ! 2750: goto yyerrorlab; ! 2751: ! 2752: /* Do not reclaim the symbols of the rule which action triggered ! 2753: this YYERROR. */ ! 2754: YYPOPSTACK (yylen); ! 2755: yylen = 0; ! 2756: YY_STACK_PRINT (yyss, yyssp); ! 2757: yystate = *yyssp; ! 2758: goto yyerrlab1; ! 2759: ! 2760: ! 2761: /*-------------------------------------------------------------. ! 2762: | yyerrlab1 -- common code for both syntax error and YYERROR. | ! 2763: `-------------------------------------------------------------*/ ! 2764: yyerrlab1: ! 2765: yyerrstatus = 3; /* Each real token shifted decrements this. */ ! 2766: ! 2767: for (;;) ! 2768: { ! 2769: yyn = yypact[yystate]; ! 2770: if (yyn != YYPACT_NINF) ! 2771: { ! 2772: yyn += YYTERROR; ! 2773: if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ! 2774: { ! 2775: yyn = yytable[yyn]; ! 2776: if (0 < yyn) ! 2777: break; ! 2778: } ! 2779: } ! 2780: ! 2781: /* Pop the current state because it cannot handle the error token. */ ! 2782: if (yyssp == yyss) ! 2783: YYABORT; ! 2784: ! 2785: ! 2786: yydestruct ("Error: popping", ! 2787: yystos[yystate], yyvsp); ! 2788: YYPOPSTACK (1); ! 2789: yystate = *yyssp; ! 2790: YY_STACK_PRINT (yyss, yyssp); ! 2791: } ! 2792: ! 2793: *++yyvsp = yylval; ! 2794: ! 2795: ! 2796: /* Shift the error token. */ ! 2797: YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); ! 2798: ! 2799: yystate = yyn; ! 2800: goto yynewstate; ! 2801: ! 2802: ! 2803: /*-------------------------------------. ! 2804: | yyacceptlab -- YYACCEPT comes here. | ! 2805: `-------------------------------------*/ ! 2806: yyacceptlab: ! 2807: yyresult = 0; ! 2808: goto yyreturn; ! 2809: ! 2810: /*-----------------------------------. ! 2811: | yyabortlab -- YYABORT comes here. | ! 2812: `-----------------------------------*/ ! 2813: yyabortlab: ! 2814: yyresult = 1; ! 2815: goto yyreturn; ! 2816: ! 2817: #if !defined(yyoverflow) || YYERROR_VERBOSE ! 2818: /*-------------------------------------------------. ! 2819: | yyexhaustedlab -- memory exhaustion comes here. | ! 2820: `-------------------------------------------------*/ ! 2821: yyexhaustedlab: ! 2822: yyerror (YY_("memory exhausted")); ! 2823: yyresult = 2; ! 2824: /* Fall through. */ ! 2825: #endif ! 2826: ! 2827: yyreturn: ! 2828: if (yychar != YYEMPTY) ! 2829: yydestruct ("Cleanup: discarding lookahead", ! 2830: yytoken, &yylval); ! 2831: /* Do not reclaim the symbols of the rule which action triggered ! 2832: this YYABORT or YYACCEPT. */ ! 2833: YYPOPSTACK (yylen); ! 2834: YY_STACK_PRINT (yyss, yyssp); ! 2835: while (yyssp != yyss) ! 2836: { ! 2837: yydestruct ("Cleanup: popping", ! 2838: yystos[*yyssp], yyvsp); ! 2839: YYPOPSTACK (1); ! 2840: } ! 2841: #ifndef yyoverflow ! 2842: if (yyss != yyssa) ! 2843: YYSTACK_FREE (yyss); ! 2844: #endif ! 2845: #if YYERROR_VERBOSE ! 2846: if (yymsg != yymsgbuf) ! 2847: YYSTACK_FREE (yymsg); ! 2848: #endif ! 2849: /* Make sure YYID is used. */ ! 2850: return YYID (yyresult); ! 2851: } ! 2852: ! 2853: ! 2854: ! 2855: /* Line 1675 of yacc.c */ ! 2856: #line 907 "parse.y" ! 2857: ! 2858: ! 2859: int ! 2860: setkeymsg0(msg, type, satype, l) ! 2861: struct sadb_msg *msg; ! 2862: unsigned int type; ! 2863: unsigned int satype; ! 2864: size_t l; ! 2865: { ! 2866: ! 2867: msg->sadb_msg_version = PF_KEY_V2; ! 2868: msg->sadb_msg_type = type; ! 2869: msg->sadb_msg_errno = 0; ! 2870: msg->sadb_msg_satype = satype; ! 2871: msg->sadb_msg_reserved = 0; ! 2872: msg->sadb_msg_seq = 0; ! 2873: msg->sadb_msg_pid = getpid(); ! 2874: msg->sadb_msg_len = PFKEY_UNIT64(l); ! 2875: return 0; ! 2876: } ! 2877: ! 2878: /* XXX NO BUFFER OVERRUN CHECK! BAD BAD! */ ! 2879: static int ! 2880: setkeymsg_spdaddr(type, upper, policy, srcs, splen, dsts, dplen) ! 2881: unsigned int type; ! 2882: unsigned int upper; ! 2883: vchar_t *policy; ! 2884: struct addrinfo *srcs; ! 2885: int splen; ! 2886: struct addrinfo *dsts; ! 2887: int dplen; ! 2888: { ! 2889: struct sadb_msg *msg; ! 2890: char buf[BUFSIZ]; ! 2891: int l, l0; ! 2892: struct sadb_address m_addr; ! 2893: struct addrinfo *s, *d; ! 2894: int n; ! 2895: int plen; ! 2896: struct sockaddr *sa; ! 2897: int salen; ! 2898: struct sadb_x_policy *sp; ! 2899: #ifdef HAVE_POLICY_FWD ! 2900: struct sadb_x_ipsecrequest *ps = NULL; ! 2901: int saved_level, saved_id = 0; ! 2902: #endif ! 2903: ! 2904: msg = (struct sadb_msg *)buf; ! 2905: ! 2906: if (!srcs || !dsts) ! 2907: return -1; ! 2908: ! 2909: /* fix up length afterwards */ ! 2910: setkeymsg0(msg, type, SADB_SATYPE_UNSPEC, 0); ! 2911: l = sizeof(struct sadb_msg); ! 2912: ! 2913: sp = (struct sadb_x_policy*) (buf + l); ! 2914: memcpy(buf + l, policy->buf, policy->len); ! 2915: l += policy->len; ! 2916: ! 2917: l0 = l; ! 2918: n = 0; ! 2919: ! 2920: /* do it for all src/dst pairs */ ! 2921: for (s = srcs; s; s = s->ai_next) { ! 2922: for (d = dsts; d; d = d->ai_next) { ! 2923: /* rewind pointer */ ! 2924: l = l0; ! 2925: ! 2926: if (s->ai_addr->sa_family != d->ai_addr->sa_family) ! 2927: continue; ! 2928: switch (s->ai_addr->sa_family) { ! 2929: case AF_INET: ! 2930: plen = sizeof(struct in_addr) << 3; ! 2931: break; ! 2932: #ifdef INET6 ! 2933: case AF_INET6: ! 2934: plen = sizeof(struct in6_addr) << 3; ! 2935: break; ! 2936: #endif ! 2937: default: ! 2938: continue; ! 2939: } ! 2940: ! 2941: /* set src */ ! 2942: sa = s->ai_addr; ! 2943: salen = sysdep_sa_len(s->ai_addr); ! 2944: m_addr.sadb_address_len = PFKEY_UNIT64(sizeof(m_addr) + ! 2945: PFKEY_ALIGN8(salen)); ! 2946: m_addr.sadb_address_exttype = SADB_EXT_ADDRESS_SRC; ! 2947: m_addr.sadb_address_proto = upper; ! 2948: m_addr.sadb_address_prefixlen = ! 2949: (splen >= 0 ? splen : plen); ! 2950: m_addr.sadb_address_reserved = 0; ! 2951: ! 2952: setvarbuf(buf, &l, (struct sadb_ext *)&m_addr, ! 2953: sizeof(m_addr), (caddr_t)sa, salen); ! 2954: ! 2955: /* set dst */ ! 2956: sa = d->ai_addr; ! 2957: salen = sysdep_sa_len(d->ai_addr); ! 2958: m_addr.sadb_address_len = PFKEY_UNIT64(sizeof(m_addr) + ! 2959: PFKEY_ALIGN8(salen)); ! 2960: m_addr.sadb_address_exttype = SADB_EXT_ADDRESS_DST; ! 2961: m_addr.sadb_address_proto = upper; ! 2962: m_addr.sadb_address_prefixlen = ! 2963: (dplen >= 0 ? dplen : plen); ! 2964: m_addr.sadb_address_reserved = 0; ! 2965: ! 2966: setvarbuf(buf, &l, (struct sadb_ext *)&m_addr, ! 2967: sizeof(m_addr), sa, salen); ! 2968: #ifdef SADB_X_EXT_SEC_CTX ! 2969: /* Add security context label */ ! 2970: if (sec_ctx.doi) { ! 2971: struct sadb_x_sec_ctx m_sec_ctx; ! 2972: u_int slen = sizeof(struct sadb_x_sec_ctx); ! 2973: ! 2974: memset(&m_sec_ctx, 0, slen); ! 2975: ! 2976: m_sec_ctx.sadb_x_sec_len = ! 2977: PFKEY_UNIT64(slen + PFKEY_ALIGN8(sec_ctx.len)); ! 2978: ! 2979: m_sec_ctx.sadb_x_sec_exttype = ! 2980: SADB_X_EXT_SEC_CTX; ! 2981: m_sec_ctx.sadb_x_ctx_len = sec_ctx.len;/*bytes*/ ! 2982: m_sec_ctx.sadb_x_ctx_doi = sec_ctx.doi; ! 2983: m_sec_ctx.sadb_x_ctx_alg = sec_ctx.alg; ! 2984: setvarbuf(buf, &l, ! 2985: (struct sadb_ext *)&m_sec_ctx, slen, ! 2986: (caddr_t)sec_ctx.buf, sec_ctx.len); ! 2987: } ! 2988: #endif ! 2989: msg->sadb_msg_len = PFKEY_UNIT64(l); ! 2990: ! 2991: sendkeymsg(buf, l); ! 2992: ! 2993: #ifdef HAVE_POLICY_FWD ! 2994: /* create extra call for FWD policy */ ! 2995: if (f_rfcmode && sp->sadb_x_policy_dir == IPSEC_DIR_INBOUND) { ! 2996: sp->sadb_x_policy_dir = IPSEC_DIR_FWD; ! 2997: ps = (struct sadb_x_ipsecrequest*) (sp+1); ! 2998: ! 2999: /* if request level is unique, change it to ! 3000: * require for fwd policy */ ! 3001: /* XXX: currently, only first policy is updated ! 3002: * only. Update following too... */ ! 3003: saved_level = ps->sadb_x_ipsecrequest_level; ! 3004: if (saved_level == IPSEC_LEVEL_UNIQUE) { ! 3005: saved_id = ps->sadb_x_ipsecrequest_reqid; ! 3006: ps->sadb_x_ipsecrequest_reqid=0; ! 3007: ps->sadb_x_ipsecrequest_level=IPSEC_LEVEL_REQUIRE; ! 3008: } ! 3009: ! 3010: sendkeymsg(buf, l); ! 3011: /* restoring for next message */ ! 3012: sp->sadb_x_policy_dir = IPSEC_DIR_INBOUND; ! 3013: if (saved_level == IPSEC_LEVEL_UNIQUE) { ! 3014: ps->sadb_x_ipsecrequest_reqid = saved_id; ! 3015: ps->sadb_x_ipsecrequest_level = saved_level; ! 3016: } ! 3017: } ! 3018: #endif ! 3019: ! 3020: n++; ! 3021: } ! 3022: } ! 3023: ! 3024: if (n == 0) ! 3025: return -1; ! 3026: else ! 3027: return 0; ! 3028: } ! 3029: ! 3030: static int ! 3031: setkeymsg_spdaddr_tag(type, tag, policy) ! 3032: unsigned int type; ! 3033: char *tag; ! 3034: vchar_t *policy; ! 3035: { ! 3036: struct sadb_msg *msg; ! 3037: char buf[BUFSIZ]; ! 3038: int l, l0; ! 3039: #ifdef SADB_X_EXT_TAG ! 3040: struct sadb_x_tag m_tag; ! 3041: #endif ! 3042: int n; ! 3043: ! 3044: msg = (struct sadb_msg *)buf; ! 3045: ! 3046: /* fix up length afterwards */ ! 3047: setkeymsg0(msg, type, SADB_SATYPE_UNSPEC, 0); ! 3048: l = sizeof(struct sadb_msg); ! 3049: ! 3050: memcpy(buf + l, policy->buf, policy->len); ! 3051: l += policy->len; ! 3052: ! 3053: l0 = l; ! 3054: n = 0; ! 3055: ! 3056: #ifdef SADB_X_EXT_TAG ! 3057: memset(&m_tag, 0, sizeof(m_tag)); ! 3058: m_tag.sadb_x_tag_len = PFKEY_UNIT64(sizeof(m_tag)); ! 3059: m_tag.sadb_x_tag_exttype = SADB_X_EXT_TAG; ! 3060: if (strlcpy(m_tag.sadb_x_tag_name, tag, ! 3061: sizeof(m_tag.sadb_x_tag_name)) >= sizeof(m_tag.sadb_x_tag_name)) ! 3062: return -1; ! 3063: memcpy(buf + l, &m_tag, sizeof(m_tag)); ! 3064: l += sizeof(m_tag); ! 3065: #endif ! 3066: ! 3067: msg->sadb_msg_len = PFKEY_UNIT64(l); ! 3068: ! 3069: sendkeymsg(buf, l); ! 3070: ! 3071: return 0; ! 3072: } ! 3073: ! 3074: /* XXX NO BUFFER OVERRUN CHECK! BAD BAD! */ ! 3075: static int ! 3076: setkeymsg_addr(type, satype, srcs, dsts, no_spi) ! 3077: unsigned int type; ! 3078: unsigned int satype; ! 3079: struct addrinfo *srcs; ! 3080: struct addrinfo *dsts; ! 3081: int no_spi; ! 3082: { ! 3083: struct sadb_msg *msg; ! 3084: char buf[BUFSIZ]; ! 3085: int l, l0, len; ! 3086: struct sadb_sa m_sa; ! 3087: struct sadb_x_sa2 m_sa2; ! 3088: struct sadb_address m_addr; ! 3089: struct addrinfo *s, *d; ! 3090: int n; ! 3091: int plen; ! 3092: struct sockaddr *sa; ! 3093: int salen; ! 3094: ! 3095: msg = (struct sadb_msg *)buf; ! 3096: ! 3097: if (!srcs || !dsts) ! 3098: return -1; ! 3099: ! 3100: /* fix up length afterwards */ ! 3101: setkeymsg0(msg, type, satype, 0); ! 3102: l = sizeof(struct sadb_msg); ! 3103: ! 3104: if (!no_spi) { ! 3105: len = sizeof(struct sadb_sa); ! 3106: m_sa.sadb_sa_len = PFKEY_UNIT64(len); ! 3107: m_sa.sadb_sa_exttype = SADB_EXT_SA; ! 3108: m_sa.sadb_sa_spi = htonl(p_spi); ! 3109: m_sa.sadb_sa_replay = p_replay; ! 3110: m_sa.sadb_sa_state = 0; ! 3111: m_sa.sadb_sa_auth = p_alg_auth; ! 3112: m_sa.sadb_sa_encrypt = p_alg_enc; ! 3113: m_sa.sadb_sa_flags = p_ext; ! 3114: ! 3115: memcpy(buf + l, &m_sa, len); ! 3116: l += len; ! 3117: ! 3118: len = sizeof(struct sadb_x_sa2); ! 3119: m_sa2.sadb_x_sa2_len = PFKEY_UNIT64(len); ! 3120: m_sa2.sadb_x_sa2_exttype = SADB_X_EXT_SA2; ! 3121: m_sa2.sadb_x_sa2_mode = p_mode; ! 3122: m_sa2.sadb_x_sa2_reqid = p_reqid; ! 3123: ! 3124: memcpy(buf + l, &m_sa2, len); ! 3125: l += len; ! 3126: } ! 3127: ! 3128: l0 = l; ! 3129: n = 0; ! 3130: ! 3131: /* do it for all src/dst pairs */ ! 3132: for (s = srcs; s; s = s->ai_next) { ! 3133: for (d = dsts; d; d = d->ai_next) { ! 3134: /* rewind pointer */ ! 3135: l = l0; ! 3136: ! 3137: if (s->ai_addr->sa_family != d->ai_addr->sa_family) ! 3138: continue; ! 3139: switch (s->ai_addr->sa_family) { ! 3140: case AF_INET: ! 3141: plen = sizeof(struct in_addr) << 3; ! 3142: break; ! 3143: #ifdef INET6 ! 3144: case AF_INET6: ! 3145: plen = sizeof(struct in6_addr) << 3; ! 3146: break; ! 3147: #endif ! 3148: default: ! 3149: continue; ! 3150: } ! 3151: ! 3152: /* set src */ ! 3153: sa = s->ai_addr; ! 3154: salen = sysdep_sa_len(s->ai_addr); ! 3155: m_addr.sadb_address_len = PFKEY_UNIT64(sizeof(m_addr) + ! 3156: PFKEY_ALIGN8(salen)); ! 3157: m_addr.sadb_address_exttype = SADB_EXT_ADDRESS_SRC; ! 3158: m_addr.sadb_address_proto = IPSEC_ULPROTO_ANY; ! 3159: m_addr.sadb_address_prefixlen = plen; ! 3160: m_addr.sadb_address_reserved = 0; ! 3161: ! 3162: setvarbuf(buf, &l, (struct sadb_ext *)&m_addr, ! 3163: sizeof(m_addr), sa, salen); ! 3164: ! 3165: /* set dst */ ! 3166: sa = d->ai_addr; ! 3167: salen = sysdep_sa_len(d->ai_addr); ! 3168: m_addr.sadb_address_len = PFKEY_UNIT64(sizeof(m_addr) + ! 3169: PFKEY_ALIGN8(salen)); ! 3170: m_addr.sadb_address_exttype = SADB_EXT_ADDRESS_DST; ! 3171: m_addr.sadb_address_proto = IPSEC_ULPROTO_ANY; ! 3172: m_addr.sadb_address_prefixlen = plen; ! 3173: m_addr.sadb_address_reserved = 0; ! 3174: ! 3175: setvarbuf(buf, &l, (struct sadb_ext *)&m_addr, ! 3176: sizeof(m_addr), sa, salen); ! 3177: ! 3178: msg->sadb_msg_len = PFKEY_UNIT64(l); ! 3179: ! 3180: sendkeymsg(buf, l); ! 3181: ! 3182: n++; ! 3183: } ! 3184: } ! 3185: ! 3186: if (n == 0) ! 3187: return -1; ! 3188: else ! 3189: return 0; ! 3190: } ! 3191: ! 3192: #ifdef SADB_X_EXT_NAT_T_TYPE ! 3193: static u_int16_t get_port (struct addrinfo *addr) ! 3194: { ! 3195: struct sockaddr *s = addr->ai_addr; ! 3196: u_int16_t port = 0; ! 3197: ! 3198: switch (s->sa_family) { ! 3199: case AF_INET: ! 3200: { ! 3201: struct sockaddr_in *sin4 = (struct sockaddr_in *)s; ! 3202: port = ntohs(sin4->sin_port); ! 3203: break; ! 3204: } ! 3205: case AF_INET6: ! 3206: { ! 3207: struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)s; ! 3208: port = ntohs(sin6->sin6_port); ! 3209: break; ! 3210: } ! 3211: } ! 3212: ! 3213: if (port == 0) ! 3214: port = DEFAULT_NATT_PORT; ! 3215: ! 3216: return port; ! 3217: } ! 3218: #endif ! 3219: ! 3220: /* XXX NO BUFFER OVERRUN CHECK! BAD BAD! */ ! 3221: static int ! 3222: setkeymsg_add(type, satype, srcs, dsts) ! 3223: unsigned int type; ! 3224: unsigned int satype; ! 3225: struct addrinfo *srcs; ! 3226: struct addrinfo *dsts; ! 3227: { ! 3228: struct sadb_msg *msg; ! 3229: char buf[BUFSIZ]; ! 3230: int l, l0, len; ! 3231: struct sadb_sa m_sa; ! 3232: struct sadb_x_sa2 m_sa2; ! 3233: struct sadb_address m_addr; ! 3234: struct addrinfo *s, *d; ! 3235: int n; ! 3236: int plen; ! 3237: struct sockaddr *sa; ! 3238: int salen; ! 3239: ! 3240: msg = (struct sadb_msg *)buf; ! 3241: ! 3242: if (!srcs || !dsts) ! 3243: return -1; ! 3244: ! 3245: /* fix up length afterwards */ ! 3246: setkeymsg0(msg, type, satype, 0); ! 3247: l = sizeof(struct sadb_msg); ! 3248: ! 3249: /* set encryption algorithm, if present. */ ! 3250: if (satype != SADB_X_SATYPE_IPCOMP && p_key_enc) { ! 3251: union { ! 3252: struct sadb_key key; ! 3253: struct sadb_ext ext; ! 3254: } m; ! 3255: ! 3256: m.key.sadb_key_len = ! 3257: PFKEY_UNIT64(sizeof(m.key) ! 3258: + PFKEY_ALIGN8(p_key_enc_len)); ! 3259: m.key.sadb_key_exttype = SADB_EXT_KEY_ENCRYPT; ! 3260: m.key.sadb_key_bits = p_key_enc_len * 8; ! 3261: m.key.sadb_key_reserved = 0; ! 3262: ! 3263: setvarbuf(buf, &l, &m.ext, sizeof(m.key), ! 3264: p_key_enc, p_key_enc_len); ! 3265: } ! 3266: ! 3267: /* set authentication algorithm, if present. */ ! 3268: if (p_key_auth) { ! 3269: union { ! 3270: struct sadb_key key; ! 3271: struct sadb_ext ext; ! 3272: } m; ! 3273: ! 3274: m.key.sadb_key_len = ! 3275: PFKEY_UNIT64(sizeof(m.key) ! 3276: + PFKEY_ALIGN8(p_key_auth_len)); ! 3277: m.key.sadb_key_exttype = SADB_EXT_KEY_AUTH; ! 3278: m.key.sadb_key_bits = p_key_auth_len * 8; ! 3279: m.key.sadb_key_reserved = 0; ! 3280: ! 3281: setvarbuf(buf, &l, &m.ext, sizeof(m.key), ! 3282: p_key_auth, p_key_auth_len); ! 3283: } ! 3284: ! 3285: /* set lifetime for HARD */ ! 3286: if (p_lt_hard != 0 || p_lb_hard != 0) { ! 3287: struct sadb_lifetime m_lt; ! 3288: u_int slen = sizeof(struct sadb_lifetime); ! 3289: ! 3290: m_lt.sadb_lifetime_len = PFKEY_UNIT64(slen); ! 3291: m_lt.sadb_lifetime_exttype = SADB_EXT_LIFETIME_HARD; ! 3292: m_lt.sadb_lifetime_allocations = 0; ! 3293: m_lt.sadb_lifetime_bytes = p_lb_hard; ! 3294: m_lt.sadb_lifetime_addtime = p_lt_hard; ! 3295: m_lt.sadb_lifetime_usetime = 0; ! 3296: ! 3297: memcpy(buf + l, &m_lt, slen); ! 3298: l += slen; ! 3299: } ! 3300: ! 3301: /* set lifetime for SOFT */ ! 3302: if (p_lt_soft != 0 || p_lb_soft != 0) { ! 3303: struct sadb_lifetime m_lt; ! 3304: u_int slen = sizeof(struct sadb_lifetime); ! 3305: ! 3306: m_lt.sadb_lifetime_len = PFKEY_UNIT64(slen); ! 3307: m_lt.sadb_lifetime_exttype = SADB_EXT_LIFETIME_SOFT; ! 3308: m_lt.sadb_lifetime_allocations = 0; ! 3309: m_lt.sadb_lifetime_bytes = p_lb_soft; ! 3310: m_lt.sadb_lifetime_addtime = p_lt_soft; ! 3311: m_lt.sadb_lifetime_usetime = 0; ! 3312: ! 3313: memcpy(buf + l, &m_lt, slen); ! 3314: l += slen; ! 3315: } ! 3316: ! 3317: #ifdef SADB_X_EXT_SEC_CTX ! 3318: /* Add security context label */ ! 3319: if (sec_ctx.doi) { ! 3320: struct sadb_x_sec_ctx m_sec_ctx; ! 3321: u_int slen = sizeof(struct sadb_x_sec_ctx); ! 3322: ! 3323: memset(&m_sec_ctx, 0, slen); ! 3324: ! 3325: m_sec_ctx.sadb_x_sec_len = PFKEY_UNIT64(slen + ! 3326: PFKEY_ALIGN8(sec_ctx.len)); ! 3327: m_sec_ctx.sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX; ! 3328: m_sec_ctx.sadb_x_ctx_len = sec_ctx.len; /* bytes */ ! 3329: m_sec_ctx.sadb_x_ctx_doi = sec_ctx.doi; ! 3330: m_sec_ctx.sadb_x_ctx_alg = sec_ctx.alg; ! 3331: setvarbuf(buf, &l, (struct sadb_ext *)&m_sec_ctx, slen, ! 3332: (caddr_t)sec_ctx.buf, sec_ctx.len); ! 3333: } ! 3334: #endif ! 3335: ! 3336: len = sizeof(struct sadb_sa); ! 3337: m_sa.sadb_sa_len = PFKEY_UNIT64(len); ! 3338: m_sa.sadb_sa_exttype = SADB_EXT_SA; ! 3339: m_sa.sadb_sa_spi = htonl(p_spi); ! 3340: m_sa.sadb_sa_replay = p_replay; ! 3341: m_sa.sadb_sa_state = 0; ! 3342: m_sa.sadb_sa_auth = p_alg_auth; ! 3343: m_sa.sadb_sa_encrypt = p_alg_enc; ! 3344: m_sa.sadb_sa_flags = p_ext; ! 3345: ! 3346: memcpy(buf + l, &m_sa, len); ! 3347: l += len; ! 3348: ! 3349: len = sizeof(struct sadb_x_sa2); ! 3350: m_sa2.sadb_x_sa2_len = PFKEY_UNIT64(len); ! 3351: m_sa2.sadb_x_sa2_exttype = SADB_X_EXT_SA2; ! 3352: m_sa2.sadb_x_sa2_mode = p_mode; ! 3353: m_sa2.sadb_x_sa2_reqid = p_reqid; ! 3354: ! 3355: memcpy(buf + l, &m_sa2, len); ! 3356: l += len; ! 3357: ! 3358: #ifdef SADB_X_EXT_NAT_T_TYPE ! 3359: if (p_natt_type) { ! 3360: struct sadb_x_nat_t_type natt_type; ! 3361: ! 3362: len = sizeof(struct sadb_x_nat_t_type); ! 3363: memset(&natt_type, 0, len); ! 3364: natt_type.sadb_x_nat_t_type_len = PFKEY_UNIT64(len); ! 3365: natt_type.sadb_x_nat_t_type_exttype = SADB_X_EXT_NAT_T_TYPE; ! 3366: natt_type.sadb_x_nat_t_type_type = p_natt_type; ! 3367: ! 3368: memcpy(buf + l, &natt_type, len); ! 3369: l += len; ! 3370: ! 3371: if (p_natt_oa) { ! 3372: sa = p_natt_oa->ai_addr; ! 3373: switch (sa->sa_family) { ! 3374: case AF_INET: ! 3375: plen = sizeof(struct in_addr) << 3; ! 3376: break; ! 3377: #ifdef INET6 ! 3378: case AF_INET6: ! 3379: plen = sizeof(struct in6_addr) << 3; ! 3380: break; ! 3381: #endif ! 3382: default: ! 3383: return -1; ! 3384: } ! 3385: salen = sysdep_sa_len(sa); ! 3386: m_addr.sadb_address_len = PFKEY_UNIT64(sizeof(m_addr) + ! 3387: PFKEY_ALIGN8(salen)); ! 3388: m_addr.sadb_address_exttype = SADB_X_EXT_NAT_T_OA; ! 3389: m_addr.sadb_address_proto = IPSEC_ULPROTO_ANY; ! 3390: m_addr.sadb_address_prefixlen = plen; ! 3391: m_addr.sadb_address_reserved = 0; ! 3392: ! 3393: setvarbuf(buf, &l, (struct sadb_ext *)&m_addr, ! 3394: sizeof(m_addr), sa, salen); ! 3395: } ! 3396: } ! 3397: #endif ! 3398: ! 3399: l0 = l; ! 3400: n = 0; ! 3401: ! 3402: /* do it for all src/dst pairs */ ! 3403: for (s = srcs; s; s = s->ai_next) { ! 3404: for (d = dsts; d; d = d->ai_next) { ! 3405: /* rewind pointer */ ! 3406: l = l0; ! 3407: ! 3408: if (s->ai_addr->sa_family != d->ai_addr->sa_family) ! 3409: continue; ! 3410: switch (s->ai_addr->sa_family) { ! 3411: case AF_INET: ! 3412: plen = sizeof(struct in_addr) << 3; ! 3413: break; ! 3414: #ifdef INET6 ! 3415: case AF_INET6: ! 3416: plen = sizeof(struct in6_addr) << 3; ! 3417: break; ! 3418: #endif ! 3419: default: ! 3420: continue; ! 3421: } ! 3422: ! 3423: /* set src */ ! 3424: sa = s->ai_addr; ! 3425: salen = sysdep_sa_len(s->ai_addr); ! 3426: m_addr.sadb_address_len = PFKEY_UNIT64(sizeof(m_addr) + ! 3427: PFKEY_ALIGN8(salen)); ! 3428: m_addr.sadb_address_exttype = SADB_EXT_ADDRESS_SRC; ! 3429: m_addr.sadb_address_proto = IPSEC_ULPROTO_ANY; ! 3430: m_addr.sadb_address_prefixlen = plen; ! 3431: m_addr.sadb_address_reserved = 0; ! 3432: ! 3433: setvarbuf(buf, &l, (struct sadb_ext *)&m_addr, ! 3434: sizeof(m_addr), sa, salen); ! 3435: ! 3436: /* set dst */ ! 3437: sa = d->ai_addr; ! 3438: salen = sysdep_sa_len(d->ai_addr); ! 3439: m_addr.sadb_address_len = PFKEY_UNIT64(sizeof(m_addr) + ! 3440: PFKEY_ALIGN8(salen)); ! 3441: m_addr.sadb_address_exttype = SADB_EXT_ADDRESS_DST; ! 3442: m_addr.sadb_address_proto = IPSEC_ULPROTO_ANY; ! 3443: m_addr.sadb_address_prefixlen = plen; ! 3444: m_addr.sadb_address_reserved = 0; ! 3445: ! 3446: setvarbuf(buf, &l, (struct sadb_ext *)&m_addr, ! 3447: sizeof(m_addr), sa, salen); ! 3448: ! 3449: #ifdef SADB_X_EXT_NAT_T_TYPE ! 3450: if (p_natt_type) { ! 3451: struct sadb_x_nat_t_port natt_port; ! 3452: ! 3453: /* NATT_SPORT */ ! 3454: len = sizeof(struct sadb_x_nat_t_port); ! 3455: memset(&natt_port, 0, len); ! 3456: natt_port.sadb_x_nat_t_port_len = PFKEY_UNIT64(len); ! 3457: natt_port.sadb_x_nat_t_port_exttype = ! 3458: SADB_X_EXT_NAT_T_SPORT; ! 3459: natt_port.sadb_x_nat_t_port_port = htons(get_port(s)); ! 3460: ! 3461: memcpy(buf + l, &natt_port, len); ! 3462: l += len; ! 3463: ! 3464: /* NATT_DPORT */ ! 3465: natt_port.sadb_x_nat_t_port_exttype = ! 3466: SADB_X_EXT_NAT_T_DPORT; ! 3467: natt_port.sadb_x_nat_t_port_port = htons(get_port(d)); ! 3468: ! 3469: memcpy(buf + l, &natt_port, len); ! 3470: l += len; ! 3471: } ! 3472: #endif ! 3473: msg->sadb_msg_len = PFKEY_UNIT64(l); ! 3474: ! 3475: sendkeymsg(buf, l); ! 3476: ! 3477: n++; ! 3478: } ! 3479: } ! 3480: ! 3481: if (n == 0) ! 3482: return -1; ! 3483: else ! 3484: return 0; ! 3485: } ! 3486: ! 3487: static struct addrinfo * ! 3488: parse_addr(host, port) ! 3489: char *host; ! 3490: char *port; ! 3491: { ! 3492: struct addrinfo hints, *res = NULL; ! 3493: int error; ! 3494: ! 3495: memset(&hints, 0, sizeof(hints)); ! 3496: hints.ai_family = p_aifamily; ! 3497: hints.ai_socktype = SOCK_DGRAM; /*dummy*/ ! 3498: hints.ai_protocol = IPPROTO_UDP; /*dummy*/ ! 3499: hints.ai_flags = p_aiflags; ! 3500: error = getaddrinfo(host, port, &hints, &res); ! 3501: if (error != 0) { ! 3502: yyerror(gai_strerror(error)); ! 3503: return NULL; ! 3504: } ! 3505: return res; ! 3506: } ! 3507: ! 3508: static int ! 3509: fix_portstr(ulproto, spec, sport, dport) ! 3510: int ulproto; ! 3511: vchar_t *spec, *sport, *dport; ! 3512: { ! 3513: char sp[16], dp[16]; ! 3514: int a, b, c, d; ! 3515: unsigned long u; ! 3516: ! 3517: if (spec->buf == NULL) ! 3518: return 0; ! 3519: ! 3520: switch (ulproto) { ! 3521: case IPPROTO_ICMP: ! 3522: case IPPROTO_ICMPV6: ! 3523: case IPPROTO_MH: ! 3524: if (sscanf(spec->buf, "%d,%d", &a, &b) == 2) { ! 3525: sprintf(sp, "%d", a); ! 3526: sprintf(dp, "%d", b); ! 3527: } else if (sscanf(spec->buf, "%d", &a) == 1) { ! 3528: sprintf(sp, "%d", a); ! 3529: } else { ! 3530: yyerror("invalid an upper layer protocol spec"); ! 3531: return -1; ! 3532: } ! 3533: break; ! 3534: case IPPROTO_GRE: ! 3535: if (sscanf(spec->buf, "%d.%d.%d.%d", &a, &b, &c, &d) == 4) { ! 3536: sprintf(sp, "%d", (a << 8) + b); ! 3537: sprintf(dp, "%d", (c << 8) + d); ! 3538: } else if (sscanf(spec->buf, "%lu", &u) == 1) { ! 3539: sprintf(sp, "%d", (int) (u >> 16)); ! 3540: sprintf(dp, "%d", (int) (u & 0xffff)); ! 3541: } else { ! 3542: yyerror("invalid an upper layer protocol spec"); ! 3543: return -1; ! 3544: } ! 3545: break; ! 3546: } ! 3547: ! 3548: free(sport->buf); ! 3549: sport->buf = strdup(sp); ! 3550: if (!sport->buf) { ! 3551: yyerror("insufficient memory"); ! 3552: return -1; ! 3553: } ! 3554: sport->len = strlen(sport->buf); ! 3555: ! 3556: free(dport->buf); ! 3557: dport->buf = strdup(dp); ! 3558: if (!dport->buf) { ! 3559: yyerror("insufficient memory"); ! 3560: return -1; ! 3561: } ! 3562: dport->len = strlen(dport->buf); ! 3563: ! 3564: return 0; ! 3565: } ! 3566: ! 3567: static int ! 3568: setvarbuf(buf, off, ebuf, elen, vbuf, vlen) ! 3569: char *buf; ! 3570: int *off; ! 3571: struct sadb_ext *ebuf; ! 3572: int elen; ! 3573: const void *vbuf; ! 3574: int vlen; ! 3575: { ! 3576: memset(buf + *off, 0, PFKEY_UNUNIT64(ebuf->sadb_ext_len)); ! 3577: memcpy(buf + *off, (caddr_t)ebuf, elen); ! 3578: memcpy(buf + *off + elen, vbuf, vlen); ! 3579: (*off) += PFKEY_ALIGN8(elen + vlen); ! 3580: ! 3581: return 0; ! 3582: } ! 3583: ! 3584: void ! 3585: parse_init() ! 3586: { ! 3587: p_spi = 0; ! 3588: ! 3589: p_ext = SADB_X_EXT_CYCSEQ; ! 3590: p_alg_enc = SADB_EALG_NONE; ! 3591: p_alg_auth = SADB_AALG_NONE; ! 3592: p_mode = IPSEC_MODE_ANY; ! 3593: p_reqid = 0; ! 3594: p_replay = 0; ! 3595: p_key_enc_len = p_key_auth_len = 0; ! 3596: p_key_enc = p_key_auth = 0; ! 3597: p_lt_hard = p_lt_soft = 0; ! 3598: p_lb_hard = p_lb_soft = 0; ! 3599: ! 3600: memset(&sec_ctx, 0, sizeof(struct security_ctx)); ! 3601: ! 3602: p_aiflags = 0; ! 3603: p_aifamily = PF_UNSPEC; ! 3604: ! 3605: /* Clear out any natt OA information */ ! 3606: if (p_natt_oa) ! 3607: freeaddrinfo (p_natt_oa); ! 3608: p_natt_oa = NULL; ! 3609: p_natt_type = 0; ! 3610: ! 3611: return; ! 3612: } ! 3613: ! 3614: void ! 3615: free_buffer() ! 3616: { ! 3617: /* we got tons of memory leaks in the parser anyways, leave them */ ! 3618: ! 3619: return; ! 3620: } ! 3621: