source: rtems-libbsd/ipsec-tools/src/racoon/prsa_par.c @ ff36f5e

5-freebsd-12
Last change on this file since ff36f5e was ff36f5e, checked in by Christian Mauderer <christian.mauderer@…>, on May 30, 2018 at 12:27:35 PM

Import ipsec-tools 0.8.2.

Import unchanged ipsec-tools sources in the release version 0.8.2. The
homepage of ipsec-tools is http://ipsec-tools.sourceforge.net/. The
sources can be obtained from there.

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