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