![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parse.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ipsec-tools / src / setkey|
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: