Annotation of embedaddon/ipsec-tools/src/racoon/cfparse.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:
! 67:
! 68: /* Copy the first part of user declarations. */
! 69:
! 70: /* Line 189 of yacc.c */
! 71: #line 5 "cfparse.y"
! 72:
! 73: /*
! 74: * Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 and 2003 WIDE Project.
! 75: * All rights reserved.
! 76: *
! 77: * Redistribution and use in source and binary forms, with or without
! 78: * modification, are permitted provided that the following conditions
! 79: * are met:
! 80: * 1. Redistributions of source code must retain the above copyright
! 81: * notice, this list of conditions and the following disclaimer.
! 82: * 2. Redistributions in binary form must reproduce the above copyright
! 83: * notice, this list of conditions and the following disclaimer in the
! 84: * documentation and/or other materials provided with the distribution.
! 85: * 3. Neither the name of the project nor the names of its contributors
! 86: * may be used to endorse or promote products derived from this software
! 87: * without specific prior written permission.
! 88: *
! 89: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
! 90: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 91: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 92: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
! 93: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 94: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 95: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 96: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 97: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 98: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 99: * SUCH DAMAGE.
! 100: */
! 101:
! 102: #include "config.h"
! 103:
! 104: #include <sys/types.h>
! 105: #include <sys/param.h>
! 106: #include <sys/queue.h>
! 107: #include <sys/socket.h>
! 108:
! 109: #include <netinet/in.h>
! 110: #include PATH_IPSEC_H
! 111:
! 112: #ifdef ENABLE_HYBRID
! 113: #include <arpa/inet.h>
! 114: #endif
! 115:
! 116: #include <stdlib.h>
! 117: #include <stdio.h>
! 118: #include <string.h>
! 119: #include <errno.h>
! 120: #include <netdb.h>
! 121: #include <pwd.h>
! 122: #include <grp.h>
! 123:
! 124: #include "var.h"
! 125: #include "misc.h"
! 126: #include "vmbuf.h"
! 127: #include "plog.h"
! 128: #include "sockmisc.h"
! 129: #include "str2val.h"
! 130: #include "genlist.h"
! 131: #include "debug.h"
! 132:
! 133: #include "admin.h"
! 134: #include "privsep.h"
! 135: #include "cfparse_proto.h"
! 136: #include "cftoken_proto.h"
! 137: #include "algorithm.h"
! 138: #include "localconf.h"
! 139: #include "policy.h"
! 140: #include "sainfo.h"
! 141: #include "oakley.h"
! 142: #include "pfkey.h"
! 143: #include "remoteconf.h"
! 144: #include "grabmyaddr.h"
! 145: #include "isakmp_var.h"
! 146: #include "handler.h"
! 147: #include "isakmp.h"
! 148: #include "nattraversal.h"
! 149: #include "isakmp_frag.h"
! 150: #ifdef ENABLE_HYBRID
! 151: #include "resolv.h"
! 152: #include "isakmp_unity.h"
! 153: #include "isakmp_xauth.h"
! 154: #include "isakmp_cfg.h"
! 155: #endif
! 156: #include "ipsec_doi.h"
! 157: #include "strnames.h"
! 158: #include "gcmalloc.h"
! 159: #ifdef HAVE_GSSAPI
! 160: #include "gssapi.h"
! 161: #endif
! 162: #include "vendorid.h"
! 163: #include "rsalist.h"
! 164: #include "crypto_openssl.h"
! 165:
! 166: struct secprotospec {
! 167: int prop_no;
! 168: int trns_no;
! 169: int strength; /* for isakmp/ipsec */
! 170: int encklen; /* for isakmp/ipsec */
! 171: time_t lifetime; /* for isakmp */
! 172: int lifebyte; /* for isakmp */
! 173: int proto_id; /* for ipsec (isakmp?) */
! 174: int ipsec_level; /* for ipsec */
! 175: int encmode; /* for ipsec */
! 176: int vendorid; /* for isakmp */
! 177: char *gssid;
! 178: struct sockaddr *remote;
! 179: int algclass[MAXALGCLASS];
! 180:
! 181: struct secprotospec *next; /* the tail is the most prefiered. */
! 182: struct secprotospec *prev;
! 183: };
! 184:
! 185: static int num2dhgroup[] = {
! 186: 0,
! 187: OAKLEY_ATTR_GRP_DESC_MODP768,
! 188: OAKLEY_ATTR_GRP_DESC_MODP1024,
! 189: OAKLEY_ATTR_GRP_DESC_EC2N155,
! 190: OAKLEY_ATTR_GRP_DESC_EC2N185,
! 191: OAKLEY_ATTR_GRP_DESC_MODP1536,
! 192: 0,
! 193: 0,
! 194: 0,
! 195: 0,
! 196: 0,
! 197: 0,
! 198: 0,
! 199: 0,
! 200: OAKLEY_ATTR_GRP_DESC_MODP2048,
! 201: OAKLEY_ATTR_GRP_DESC_MODP3072,
! 202: OAKLEY_ATTR_GRP_DESC_MODP4096,
! 203: OAKLEY_ATTR_GRP_DESC_MODP6144,
! 204: OAKLEY_ATTR_GRP_DESC_MODP8192
! 205: };
! 206:
! 207: static struct remoteconf *cur_rmconf;
! 208: static int tmpalgtype[MAXALGCLASS];
! 209: static struct sainfo *cur_sainfo;
! 210: static int cur_algclass;
! 211: static int oldloglevel = LLV_BASE;
! 212:
! 213: static struct secprotospec *newspspec __P((void));
! 214: static void insspspec __P((struct remoteconf *, struct secprotospec *));
! 215: void dupspspec_list __P((struct remoteconf *dst, struct remoteconf *src));
! 216: void flushspspec __P((struct remoteconf *));
! 217: static void adminsock_conf __P((vchar_t *, vchar_t *, vchar_t *, int));
! 218:
! 219: static int set_isakmp_proposal __P((struct remoteconf *));
! 220: static void clean_tmpalgtype __P((void));
! 221: static int expand_isakmpspec __P((int, int, int *,
! 222: int, int, time_t, int, int, int, char *, struct remoteconf *));
! 223:
! 224: void freeetypes (struct etypes **etypes);
! 225:
! 226: static int load_x509(const char *file, char **filenameptr,
! 227: vchar_t **certptr)
! 228: {
! 229: char path[PATH_MAX];
! 230:
! 231: getpathname(path, sizeof(path), LC_PATHTYPE_CERT, file);
! 232: *certptr = eay_get_x509cert(path);
! 233: if (*certptr == NULL)
! 234: return -1;
! 235:
! 236: *filenameptr = racoon_strdup(file);
! 237: STRDUP_FATAL(*filenameptr);
! 238:
! 239: return 0;
! 240: }
! 241:
! 242:
! 243:
! 244: /* Line 189 of yacc.c */
! 245: #line 246 "cfparse.c"
! 246:
! 247: /* Enabling traces. */
! 248: #ifndef YYDEBUG
! 249: # define YYDEBUG 0
! 250: #endif
! 251:
! 252: /* Enabling verbose error messages. */
! 253: #ifdef YYERROR_VERBOSE
! 254: # undef YYERROR_VERBOSE
! 255: # define YYERROR_VERBOSE 1
! 256: #else
! 257: # define YYERROR_VERBOSE 0
! 258: #endif
! 259:
! 260: /* Enabling the token table. */
! 261: #ifndef YYTOKEN_TABLE
! 262: # define YYTOKEN_TABLE 0
! 263: #endif
! 264:
! 265:
! 266: /* Tokens. */
! 267: #ifndef YYTOKENTYPE
! 268: # define YYTOKENTYPE
! 269: /* Put the tokens into the symbol table, so that GDB and other debuggers
! 270: know about them. */
! 271: enum yytokentype {
! 272: PRIVSEP = 258,
! 273: USER = 259,
! 274: GROUP = 260,
! 275: CHROOT = 261,
! 276: PATH = 262,
! 277: PATHTYPE = 263,
! 278: INCLUDE = 264,
! 279: PFKEY_BUFFER = 265,
! 280: LOGGING = 266,
! 281: LOGLEV = 267,
! 282: PADDING = 268,
! 283: PAD_RANDOMIZE = 269,
! 284: PAD_RANDOMIZELEN = 270,
! 285: PAD_MAXLEN = 271,
! 286: PAD_STRICT = 272,
! 287: PAD_EXCLTAIL = 273,
! 288: LISTEN = 274,
! 289: X_ISAKMP = 275,
! 290: X_ISAKMP_NATT = 276,
! 291: X_ADMIN = 277,
! 292: STRICT_ADDRESS = 278,
! 293: ADMINSOCK = 279,
! 294: DISABLED = 280,
! 295: LDAPCFG = 281,
! 296: LDAP_HOST = 282,
! 297: LDAP_PORT = 283,
! 298: LDAP_PVER = 284,
! 299: LDAP_BASE = 285,
! 300: LDAP_BIND_DN = 286,
! 301: LDAP_BIND_PW = 287,
! 302: LDAP_SUBTREE = 288,
! 303: LDAP_ATTR_USER = 289,
! 304: LDAP_ATTR_ADDR = 290,
! 305: LDAP_ATTR_MASK = 291,
! 306: LDAP_ATTR_GROUP = 292,
! 307: LDAP_ATTR_MEMBER = 293,
! 308: RADCFG = 294,
! 309: RAD_AUTH = 295,
! 310: RAD_ACCT = 296,
! 311: RAD_TIMEOUT = 297,
! 312: RAD_RETRIES = 298,
! 313: MODECFG = 299,
! 314: CFG_NET4 = 300,
! 315: CFG_MASK4 = 301,
! 316: CFG_DNS4 = 302,
! 317: CFG_NBNS4 = 303,
! 318: CFG_DEFAULT_DOMAIN = 304,
! 319: CFG_AUTH_SOURCE = 305,
! 320: CFG_AUTH_GROUPS = 306,
! 321: CFG_SYSTEM = 307,
! 322: CFG_RADIUS = 308,
! 323: CFG_PAM = 309,
! 324: CFG_LDAP = 310,
! 325: CFG_LOCAL = 311,
! 326: CFG_NONE = 312,
! 327: CFG_GROUP_SOURCE = 313,
! 328: CFG_ACCOUNTING = 314,
! 329: CFG_CONF_SOURCE = 315,
! 330: CFG_MOTD = 316,
! 331: CFG_POOL_SIZE = 317,
! 332: CFG_AUTH_THROTTLE = 318,
! 333: CFG_SPLIT_NETWORK = 319,
! 334: CFG_SPLIT_LOCAL = 320,
! 335: CFG_SPLIT_INCLUDE = 321,
! 336: CFG_SPLIT_DNS = 322,
! 337: CFG_PFS_GROUP = 323,
! 338: CFG_SAVE_PASSWD = 324,
! 339: RETRY = 325,
! 340: RETRY_COUNTER = 326,
! 341: RETRY_INTERVAL = 327,
! 342: RETRY_PERSEND = 328,
! 343: RETRY_PHASE1 = 329,
! 344: RETRY_PHASE2 = 330,
! 345: NATT_KA = 331,
! 346: ALGORITHM_CLASS = 332,
! 347: ALGORITHMTYPE = 333,
! 348: STRENGTHTYPE = 334,
! 349: SAINFO = 335,
! 350: FROM = 336,
! 351: REMOTE = 337,
! 352: ANONYMOUS = 338,
! 353: CLIENTADDR = 339,
! 354: INHERIT = 340,
! 355: REMOTE_ADDRESS = 341,
! 356: EXCHANGE_MODE = 342,
! 357: EXCHANGETYPE = 343,
! 358: DOI = 344,
! 359: DOITYPE = 345,
! 360: SITUATION = 346,
! 361: SITUATIONTYPE = 347,
! 362: CERTIFICATE_TYPE = 348,
! 363: CERTTYPE = 349,
! 364: PEERS_CERTFILE = 350,
! 365: CA_TYPE = 351,
! 366: VERIFY_CERT = 352,
! 367: SEND_CERT = 353,
! 368: SEND_CR = 354,
! 369: MATCH_EMPTY_CR = 355,
! 370: IDENTIFIERTYPE = 356,
! 371: IDENTIFIERQUAL = 357,
! 372: MY_IDENTIFIER = 358,
! 373: PEERS_IDENTIFIER = 359,
! 374: VERIFY_IDENTIFIER = 360,
! 375: DNSSEC = 361,
! 376: CERT_X509 = 362,
! 377: CERT_PLAINRSA = 363,
! 378: NONCE_SIZE = 364,
! 379: DH_GROUP = 365,
! 380: KEEPALIVE = 366,
! 381: PASSIVE = 367,
! 382: INITIAL_CONTACT = 368,
! 383: NAT_TRAVERSAL = 369,
! 384: REMOTE_FORCE_LEVEL = 370,
! 385: PROPOSAL_CHECK = 371,
! 386: PROPOSAL_CHECK_LEVEL = 372,
! 387: GENERATE_POLICY = 373,
! 388: GENERATE_LEVEL = 374,
! 389: SUPPORT_PROXY = 375,
! 390: PROPOSAL = 376,
! 391: EXEC_PATH = 377,
! 392: EXEC_COMMAND = 378,
! 393: EXEC_SUCCESS = 379,
! 394: EXEC_FAILURE = 380,
! 395: GSS_ID = 381,
! 396: GSS_ID_ENC = 382,
! 397: GSS_ID_ENCTYPE = 383,
! 398: COMPLEX_BUNDLE = 384,
! 399: DPD = 385,
! 400: DPD_DELAY = 386,
! 401: DPD_RETRY = 387,
! 402: DPD_MAXFAIL = 388,
! 403: PH1ID = 389,
! 404: XAUTH_LOGIN = 390,
! 405: WEAK_PHASE1_CHECK = 391,
! 406: REKEY = 392,
! 407: PREFIX = 393,
! 408: PORT = 394,
! 409: PORTANY = 395,
! 410: UL_PROTO = 396,
! 411: ANY = 397,
! 412: IKE_FRAG = 398,
! 413: ESP_FRAG = 399,
! 414: MODE_CFG = 400,
! 415: PFS_GROUP = 401,
! 416: LIFETIME = 402,
! 417: LIFETYPE_TIME = 403,
! 418: LIFETYPE_BYTE = 404,
! 419: STRENGTH = 405,
! 420: REMOTEID = 406,
! 421: SCRIPT = 407,
! 422: PHASE1_UP = 408,
! 423: PHASE1_DOWN = 409,
! 424: PHASE1_DEAD = 410,
! 425: NUMBER = 411,
! 426: SWITCH = 412,
! 427: BOOLEAN = 413,
! 428: HEXSTRING = 414,
! 429: QUOTEDSTRING = 415,
! 430: ADDRSTRING = 416,
! 431: ADDRRANGE = 417,
! 432: UNITTYPE_BYTE = 418,
! 433: UNITTYPE_KBYTES = 419,
! 434: UNITTYPE_MBYTES = 420,
! 435: UNITTYPE_TBYTES = 421,
! 436: UNITTYPE_SEC = 422,
! 437: UNITTYPE_MIN = 423,
! 438: UNITTYPE_HOUR = 424,
! 439: EOS = 425,
! 440: BOC = 426,
! 441: EOC = 427,
! 442: COMMA = 428
! 443: };
! 444: #endif
! 445: /* Tokens. */
! 446: #define PRIVSEP 258
! 447: #define USER 259
! 448: #define GROUP 260
! 449: #define CHROOT 261
! 450: #define PATH 262
! 451: #define PATHTYPE 263
! 452: #define INCLUDE 264
! 453: #define PFKEY_BUFFER 265
! 454: #define LOGGING 266
! 455: #define LOGLEV 267
! 456: #define PADDING 268
! 457: #define PAD_RANDOMIZE 269
! 458: #define PAD_RANDOMIZELEN 270
! 459: #define PAD_MAXLEN 271
! 460: #define PAD_STRICT 272
! 461: #define PAD_EXCLTAIL 273
! 462: #define LISTEN 274
! 463: #define X_ISAKMP 275
! 464: #define X_ISAKMP_NATT 276
! 465: #define X_ADMIN 277
! 466: #define STRICT_ADDRESS 278
! 467: #define ADMINSOCK 279
! 468: #define DISABLED 280
! 469: #define LDAPCFG 281
! 470: #define LDAP_HOST 282
! 471: #define LDAP_PORT 283
! 472: #define LDAP_PVER 284
! 473: #define LDAP_BASE 285
! 474: #define LDAP_BIND_DN 286
! 475: #define LDAP_BIND_PW 287
! 476: #define LDAP_SUBTREE 288
! 477: #define LDAP_ATTR_USER 289
! 478: #define LDAP_ATTR_ADDR 290
! 479: #define LDAP_ATTR_MASK 291
! 480: #define LDAP_ATTR_GROUP 292
! 481: #define LDAP_ATTR_MEMBER 293
! 482: #define RADCFG 294
! 483: #define RAD_AUTH 295
! 484: #define RAD_ACCT 296
! 485: #define RAD_TIMEOUT 297
! 486: #define RAD_RETRIES 298
! 487: #define MODECFG 299
! 488: #define CFG_NET4 300
! 489: #define CFG_MASK4 301
! 490: #define CFG_DNS4 302
! 491: #define CFG_NBNS4 303
! 492: #define CFG_DEFAULT_DOMAIN 304
! 493: #define CFG_AUTH_SOURCE 305
! 494: #define CFG_AUTH_GROUPS 306
! 495: #define CFG_SYSTEM 307
! 496: #define CFG_RADIUS 308
! 497: #define CFG_PAM 309
! 498: #define CFG_LDAP 310
! 499: #define CFG_LOCAL 311
! 500: #define CFG_NONE 312
! 501: #define CFG_GROUP_SOURCE 313
! 502: #define CFG_ACCOUNTING 314
! 503: #define CFG_CONF_SOURCE 315
! 504: #define CFG_MOTD 316
! 505: #define CFG_POOL_SIZE 317
! 506: #define CFG_AUTH_THROTTLE 318
! 507: #define CFG_SPLIT_NETWORK 319
! 508: #define CFG_SPLIT_LOCAL 320
! 509: #define CFG_SPLIT_INCLUDE 321
! 510: #define CFG_SPLIT_DNS 322
! 511: #define CFG_PFS_GROUP 323
! 512: #define CFG_SAVE_PASSWD 324
! 513: #define RETRY 325
! 514: #define RETRY_COUNTER 326
! 515: #define RETRY_INTERVAL 327
! 516: #define RETRY_PERSEND 328
! 517: #define RETRY_PHASE1 329
! 518: #define RETRY_PHASE2 330
! 519: #define NATT_KA 331
! 520: #define ALGORITHM_CLASS 332
! 521: #define ALGORITHMTYPE 333
! 522: #define STRENGTHTYPE 334
! 523: #define SAINFO 335
! 524: #define FROM 336
! 525: #define REMOTE 337
! 526: #define ANONYMOUS 338
! 527: #define CLIENTADDR 339
! 528: #define INHERIT 340
! 529: #define REMOTE_ADDRESS 341
! 530: #define EXCHANGE_MODE 342
! 531: #define EXCHANGETYPE 343
! 532: #define DOI 344
! 533: #define DOITYPE 345
! 534: #define SITUATION 346
! 535: #define SITUATIONTYPE 347
! 536: #define CERTIFICATE_TYPE 348
! 537: #define CERTTYPE 349
! 538: #define PEERS_CERTFILE 350
! 539: #define CA_TYPE 351
! 540: #define VERIFY_CERT 352
! 541: #define SEND_CERT 353
! 542: #define SEND_CR 354
! 543: #define MATCH_EMPTY_CR 355
! 544: #define IDENTIFIERTYPE 356
! 545: #define IDENTIFIERQUAL 357
! 546: #define MY_IDENTIFIER 358
! 547: #define PEERS_IDENTIFIER 359
! 548: #define VERIFY_IDENTIFIER 360
! 549: #define DNSSEC 361
! 550: #define CERT_X509 362
! 551: #define CERT_PLAINRSA 363
! 552: #define NONCE_SIZE 364
! 553: #define DH_GROUP 365
! 554: #define KEEPALIVE 366
! 555: #define PASSIVE 367
! 556: #define INITIAL_CONTACT 368
! 557: #define NAT_TRAVERSAL 369
! 558: #define REMOTE_FORCE_LEVEL 370
! 559: #define PROPOSAL_CHECK 371
! 560: #define PROPOSAL_CHECK_LEVEL 372
! 561: #define GENERATE_POLICY 373
! 562: #define GENERATE_LEVEL 374
! 563: #define SUPPORT_PROXY 375
! 564: #define PROPOSAL 376
! 565: #define EXEC_PATH 377
! 566: #define EXEC_COMMAND 378
! 567: #define EXEC_SUCCESS 379
! 568: #define EXEC_FAILURE 380
! 569: #define GSS_ID 381
! 570: #define GSS_ID_ENC 382
! 571: #define GSS_ID_ENCTYPE 383
! 572: #define COMPLEX_BUNDLE 384
! 573: #define DPD 385
! 574: #define DPD_DELAY 386
! 575: #define DPD_RETRY 387
! 576: #define DPD_MAXFAIL 388
! 577: #define PH1ID 389
! 578: #define XAUTH_LOGIN 390
! 579: #define WEAK_PHASE1_CHECK 391
! 580: #define REKEY 392
! 581: #define PREFIX 393
! 582: #define PORT 394
! 583: #define PORTANY 395
! 584: #define UL_PROTO 396
! 585: #define ANY 397
! 586: #define IKE_FRAG 398
! 587: #define ESP_FRAG 399
! 588: #define MODE_CFG 400
! 589: #define PFS_GROUP 401
! 590: #define LIFETIME 402
! 591: #define LIFETYPE_TIME 403
! 592: #define LIFETYPE_BYTE 404
! 593: #define STRENGTH 405
! 594: #define REMOTEID 406
! 595: #define SCRIPT 407
! 596: #define PHASE1_UP 408
! 597: #define PHASE1_DOWN 409
! 598: #define PHASE1_DEAD 410
! 599: #define NUMBER 411
! 600: #define SWITCH 412
! 601: #define BOOLEAN 413
! 602: #define HEXSTRING 414
! 603: #define QUOTEDSTRING 415
! 604: #define ADDRSTRING 416
! 605: #define ADDRRANGE 417
! 606: #define UNITTYPE_BYTE 418
! 607: #define UNITTYPE_KBYTES 419
! 608: #define UNITTYPE_MBYTES 420
! 609: #define UNITTYPE_TBYTES 421
! 610: #define UNITTYPE_SEC 422
! 611: #define UNITTYPE_MIN 423
! 612: #define UNITTYPE_HOUR 424
! 613: #define EOS 425
! 614: #define BOC 426
! 615: #define EOC 427
! 616: #define COMMA 428
! 617:
! 618:
! 619:
! 620:
! 621: #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
! 622: typedef union YYSTYPE
! 623: {
! 624:
! 625: /* Line 214 of yacc.c */
! 626: #line 177 "cfparse.y"
! 627:
! 628: unsigned long num;
! 629: vchar_t *val;
! 630: struct remoteconf *rmconf;
! 631: struct sockaddr *saddr;
! 632: struct sainfoalg *alg;
! 633:
! 634:
! 635:
! 636: /* Line 214 of yacc.c */
! 637: #line 638 "cfparse.c"
! 638: } YYSTYPE;
! 639: # define YYSTYPE_IS_TRIVIAL 1
! 640: # define yystype YYSTYPE /* obsolescent; will be withdrawn */
! 641: # define YYSTYPE_IS_DECLARED 1
! 642: #endif
! 643:
! 644:
! 645: /* Copy the second part of user declarations. */
! 646:
! 647:
! 648: /* Line 264 of yacc.c */
! 649: #line 650 "cfparse.c"
! 650:
! 651: #ifdef short
! 652: # undef short
! 653: #endif
! 654:
! 655: #ifdef YYTYPE_UINT8
! 656: typedef YYTYPE_UINT8 yytype_uint8;
! 657: #else
! 658: typedef unsigned char yytype_uint8;
! 659: #endif
! 660:
! 661: #ifdef YYTYPE_INT8
! 662: typedef YYTYPE_INT8 yytype_int8;
! 663: #elif (defined __STDC__ || defined __C99__FUNC__ \
! 664: || defined __cplusplus || defined _MSC_VER)
! 665: typedef signed char yytype_int8;
! 666: #else
! 667: typedef short int yytype_int8;
! 668: #endif
! 669:
! 670: #ifdef YYTYPE_UINT16
! 671: typedef YYTYPE_UINT16 yytype_uint16;
! 672: #else
! 673: typedef unsigned short int yytype_uint16;
! 674: #endif
! 675:
! 676: #ifdef YYTYPE_INT16
! 677: typedef YYTYPE_INT16 yytype_int16;
! 678: #else
! 679: typedef short int yytype_int16;
! 680: #endif
! 681:
! 682: #ifndef YYSIZE_T
! 683: # ifdef __SIZE_TYPE__
! 684: # define YYSIZE_T __SIZE_TYPE__
! 685: # elif defined size_t
! 686: # define YYSIZE_T size_t
! 687: # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
! 688: || defined __cplusplus || defined _MSC_VER)
! 689: # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
! 690: # define YYSIZE_T size_t
! 691: # else
! 692: # define YYSIZE_T unsigned int
! 693: # endif
! 694: #endif
! 695:
! 696: #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
! 697:
! 698: #ifndef YY_
! 699: # if YYENABLE_NLS
! 700: # if ENABLE_NLS
! 701: # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
! 702: # define YY_(msgid) dgettext ("bison-runtime", msgid)
! 703: # endif
! 704: # endif
! 705: # ifndef YY_
! 706: # define YY_(msgid) msgid
! 707: # endif
! 708: #endif
! 709:
! 710: /* Suppress unused-variable warnings by "using" E. */
! 711: #if ! defined lint || defined __GNUC__
! 712: # define YYUSE(e) ((void) (e))
! 713: #else
! 714: # define YYUSE(e) /* empty */
! 715: #endif
! 716:
! 717: /* Identity function, used to suppress warnings about constant conditions. */
! 718: #ifndef lint
! 719: # define YYID(n) (n)
! 720: #else
! 721: #if (defined __STDC__ || defined __C99__FUNC__ \
! 722: || defined __cplusplus || defined _MSC_VER)
! 723: static int
! 724: YYID (int yyi)
! 725: #else
! 726: static int
! 727: YYID (yyi)
! 728: int yyi;
! 729: #endif
! 730: {
! 731: return yyi;
! 732: }
! 733: #endif
! 734:
! 735: #if ! defined yyoverflow || YYERROR_VERBOSE
! 736:
! 737: /* The parser invokes alloca or malloc; define the necessary symbols. */
! 738:
! 739: # ifdef YYSTACK_USE_ALLOCA
! 740: # if YYSTACK_USE_ALLOCA
! 741: # ifdef __GNUC__
! 742: # define YYSTACK_ALLOC __builtin_alloca
! 743: # elif defined __BUILTIN_VA_ARG_INCR
! 744: # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
! 745: # elif defined _AIX
! 746: # define YYSTACK_ALLOC __alloca
! 747: # elif defined _MSC_VER
! 748: # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
! 749: # define alloca _alloca
! 750: # else
! 751: # define YYSTACK_ALLOC alloca
! 752: # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
! 753: || defined __cplusplus || defined _MSC_VER)
! 754: # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
! 755: # ifndef _STDLIB_H
! 756: # define _STDLIB_H 1
! 757: # endif
! 758: # endif
! 759: # endif
! 760: # endif
! 761: # endif
! 762:
! 763: # ifdef YYSTACK_ALLOC
! 764: /* Pacify GCC's `empty if-body' warning. */
! 765: # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
! 766: # ifndef YYSTACK_ALLOC_MAXIMUM
! 767: /* The OS might guarantee only one guard page at the bottom of the stack,
! 768: and a page size can be as small as 4096 bytes. So we cannot safely
! 769: invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
! 770: to allow for a few compiler-allocated temporary stack slots. */
! 771: # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
! 772: # endif
! 773: # else
! 774: # define YYSTACK_ALLOC YYMALLOC
! 775: # define YYSTACK_FREE YYFREE
! 776: # ifndef YYSTACK_ALLOC_MAXIMUM
! 777: # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
! 778: # endif
! 779: # if (defined __cplusplus && ! defined _STDLIB_H \
! 780: && ! ((defined YYMALLOC || defined malloc) \
! 781: && (defined YYFREE || defined free)))
! 782: # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
! 783: # ifndef _STDLIB_H
! 784: # define _STDLIB_H 1
! 785: # endif
! 786: # endif
! 787: # ifndef YYMALLOC
! 788: # define YYMALLOC malloc
! 789: # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
! 790: || defined __cplusplus || defined _MSC_VER)
! 791: void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
! 792: # endif
! 793: # endif
! 794: # ifndef YYFREE
! 795: # define YYFREE free
! 796: # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
! 797: || defined __cplusplus || defined _MSC_VER)
! 798: void free (void *); /* INFRINGES ON USER NAME SPACE */
! 799: # endif
! 800: # endif
! 801: # endif
! 802: #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
! 803:
! 804:
! 805: #if (! defined yyoverflow \
! 806: && (! defined __cplusplus \
! 807: || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
! 808:
! 809: /* A type that is properly aligned for any stack member. */
! 810: union yyalloc
! 811: {
! 812: yytype_int16 yyss_alloc;
! 813: YYSTYPE yyvs_alloc;
! 814: };
! 815:
! 816: /* The size of the maximum gap between one aligned stack and the next. */
! 817: # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
! 818:
! 819: /* The size of an array large to enough to hold all stacks, each with
! 820: N elements. */
! 821: # define YYSTACK_BYTES(N) \
! 822: ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
! 823: + YYSTACK_GAP_MAXIMUM)
! 824:
! 825: /* Copy COUNT objects from FROM to TO. The source and destination do
! 826: not overlap. */
! 827: # ifndef YYCOPY
! 828: # if defined __GNUC__ && 1 < __GNUC__
! 829: # define YYCOPY(To, From, Count) \
! 830: __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
! 831: # else
! 832: # define YYCOPY(To, From, Count) \
! 833: do \
! 834: { \
! 835: YYSIZE_T yyi; \
! 836: for (yyi = 0; yyi < (Count); yyi++) \
! 837: (To)[yyi] = (From)[yyi]; \
! 838: } \
! 839: while (YYID (0))
! 840: # endif
! 841: # endif
! 842:
! 843: /* Relocate STACK from its old location to the new one. The
! 844: local variables YYSIZE and YYSTACKSIZE give the old and new number of
! 845: elements in the stack, and YYPTR gives the new location of the
! 846: stack. Advance YYPTR to a properly aligned location for the next
! 847: stack. */
! 848: # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
! 849: do \
! 850: { \
! 851: YYSIZE_T yynewbytes; \
! 852: YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
! 853: Stack = &yyptr->Stack_alloc; \
! 854: yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
! 855: yyptr += yynewbytes / sizeof (*yyptr); \
! 856: } \
! 857: while (YYID (0))
! 858:
! 859: #endif
! 860:
! 861: /* YYFINAL -- State number of the termination state. */
! 862: #define YYFINAL 2
! 863: /* YYLAST -- Last index in YYTABLE. */
! 864: #define YYLAST 548
! 865:
! 866: /* YYNTOKENS -- Number of terminals. */
! 867: #define YYNTOKENS 174
! 868: /* YYNNTS -- Number of nonterminals. */
! 869: #define YYNNTS 203
! 870: /* YYNRULES -- Number of rules. */
! 871: #define YYNRULES 379
! 872: /* YYNRULES -- Number of states. */
! 873: #define YYNSTATES 689
! 874:
! 875: /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
! 876: #define YYUNDEFTOK 2
! 877: #define YYMAXUTOK 428
! 878:
! 879: #define YYTRANSLATE(YYX) \
! 880: ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
! 881:
! 882: /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
! 883: static const yytype_uint8 yytranslate[] =
! 884: {
! 885: 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 886: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 887: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 888: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 889: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 890: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 891: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 892: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 893: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 894: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 895: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 896: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 897: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 898: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 899: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 900: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 901: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 902: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 903: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 904: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 905: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 906: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 907: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 908: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 909: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 910: 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
! 911: 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
! 912: 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
! 913: 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
! 914: 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
! 915: 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
! 916: 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
! 917: 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
! 918: 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
! 919: 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
! 920: 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
! 921: 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
! 922: 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
! 923: 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
! 924: 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
! 925: 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
! 926: 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
! 927: 165, 166, 167, 168, 169, 170, 171, 172, 173
! 928: };
! 929:
! 930: #if YYDEBUG
! 931: /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
! 932: YYRHS. */
! 933: static const yytype_uint16 yyprhs[] =
! 934: {
! 935: 0, 0, 3, 4, 7, 9, 11, 13, 15, 17,
! 936: 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
! 937: 42, 43, 46, 47, 52, 53, 58, 59, 64, 65,
! 938: 70, 71, 76, 77, 83, 84, 89, 93, 97, 101,
! 939: 105, 107, 112, 113, 116, 117, 122, 123, 128, 129,
! 940: 134, 135, 140, 141, 146, 151, 152, 155, 156, 161,
! 941: 162, 167, 168, 176, 177, 182, 183, 188, 189, 193,
! 942: 196, 197, 199, 200, 206, 207, 210, 211, 217, 218,
! 943: 225, 226, 232, 233, 240, 241, 246, 247, 252, 253,
! 944: 259, 260, 263, 264, 269, 270, 275, 276, 281, 282,
! 945: 287, 288, 293, 294, 299, 300, 305, 306, 311, 312,
! 946: 317, 318, 323, 324, 329, 330, 335, 340, 341, 344,
! 947: 345, 350, 351, 356, 360, 364, 365, 371, 372, 378,
! 948: 379, 384, 385, 390, 391, 396, 397, 402, 403, 408,
! 949: 409, 414, 415, 420, 421, 426, 427, 432, 433, 438,
! 950: 439, 444, 445, 450, 451, 456, 457, 462, 463, 468,
! 951: 469, 474, 475, 480, 481, 486, 487, 492, 493, 498,
! 952: 499, 504, 506, 510, 512, 514, 518, 520, 522, 526,
! 953: 529, 531, 535, 537, 539, 543, 545, 550, 551, 554,
! 954: 555, 560, 561, 567, 568, 573, 574, 580, 581, 587,
! 955: 588, 594, 595, 596, 605, 607, 610, 613, 616, 619,
! 956: 622, 628, 635, 638, 639, 643, 646, 647, 650, 651,
! 957: 656, 657, 662, 663, 670, 671, 678, 679, 684, 686,
! 958: 687, 692, 695, 696, 698, 699, 701, 703, 705, 707,
! 959: 709, 710, 712, 713, 720, 721, 726, 727, 734, 735,
! 960: 740, 744, 747, 749, 750, 753, 754, 759, 760, 765,
! 961: 766, 771, 772, 777, 780, 781, 786, 787, 793, 794,
! 962: 800, 801, 806, 807, 813, 814, 819, 820, 825, 826,
! 963: 831, 832, 837, 838, 844, 845, 852, 853, 858, 859,
! 964: 865, 866, 873, 874, 879, 880, 885, 886, 891, 892,
! 965: 897, 898, 903, 904, 909, 910, 915, 916, 922, 923,
! 966: 929, 930, 936, 937, 942, 943, 948, 949, 954, 955,
! 967: 960, 961, 966, 967, 972, 973, 978, 979, 984, 985,
! 968: 990, 991, 996, 997, 1002, 1003, 1008, 1009, 1014, 1015,
! 969: 1020, 1021, 1026, 1027, 1034, 1035, 1040, 1041, 1048, 1049,
! 970: 1055, 1056, 1059, 1060, 1066, 1067, 1072, 1074, 1076, 1077,
! 971: 1079, 1081, 1082, 1085, 1086, 1093, 1094, 1101, 1102, 1107,
! 972: 1108, 1113, 1114, 1120, 1122, 1124, 1126, 1128, 1130, 1132
! 973: };
! 974:
! 975: /* YYRHS -- A `-1'-separated list of the rules' RHS. */
! 976: static const yytype_int16 yyrhs[] =
! 977: {
! 978: 175, 0, -1, -1, 175, 176, -1, 177, -1, 185,
! 979: -1, 189, -1, 190, -1, 191, -1, 192, -1, 194,
! 980: -1, 202, -1, 223, -1, 213, -1, 239, -1, 277,
! 981: -1, 286, -1, 306, -1, 187, -1, 3, 171, 178,
! 982: 172, -1, -1, 178, 179, -1, -1, 4, 160, 180,
! 983: 170, -1, -1, 4, 156, 181, 170, -1, -1, 5,
! 984: 160, 182, 170, -1, -1, 5, 156, 183, 170, -1,
! 985: -1, 6, 160, 184, 170, -1, -1, 7, 8, 160,
! 986: 186, 170, -1, -1, 129, 157, 188, 170, -1, 9,
! 987: 160, 170, -1, 10, 156, 170, -1, 127, 128, 170,
! 988: -1, 11, 193, 170, -1, 12, -1, 13, 171, 195,
! 989: 172, -1, -1, 195, 196, -1, -1, 14, 157, 197,
! 990: 170, -1, -1, 15, 157, 198, 170, -1, -1, 16,
! 991: 156, 199, 170, -1, -1, 17, 157, 200, 170, -1,
! 992: -1, 18, 157, 201, 170, -1, 19, 171, 203, 172,
! 993: -1, -1, 203, 204, -1, -1, 20, 211, 205, 170,
! 994: -1, -1, 21, 211, 206, 170, -1, -1, 24, 160,
! 995: 160, 160, 156, 207, 170, -1, -1, 24, 160, 208,
! 996: 170, -1, -1, 24, 25, 209, 170, -1, -1, 23,
! 997: 210, 170, -1, 161, 212, -1, -1, 139, -1, -1,
! 998: 39, 214, 171, 215, 172, -1, -1, 215, 216, -1,
! 999: -1, 40, 160, 160, 217, 170, -1, -1, 40, 160,
! 1000: 156, 160, 218, 170, -1, -1, 41, 160, 160, 219,
! 1001: 170, -1, -1, 41, 160, 156, 160, 220, 170, -1,
! 1002: -1, 42, 156, 221, 170, -1, -1, 43, 156, 222,
! 1003: 170, -1, -1, 26, 224, 171, 225, 172, -1, -1,
! 1004: 225, 226, -1, -1, 29, 156, 227, 170, -1, -1,
! 1005: 27, 160, 228, 170, -1, -1, 28, 156, 229, 170,
! 1006: -1, -1, 30, 160, 230, 170, -1, -1, 33, 157,
! 1007: 231, 170, -1, -1, 31, 160, 232, 170, -1, -1,
! 1008: 32, 160, 233, 170, -1, -1, 34, 160, 234, 170,
! 1009: -1, -1, 35, 160, 235, 170, -1, -1, 36, 160,
! 1010: 236, 170, -1, -1, 37, 160, 237, 170, -1, -1,
! 1011: 38, 160, 238, 170, -1, 44, 171, 240, 172, -1,
! 1012: -1, 240, 241, -1, -1, 45, 161, 242, 170, -1,
! 1013: -1, 46, 161, 243, 170, -1, 47, 267, 170, -1,
! 1014: 48, 269, 170, -1, -1, 64, 65, 271, 244, 170,
! 1015: -1, -1, 64, 66, 271, 245, 170, -1, -1, 67,
! 1016: 275, 246, 170, -1, -1, 49, 160, 247, 170, -1,
! 1017: -1, 50, 52, 248, 170, -1, -1, 50, 53, 249,
! 1018: 170, -1, -1, 50, 54, 250, 170, -1, -1, 50,
! 1019: 55, 251, 170, -1, -1, 51, 273, 252, 170, -1,
! 1020: -1, 58, 52, 253, 170, -1, -1, 58, 55, 254,
! 1021: 170, -1, -1, 59, 57, 255, 170, -1, -1, 59,
! 1022: 52, 256, 170, -1, -1, 59, 53, 257, 170, -1,
! 1023: -1, 59, 54, 258, 170, -1, -1, 62, 156, 259,
! 1024: 170, -1, -1, 68, 156, 260, 170, -1, -1, 69,
! 1025: 157, 261, 170, -1, -1, 63, 156, 262, 170, -1,
! 1026: -1, 60, 56, 263, 170, -1, -1, 60, 53, 264,
! 1027: 170, -1, -1, 60, 55, 265, 170, -1, -1, 61,
! 1028: 160, 266, 170, -1, 268, -1, 268, 173, 267, -1,
! 1029: 161, -1, 270, -1, 270, 173, 269, -1, 161, -1,
! 1030: 272, -1, 271, 173, 272, -1, 161, 138, -1, 274,
! 1031: -1, 274, 173, 273, -1, 160, -1, 276, -1, 276,
! 1032: 173, 275, -1, 160, -1, 70, 171, 278, 172, -1,
! 1033: -1, 278, 279, -1, -1, 71, 156, 280, 170, -1,
! 1034: -1, 72, 156, 375, 281, 170, -1, -1, 73, 156,
! 1035: 282, 170, -1, -1, 74, 156, 375, 283, 170, -1,
! 1036: -1, 75, 156, 375, 284, 170, -1, -1, 76, 156,
! 1037: 375, 285, 170, -1, -1, -1, 80, 287, 289, 291,
! 1038: 171, 292, 288, 172, -1, 83, -1, 83, 84, -1,
! 1039: 83, 290, -1, 290, 83, -1, 290, 84, -1, 290,
! 1040: 290, -1, 101, 161, 302, 303, 304, -1, 101, 161,
! 1041: 162, 302, 303, 304, -1, 101, 160, -1, -1, 81,
! 1042: 101, 367, -1, 5, 160, -1, -1, 292, 293, -1,
! 1043: -1, 146, 366, 294, 170, -1, -1, 151, 156, 295,
! 1044: 170, -1, -1, 147, 148, 156, 375, 296, 170, -1,
! 1045: -1, 147, 149, 156, 376, 297, 170, -1, -1, 77,
! 1046: 298, 299, 170, -1, 301, -1, -1, 301, 300, 173,
! 1047: 299, -1, 78, 305, -1, -1, 138, -1, -1, 139,
! 1048: -1, 140, -1, 156, -1, 141, -1, 142, -1, -1,
! 1049: 156, -1, -1, 82, 160, 85, 160, 307, 311, -1,
! 1050: -1, 82, 160, 308, 311, -1, -1, 82, 312, 85,
! 1051: 312, 309, 311, -1, -1, 82, 312, 310, 311, -1,
! 1052: 171, 313, 172, -1, 83, 212, -1, 211, -1, -1,
! 1053: 313, 314, -1, -1, 86, 211, 315, 170, -1, -1,
! 1054: 87, 316, 362, 170, -1, -1, 89, 90, 317, 170,
! 1055: -1, -1, 91, 92, 318, 170, -1, 93, 363, -1,
! 1056: -1, 95, 160, 319, 170, -1, -1, 95, 107, 160,
! 1057: 320, 170, -1, -1, 95, 108, 160, 321, 170, -1,
! 1058: -1, 95, 106, 322, 170, -1, -1, 96, 107, 160,
! 1059: 323, 170, -1, -1, 97, 157, 324, 170, -1, -1,
! 1060: 98, 157, 325, 170, -1, -1, 99, 157, 326, 170,
! 1061: -1, -1, 100, 157, 327, 170, -1, -1, 103, 101,
! 1062: 367, 328, 170, -1, -1, 103, 101, 102, 367, 329,
! 1063: 170, -1, -1, 135, 367, 330, 170, -1, -1, 104,
! 1064: 101, 367, 331, 170, -1, -1, 104, 101, 102, 367,
! 1065: 332, 170, -1, -1, 105, 157, 333, 170, -1, -1,
! 1066: 109, 156, 334, 170, -1, -1, 110, 335, 366, 170,
! 1067: -1, -1, 112, 157, 336, 170, -1, -1, 143, 157,
! 1068: 337, 170, -1, -1, 143, 115, 338, 170, -1, -1,
! 1069: 144, 156, 339, 170, -1, -1, 152, 160, 153, 340,
! 1070: 170, -1, -1, 152, 160, 154, 341, 170, -1, -1,
! 1071: 152, 160, 155, 342, 170, -1, -1, 145, 157, 343,
! 1072: 170, -1, -1, 136, 157, 344, 170, -1, -1, 118,
! 1073: 157, 345, 170, -1, -1, 118, 119, 346, 170, -1,
! 1074: -1, 120, 157, 347, 170, -1, -1, 113, 157, 348,
! 1075: 170, -1, -1, 114, 157, 349, 170, -1, -1, 114,
! 1076: 115, 350, 170, -1, -1, 130, 157, 351, 170, -1,
! 1077: -1, 131, 156, 352, 170, -1, -1, 132, 156, 353,
! 1078: 170, -1, -1, 133, 156, 354, 170, -1, -1, 137,
! 1079: 157, 355, 170, -1, -1, 137, 115, 356, 170, -1,
! 1080: -1, 134, 156, 357, 170, -1, -1, 147, 148, 156,
! 1081: 375, 358, 170, -1, -1, 116, 117, 359, 170, -1,
! 1082: -1, 147, 149, 156, 376, 360, 170, -1, -1, 121,
! 1083: 361, 171, 368, 172, -1, -1, 362, 88, -1, -1,
! 1084: 107, 160, 160, 364, 170, -1, -1, 108, 160, 365,
! 1085: 170, -1, 78, -1, 156, -1, -1, 161, -1, 160,
! 1086: -1, -1, 368, 369, -1, -1, 147, 148, 156, 375,
! 1087: 370, 170, -1, -1, 147, 149, 156, 376, 371, 170,
! 1088: -1, -1, 110, 366, 372, 170, -1, -1, 126, 160,
! 1089: 373, 170, -1, -1, 77, 78, 305, 374, 170, -1,
! 1090: 167, -1, 168, -1, 169, -1, 163, -1, 164, -1,
! 1091: 165, -1, 166, -1
! 1092: };
! 1093:
! 1094: /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
! 1095: static const yytype_uint16 yyrline[] =
! 1096: {
! 1097: 0, 266, 266, 268, 271, 272, 273, 274, 275, 276,
! 1098: 277, 278, 279, 280, 281, 282, 283, 284, 285, 290,
! 1099: 292, 294, 298, 297, 308, 308, 310, 309, 320, 320,
! 1100: 321, 321, 327, 326, 347, 347, 352, 366, 373, 385,
! 1101: 388, 402, 404, 406, 409, 409, 410, 410, 411, 411,
! 1102: 412, 412, 413, 413, 418, 420, 422, 426, 425, 432,
! 1103: 431, 443, 442, 452, 451, 461, 460, 469, 469, 472,
! 1104: 484, 485, 490, 490, 507, 509, 513, 512, 531, 530,
! 1105: 549, 548, 567, 566, 585, 584, 594, 593, 606, 606,
! 1106: 617, 619, 623, 622, 634, 633, 645, 644, 654, 653,
! 1107: 665, 664, 674, 673, 685, 684, 696, 695, 707, 706,
! 1108: 718, 717, 729, 728, 740, 739, 754, 756, 758, 762,
! 1109: 761, 773, 772, 783, 785, 788, 787, 797, 796, 806,
! 1110: 805, 813, 812, 825, 824, 834, 833, 847, 846, 860,
! 1111: 859, 873, 872, 880, 879, 889, 888, 902, 901, 911,
! 1112: 910, 920, 919, 933, 932, 946, 945, 956, 955, 965,
! 1113: 964, 974, 973, 983, 982, 992, 991, 1005, 1004, 1018,
! 1114: 1017, 1031, 1032, 1035, 1052, 1053, 1056, 1073, 1074, 1077,
! 1115: 1100, 1101, 1104, 1138, 1139, 1142, 1179, 1181, 1183, 1187,
! 1116: 1186, 1192, 1191, 1197, 1196, 1202, 1201, 1207, 1206, 1212,
! 1117: 1211, 1228, 1236, 1227, 1275, 1280, 1285, 1290, 1295, 1300,
! 1118: 1307, 1356, 1421, 1450, 1453, 1478, 1491, 1493, 1497, 1496,
! 1119: 1502, 1501, 1507, 1506, 1512, 1511, 1523, 1523, 1530, 1535,
! 1120: 1534, 1541, 1597, 1598, 1601, 1602, 1603, 1606, 1607, 1608,
! 1121: 1611, 1612, 1618, 1617, 1648, 1647, 1668, 1667, 1691, 1690,
! 1122: 1707, 1784, 1790, 1799, 1801, 1805, 1804, 1814, 1813, 1818,
! 1123: 1818, 1819, 1819, 1820, 1822, 1821, 1842, 1841, 1859, 1858,
! 1124: 1889, 1888, 1903, 1902, 1919, 1919, 1920, 1920, 1921, 1921,
! 1125: 1922, 1922, 1924, 1923, 1933, 1932, 1942, 1941, 1959, 1958,
! 1126: 1976, 1975, 1992, 1992, 1993, 1993, 1995, 1994, 2000, 2000,
! 1127: 2001, 2001, 2002, 2002, 2003, 2003, 2013, 2013, 2020, 2020,
! 1128: 2027, 2027, 2034, 2034, 2035, 2035, 2038, 2038, 2039, 2039,
! 1129: 2040, 2040, 2041, 2041, 2043, 2042, 2054, 2053, 2065, 2064,
! 1130: 2073, 2072, 2082, 2081, 2091, 2090, 2099, 2099, 2100, 2100,
! 1131: 2102, 2101, 2107, 2106, 2111, 2111, 2113, 2112, 2127, 2126,
! 1132: 2137, 2139, 2163, 2162, 2184, 2183, 2217, 2225, 2237, 2238,
! 1133: 2239, 2241, 2243, 2247, 2246, 2252, 2251, 2264, 2263, 2269,
! 1134: 2268, 2282, 2281, 2379, 2380, 2381, 2384, 2385, 2386, 2387
! 1135: };
! 1136: #endif
! 1137:
! 1138: #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
! 1139: /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
! 1140: First, the terminals, then, starting at YYNTOKENS, nonterminals. */
! 1141: static const char *const yytname[] =
! 1142: {
! 1143: "$end", "error", "$undefined", "PRIVSEP", "USER", "GROUP", "CHROOT",
! 1144: "PATH", "PATHTYPE", "INCLUDE", "PFKEY_BUFFER", "LOGGING", "LOGLEV",
! 1145: "PADDING", "PAD_RANDOMIZE", "PAD_RANDOMIZELEN", "PAD_MAXLEN",
! 1146: "PAD_STRICT", "PAD_EXCLTAIL", "LISTEN", "X_ISAKMP", "X_ISAKMP_NATT",
! 1147: "X_ADMIN", "STRICT_ADDRESS", "ADMINSOCK", "DISABLED", "LDAPCFG",
! 1148: "LDAP_HOST", "LDAP_PORT", "LDAP_PVER", "LDAP_BASE", "LDAP_BIND_DN",
! 1149: "LDAP_BIND_PW", "LDAP_SUBTREE", "LDAP_ATTR_USER", "LDAP_ATTR_ADDR",
! 1150: "LDAP_ATTR_MASK", "LDAP_ATTR_GROUP", "LDAP_ATTR_MEMBER", "RADCFG",
! 1151: "RAD_AUTH", "RAD_ACCT", "RAD_TIMEOUT", "RAD_RETRIES", "MODECFG",
! 1152: "CFG_NET4", "CFG_MASK4", "CFG_DNS4", "CFG_NBNS4", "CFG_DEFAULT_DOMAIN",
! 1153: "CFG_AUTH_SOURCE", "CFG_AUTH_GROUPS", "CFG_SYSTEM", "CFG_RADIUS",
! 1154: "CFG_PAM", "CFG_LDAP", "CFG_LOCAL", "CFG_NONE", "CFG_GROUP_SOURCE",
! 1155: "CFG_ACCOUNTING", "CFG_CONF_SOURCE", "CFG_MOTD", "CFG_POOL_SIZE",
! 1156: "CFG_AUTH_THROTTLE", "CFG_SPLIT_NETWORK", "CFG_SPLIT_LOCAL",
! 1157: "CFG_SPLIT_INCLUDE", "CFG_SPLIT_DNS", "CFG_PFS_GROUP", "CFG_SAVE_PASSWD",
! 1158: "RETRY", "RETRY_COUNTER", "RETRY_INTERVAL", "RETRY_PERSEND",
! 1159: "RETRY_PHASE1", "RETRY_PHASE2", "NATT_KA", "ALGORITHM_CLASS",
! 1160: "ALGORITHMTYPE", "STRENGTHTYPE", "SAINFO", "FROM", "REMOTE", "ANONYMOUS",
! 1161: "CLIENTADDR", "INHERIT", "REMOTE_ADDRESS", "EXCHANGE_MODE",
! 1162: "EXCHANGETYPE", "DOI", "DOITYPE", "SITUATION", "SITUATIONTYPE",
! 1163: "CERTIFICATE_TYPE", "CERTTYPE", "PEERS_CERTFILE", "CA_TYPE",
! 1164: "VERIFY_CERT", "SEND_CERT", "SEND_CR", "MATCH_EMPTY_CR",
! 1165: "IDENTIFIERTYPE", "IDENTIFIERQUAL", "MY_IDENTIFIER", "PEERS_IDENTIFIER",
! 1166: "VERIFY_IDENTIFIER", "DNSSEC", "CERT_X509", "CERT_PLAINRSA",
! 1167: "NONCE_SIZE", "DH_GROUP", "KEEPALIVE", "PASSIVE", "INITIAL_CONTACT",
! 1168: "NAT_TRAVERSAL", "REMOTE_FORCE_LEVEL", "PROPOSAL_CHECK",
! 1169: "PROPOSAL_CHECK_LEVEL", "GENERATE_POLICY", "GENERATE_LEVEL",
! 1170: "SUPPORT_PROXY", "PROPOSAL", "EXEC_PATH", "EXEC_COMMAND", "EXEC_SUCCESS",
! 1171: "EXEC_FAILURE", "GSS_ID", "GSS_ID_ENC", "GSS_ID_ENCTYPE",
! 1172: "COMPLEX_BUNDLE", "DPD", "DPD_DELAY", "DPD_RETRY", "DPD_MAXFAIL",
! 1173: "PH1ID", "XAUTH_LOGIN", "WEAK_PHASE1_CHECK", "REKEY", "PREFIX", "PORT",
! 1174: "PORTANY", "UL_PROTO", "ANY", "IKE_FRAG", "ESP_FRAG", "MODE_CFG",
! 1175: "PFS_GROUP", "LIFETIME", "LIFETYPE_TIME", "LIFETYPE_BYTE", "STRENGTH",
! 1176: "REMOTEID", "SCRIPT", "PHASE1_UP", "PHASE1_DOWN", "PHASE1_DEAD",
! 1177: "NUMBER", "SWITCH", "BOOLEAN", "HEXSTRING", "QUOTEDSTRING", "ADDRSTRING",
! 1178: "ADDRRANGE", "UNITTYPE_BYTE", "UNITTYPE_KBYTES", "UNITTYPE_MBYTES",
! 1179: "UNITTYPE_TBYTES", "UNITTYPE_SEC", "UNITTYPE_MIN", "UNITTYPE_HOUR",
! 1180: "EOS", "BOC", "EOC", "COMMA", "$accept", "statements", "statement",
! 1181: "privsep_statement", "privsep_stmts", "privsep_stmt", "$@1", "$@2",
! 1182: "$@3", "$@4", "$@5", "path_statement", "$@6", "special_statement", "$@7",
! 1183: "include_statement", "pfkey_statement", "gssenc_statement",
! 1184: "logging_statement", "log_level", "padding_statement", "padding_stmts",
! 1185: "padding_stmt", "$@8", "$@9", "$@10", "$@11", "$@12", "listen_statement",
! 1186: "listen_stmts", "listen_stmt", "$@13", "$@14", "$@15", "$@16", "$@17",
! 1187: "$@18", "ike_addrinfo_port", "ike_port", "radcfg_statement", "$@19",
! 1188: "radcfg_stmts", "radcfg_stmt", "$@20", "$@21", "$@22", "$@23", "$@24",
! 1189: "$@25", "ldapcfg_statement", "$@26", "ldapcfg_stmts", "ldapcfg_stmt",
! 1190: "$@27", "$@28", "$@29", "$@30", "$@31", "$@32", "$@33", "$@34", "$@35",
! 1191: "$@36", "$@37", "$@38", "modecfg_statement", "modecfg_stmts",
! 1192: "modecfg_stmt", "$@39", "$@40", "$@41", "$@42", "$@43", "$@44", "$@45",
! 1193: "$@46", "$@47", "$@48", "$@49", "$@50", "$@51", "$@52", "$@53", "$@54",
! 1194: "$@55", "$@56", "$@57", "$@58", "$@59", "$@60", "$@61", "$@62", "$@63",
! 1195: "addrdnslist", "addrdns", "addrwinslist", "addrwins", "splitnetlist",
! 1196: "splitnet", "authgrouplist", "authgroup", "splitdnslist", "splitdns",
! 1197: "timer_statement", "timer_stmts", "timer_stmt", "$@64", "$@65", "$@66",
! 1198: "$@67", "$@68", "$@69", "sainfo_statement", "$@70", "$@71",
! 1199: "sainfo_name", "sainfo_id", "sainfo_param", "sainfo_specs",
! 1200: "sainfo_spec", "$@72", "$@73", "$@74", "$@75", "$@76", "algorithms",
! 1201: "$@77", "algorithm", "prefix", "port", "ul_proto", "keylength",
! 1202: "remote_statement", "$@78", "$@79", "$@80", "$@81", "remote_specs_block",
! 1203: "remote_index", "remote_specs", "remote_spec", "$@82", "$@83", "$@84",
! 1204: "$@85", "$@86", "$@87", "$@88", "$@89", "$@90", "$@91", "$@92", "$@93",
! 1205: "$@94", "$@95", "$@96", "$@97", "$@98", "$@99", "$@100", "$@101",
! 1206: "$@102", "$@103", "$@104", "$@105", "$@106", "$@107", "$@108", "$@109",
! 1207: "$@110", "$@111", "$@112", "$@113", "$@114", "$@115", "$@116", "$@117",
! 1208: "$@118", "$@119", "$@120", "$@121", "$@122", "$@123", "$@124", "$@125",
! 1209: "$@126", "$@127", "$@128", "exchange_types", "cert_spec", "$@129",
! 1210: "$@130", "dh_group_num", "identifierstring", "isakmpproposal_specs",
! 1211: "isakmpproposal_spec", "$@131", "$@132", "$@133", "$@134", "$@135",
! 1212: "unittype_time", "unittype_byte", 0
! 1213: };
! 1214: #endif
! 1215:
! 1216: # ifdef YYPRINT
! 1217: /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
! 1218: token YYLEX-NUM. */
! 1219: static const yytype_uint16 yytoknum[] =
! 1220: {
! 1221: 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
! 1222: 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
! 1223: 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
! 1224: 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
! 1225: 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
! 1226: 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
! 1227: 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
! 1228: 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
! 1229: 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
! 1230: 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
! 1231: 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
! 1232: 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
! 1233: 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
! 1234: 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
! 1235: 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
! 1236: 405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
! 1237: 415, 416, 417, 418, 419, 420, 421, 422, 423, 424,
! 1238: 425, 426, 427, 428
! 1239: };
! 1240: # endif
! 1241:
! 1242: /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
! 1243: static const yytype_uint16 yyr1[] =
! 1244: {
! 1245: 0, 174, 175, 175, 176, 176, 176, 176, 176, 176,
! 1246: 176, 176, 176, 176, 176, 176, 176, 176, 176, 177,
! 1247: 178, 178, 180, 179, 181, 179, 182, 179, 183, 179,
! 1248: 184, 179, 186, 185, 188, 187, 189, 190, 191, 192,
! 1249: 193, 194, 195, 195, 197, 196, 198, 196, 199, 196,
! 1250: 200, 196, 201, 196, 202, 203, 203, 205, 204, 206,
! 1251: 204, 207, 204, 208, 204, 209, 204, 210, 204, 211,
! 1252: 212, 212, 214, 213, 215, 215, 217, 216, 218, 216,
! 1253: 219, 216, 220, 216, 221, 216, 222, 216, 224, 223,
! 1254: 225, 225, 227, 226, 228, 226, 229, 226, 230, 226,
! 1255: 231, 226, 232, 226, 233, 226, 234, 226, 235, 226,
! 1256: 236, 226, 237, 226, 238, 226, 239, 240, 240, 242,
! 1257: 241, 243, 241, 241, 241, 244, 241, 245, 241, 246,
! 1258: 241, 247, 241, 248, 241, 249, 241, 250, 241, 251,
! 1259: 241, 252, 241, 253, 241, 254, 241, 255, 241, 256,
! 1260: 241, 257, 241, 258, 241, 259, 241, 260, 241, 261,
! 1261: 241, 262, 241, 263, 241, 264, 241, 265, 241, 266,
! 1262: 241, 267, 267, 268, 269, 269, 270, 271, 271, 272,
! 1263: 273, 273, 274, 275, 275, 276, 277, 278, 278, 280,
! 1264: 279, 281, 279, 282, 279, 283, 279, 284, 279, 285,
! 1265: 279, 287, 288, 286, 289, 289, 289, 289, 289, 289,
! 1266: 290, 290, 290, 291, 291, 291, 292, 292, 294, 293,
! 1267: 295, 293, 296, 293, 297, 293, 298, 293, 299, 300,
! 1268: 299, 301, 302, 302, 303, 303, 303, 304, 304, 304,
! 1269: 305, 305, 307, 306, 308, 306, 309, 306, 310, 306,
! 1270: 311, 312, 312, 313, 313, 315, 314, 316, 314, 317,
! 1271: 314, 318, 314, 314, 319, 314, 320, 314, 321, 314,
! 1272: 322, 314, 323, 314, 324, 314, 325, 314, 326, 314,
! 1273: 327, 314, 328, 314, 329, 314, 330, 314, 331, 314,
! 1274: 332, 314, 333, 314, 334, 314, 335, 314, 336, 314,
! 1275: 337, 314, 338, 314, 339, 314, 340, 314, 341, 314,
! 1276: 342, 314, 343, 314, 344, 314, 345, 314, 346, 314,
! 1277: 347, 314, 348, 314, 349, 314, 350, 314, 351, 314,
! 1278: 352, 314, 353, 314, 354, 314, 355, 314, 356, 314,
! 1279: 357, 314, 358, 314, 359, 314, 360, 314, 361, 314,
! 1280: 362, 362, 364, 363, 365, 363, 366, 366, 367, 367,
! 1281: 367, 368, 368, 370, 369, 371, 369, 372, 369, 373,
! 1282: 369, 374, 369, 375, 375, 375, 376, 376, 376, 376
! 1283: };
! 1284:
! 1285: /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
! 1286: static const yytype_uint8 yyr2[] =
! 1287: {
! 1288: 0, 2, 0, 2, 1, 1, 1, 1, 1, 1,
! 1289: 1, 1, 1, 1, 1, 1, 1, 1, 1, 4,
! 1290: 0, 2, 0, 4, 0, 4, 0, 4, 0, 4,
! 1291: 0, 4, 0, 5, 0, 4, 3, 3, 3, 3,
! 1292: 1, 4, 0, 2, 0, 4, 0, 4, 0, 4,
! 1293: 0, 4, 0, 4, 4, 0, 2, 0, 4, 0,
! 1294: 4, 0, 7, 0, 4, 0, 4, 0, 3, 2,
! 1295: 0, 1, 0, 5, 0, 2, 0, 5, 0, 6,
! 1296: 0, 5, 0, 6, 0, 4, 0, 4, 0, 5,
! 1297: 0, 2, 0, 4, 0, 4, 0, 4, 0, 4,
! 1298: 0, 4, 0, 4, 0, 4, 0, 4, 0, 4,
! 1299: 0, 4, 0, 4, 0, 4, 4, 0, 2, 0,
! 1300: 4, 0, 4, 3, 3, 0, 5, 0, 5, 0,
! 1301: 4, 0, 4, 0, 4, 0, 4, 0, 4, 0,
! 1302: 4, 0, 4, 0, 4, 0, 4, 0, 4, 0,
! 1303: 4, 0, 4, 0, 4, 0, 4, 0, 4, 0,
! 1304: 4, 0, 4, 0, 4, 0, 4, 0, 4, 0,
! 1305: 4, 1, 3, 1, 1, 3, 1, 1, 3, 2,
! 1306: 1, 3, 1, 1, 3, 1, 4, 0, 2, 0,
! 1307: 4, 0, 5, 0, 4, 0, 5, 0, 5, 0,
! 1308: 5, 0, 0, 8, 1, 2, 2, 2, 2, 2,
! 1309: 5, 6, 2, 0, 3, 2, 0, 2, 0, 4,
! 1310: 0, 4, 0, 6, 0, 6, 0, 4, 1, 0,
! 1311: 4, 2, 0, 1, 0, 1, 1, 1, 1, 1,
! 1312: 0, 1, 0, 6, 0, 4, 0, 6, 0, 4,
! 1313: 3, 2, 1, 0, 2, 0, 4, 0, 4, 0,
! 1314: 4, 0, 4, 2, 0, 4, 0, 5, 0, 5,
! 1315: 0, 4, 0, 5, 0, 4, 0, 4, 0, 4,
! 1316: 0, 4, 0, 5, 0, 6, 0, 4, 0, 5,
! 1317: 0, 6, 0, 4, 0, 4, 0, 4, 0, 4,
! 1318: 0, 4, 0, 4, 0, 4, 0, 5, 0, 5,
! 1319: 0, 5, 0, 4, 0, 4, 0, 4, 0, 4,
! 1320: 0, 4, 0, 4, 0, 4, 0, 4, 0, 4,
! 1321: 0, 4, 0, 4, 0, 4, 0, 4, 0, 4,
! 1322: 0, 4, 0, 6, 0, 4, 0, 6, 0, 5,
! 1323: 0, 2, 0, 5, 0, 4, 1, 1, 0, 1,
! 1324: 1, 0, 2, 0, 6, 0, 6, 0, 4, 0,
! 1325: 4, 0, 5, 1, 1, 1, 1, 1, 1, 1
! 1326: };
! 1327:
! 1328: /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
! 1329: STATE-NUM when YYTABLE doesn't specify something else to do. Zero
! 1330: means the default is an error. */
! 1331: static const yytype_uint16 yydefact[] =
! 1332: {
! 1333: 2, 0, 1, 0, 0, 0, 0, 0, 0, 0,
! 1334: 88, 72, 0, 0, 201, 0, 0, 0, 3, 4,
! 1335: 5, 18, 6, 7, 8, 9, 10, 11, 13, 12,
! 1336: 14, 15, 16, 17, 20, 0, 0, 0, 40, 0,
! 1337: 42, 55, 0, 0, 117, 187, 0, 70, 244, 70,
! 1338: 252, 248, 0, 34, 0, 32, 36, 37, 39, 0,
! 1339: 0, 90, 74, 0, 0, 204, 0, 213, 0, 71,
! 1340: 251, 0, 0, 69, 0, 0, 38, 0, 0, 0,
! 1341: 0, 19, 21, 0, 0, 0, 0, 0, 0, 41,
! 1342: 43, 0, 0, 67, 0, 54, 56, 0, 0, 0,
! 1343: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 1344: 0, 0, 0, 0, 0, 0, 116, 118, 0, 0,
! 1345: 0, 0, 0, 0, 186, 188, 205, 206, 212, 232,
! 1346: 0, 0, 0, 207, 208, 209, 242, 253, 245, 246,
! 1347: 249, 35, 24, 22, 28, 26, 30, 33, 44, 46,
! 1348: 48, 50, 52, 57, 59, 0, 65, 63, 0, 0,
! 1349: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 1350: 89, 91, 0, 0, 0, 0, 73, 75, 119, 121,
! 1351: 173, 0, 171, 176, 0, 174, 131, 133, 135, 137,
! 1352: 139, 182, 141, 180, 143, 145, 149, 151, 153, 147,
! 1353: 165, 167, 163, 169, 155, 161, 0, 0, 185, 129,
! 1354: 183, 157, 159, 189, 0, 193, 0, 0, 0, 233,
! 1355: 232, 234, 215, 358, 216, 0, 0, 0, 0, 0,
! 1356: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 1357: 68, 0, 0, 0, 94, 96, 92, 98, 102, 104,
! 1358: 100, 106, 108, 110, 112, 114, 0, 0, 84, 86,
! 1359: 0, 0, 123, 0, 124, 0, 0, 0, 0, 0,
! 1360: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 1361: 0, 0, 0, 0, 0, 0, 125, 177, 127, 0,
! 1362: 0, 0, 0, 0, 373, 374, 375, 191, 0, 195,
! 1363: 197, 199, 234, 235, 236, 0, 360, 359, 214, 202,
! 1364: 243, 0, 257, 0, 0, 0, 0, 0, 0, 0,
! 1365: 0, 0, 0, 0, 0, 0, 296, 0, 0, 0,
! 1366: 0, 0, 0, 348, 0, 0, 0, 0, 0, 358,
! 1367: 0, 0, 0, 0, 0, 0, 0, 250, 254, 247,
! 1368: 25, 23, 29, 27, 31, 45, 47, 49, 51, 53,
! 1369: 58, 60, 66, 0, 64, 0, 0, 0, 0, 0,
! 1370: 0, 0, 0, 0, 0, 0, 0, 0, 76, 0,
! 1371: 80, 0, 0, 120, 122, 172, 175, 132, 134, 136,
! 1372: 138, 140, 142, 181, 144, 146, 150, 152, 154, 148,
! 1373: 166, 168, 164, 170, 156, 162, 179, 0, 0, 0,
! 1374: 130, 184, 158, 160, 190, 0, 194, 0, 0, 0,
! 1375: 0, 238, 239, 237, 210, 226, 0, 0, 0, 0,
! 1376: 217, 255, 350, 259, 261, 0, 0, 263, 270, 0,
! 1377: 0, 264, 0, 274, 276, 278, 280, 358, 358, 292,
! 1378: 294, 0, 298, 322, 326, 324, 344, 318, 316, 320,
! 1379: 0, 328, 330, 332, 334, 340, 286, 314, 338, 336,
! 1380: 302, 300, 304, 312, 0, 0, 0, 61, 95, 97,
! 1381: 93, 99, 103, 105, 101, 107, 109, 111, 113, 115,
! 1382: 78, 0, 82, 0, 85, 87, 178, 126, 128, 192,
! 1383: 196, 198, 200, 211, 0, 356, 357, 218, 0, 0,
! 1384: 220, 203, 0, 0, 0, 0, 0, 354, 0, 266,
! 1385: 268, 0, 272, 0, 0, 0, 0, 358, 282, 358,
! 1386: 288, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 1387: 0, 0, 361, 0, 0, 0, 0, 0, 0, 0,
! 1388: 0, 0, 0, 0, 0, 0, 0, 0, 306, 308,
! 1389: 310, 0, 0, 77, 0, 81, 240, 0, 228, 0,
! 1390: 0, 0, 0, 256, 351, 258, 260, 262, 352, 0,
! 1391: 271, 0, 0, 265, 0, 275, 277, 279, 281, 284,
! 1392: 0, 290, 0, 293, 295, 297, 299, 323, 327, 325,
! 1393: 345, 319, 317, 321, 0, 329, 331, 333, 335, 341,
! 1394: 287, 315, 339, 337, 303, 301, 305, 313, 342, 376,
! 1395: 377, 378, 379, 346, 0, 0, 0, 62, 79, 83,
! 1396: 241, 231, 227, 0, 219, 222, 224, 221, 0, 355,
! 1397: 267, 269, 273, 0, 283, 0, 289, 0, 0, 0,
! 1398: 0, 349, 362, 0, 0, 307, 309, 311, 0, 0,
! 1399: 0, 353, 285, 291, 240, 367, 369, 0, 0, 343,
! 1400: 347, 230, 223, 225, 371, 0, 0, 0, 0, 0,
! 1401: 368, 370, 363, 365, 372, 0, 0, 364, 366
! 1402: };
! 1403:
! 1404: /* YYDEFGOTO[NTERM-NUM]. */
! 1405: static const yytype_int16 yydefgoto[] =
! 1406: {
! 1407: -1, 1, 18, 19, 54, 82, 229, 228, 231, 230,
! 1408: 232, 20, 83, 21, 77, 22, 23, 24, 25, 39,
! 1409: 26, 59, 90, 233, 234, 235, 236, 237, 27, 60,
! 1410: 96, 238, 239, 561, 243, 241, 155, 50, 70, 28,
! 1411: 43, 98, 177, 491, 562, 493, 564, 381, 382, 29,
! 1412: 42, 97, 171, 367, 365, 366, 368, 371, 369, 370,
! 1413: 372, 373, 374, 375, 376, 30, 63, 117, 260, 261,
! 1414: 408, 409, 289, 266, 267, 268, 269, 270, 271, 273,
! 1415: 274, 278, 275, 276, 277, 283, 291, 292, 284, 281,
! 1416: 279, 280, 282, 181, 182, 184, 185, 286, 287, 192,
! 1417: 193, 209, 210, 31, 64, 125, 293, 415, 298, 417,
! 1418: 418, 419, 32, 46, 429, 67, 68, 132, 309, 430,
! 1419: 569, 572, 659, 660, 504, 567, 633, 568, 221, 305,
! 1420: 424, 631, 33, 225, 72, 227, 75, 138, 51, 226,
! 1421: 348, 512, 432, 514, 515, 521, 581, 582, 518, 584,
! 1422: 523, 524, 525, 526, 590, 643, 548, 592, 645, 531,
! 1423: 532, 451, 534, 553, 552, 554, 624, 625, 626, 555,
! 1424: 549, 540, 539, 541, 535, 537, 536, 543, 544, 545,
! 1425: 546, 551, 550, 547, 653, 538, 654, 460, 513, 437,
! 1426: 638, 579, 507, 308, 604, 652, 685, 686, 675, 676,
! 1427: 679, 297, 623
! 1428: };
! 1429:
! 1430: /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
! 1431: STATE-NUM. */
! 1432: #define YYPACT_NINF -535
! 1433: static const yytype_int16 yypact[] =
! 1434: {
! 1435: -535, 42, -535, -101, 87, -53, -14, 144, 9, 24,
! 1436: -535, -535, 26, 36, -535, -43, 65, 7, -535, -535,
! 1437: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1438: -535, -535, -535, -535, -535, 40, 35, 39, -535, 48,
! 1439: -535, -535, 53, 54, -535, -535, 2, 72, 134, 72,
! 1440: -535, 143, 62, -535, 3, -535, -535, -535, -535, -4,
! 1441: -5, -535, -535, 29, -9, 22, -113, 49, 45, -535,
! 1442: -535, 74, 68, -535, -45, 68, -535, 66, -23, -13,
! 1443: 81, -535, -535, 70, 85, 86, 88, 89, 98, -535,
! 1444: -535, 84, 84, -535, -8, -535, -535, -6, -7, 95,
! 1445: 97, 102, 104, 99, 96, 106, 4, 56, 79, 107,
! 1446: 101, 112, 75, 110, 115, 116, -535, -535, 118, 119,
! 1447: 120, 121, 122, 123, -535, -535, -535, -535, -535, -78,
! 1448: 124, 171, 109, -535, -535, -535, -535, -535, -535, -535,
! 1449: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1450: -535, -535, -535, -535, -535, 111, -535, 125, 126, 127,
! 1451: 131, 128, 130, 132, 136, 135, 137, 138, 139, 140,
! 1452: -535, -535, 141, 142, 147, 148, -535, -535, -535, -535,
! 1453: -535, 145, 133, -535, 146, 149, -535, -535, -535, -535,
! 1454: -535, -535, -535, 150, -535, -535, -535, -535, -535, -535,
! 1455: -535, -535, -535, -535, -535, -535, 151, 151, -535, -535,
! 1456: 152, -535, -535, -535, 14, -535, 14, 14, 14, -535,
! 1457: 153, 34, -535, 1, -535, 68, 117, 68, 154, 156,
! 1458: 157, 158, 159, 160, 161, 162, 163, 164, 165, 166,
! 1459: -535, 167, 178, 169, -535, -535, -535, -535, -535, -535,
! 1460: -535, -535, -535, -535, -535, -535, -2, -1, -535, -535,
! 1461: 172, 173, -535, 102, -535, 104, 174, 175, 176, 177,
! 1462: 179, 180, 106, 181, 182, 183, 185, 186, 187, 188,
! 1463: 189, 190, 191, 192, 193, 170, 168, -535, 168, 194,
! 1464: 110, 195, 196, 197, -535, -535, -535, -535, 198, -535,
! 1465: -535, -535, 34, -535, -535, -3, -535, -535, -535, -20,
! 1466: -535, 84, -535, 204, 213, 80, -35, 200, 212, 214,
! 1467: 215, 216, 208, 209, 217, 155, -535, 218, 219, -57,
! 1468: 201, -75, 220, -535, 221, 223, 224, 225, 226, 1,
! 1469: 227, -46, -21, 229, 230, 41, 210, -535, -535, -535,
! 1470: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1471: -535, -535, -535, 232, -535, 222, 228, 231, 233, 234,
! 1472: 235, 236, 237, 238, 239, 240, 241, 242, -535, 252,
! 1473: -535, 243, 244, -535, -535, -535, -535, -535, -535, -535,
! 1474: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1475: -535, -535, -535, -535, -535, -535, -535, 151, 245, 246,
! 1476: -535, -535, -535, -535, -535, 247, -535, 248, 249, 250,
! 1477: -3, -535, -535, -535, -535, -535, -37, 43, 265, 211,
! 1478: -535, -535, -535, -535, -535, 262, 263, -535, -535, 264,
! 1479: 266, -535, 267, -535, -535, -535, -535, -59, -56, -535,
! 1480: -535, -37, -535, -535, -535, -535, -535, -535, -535, -535,
! 1481: 254, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1482: -535, -535, -535, -535, 272, 273, 31, -535, -535, -535,
! 1483: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1484: -535, 260, -535, 261, -535, -535, -535, -535, -535, -535,
! 1485: -535, -535, -535, -535, 270, -535, -535, -535, 276, 277,
! 1486: -535, -535, 268, -49, 269, 271, 274, -535, 275, -535,
! 1487: -535, 278, -535, 279, 280, 281, 282, 1, -535, 1,
! 1488: -535, 283, 284, 285, 286, 287, 288, 289, 290, 292,
! 1489: 293, 294, -535, 295, 296, 297, 298, 299, 300, 301,
! 1490: 302, 303, 304, 305, 306, 307, 14, 13, -535, -535,
! 1491: -535, 308, 309, -535, 310, -535, 291, 311, 312, 313,
! 1492: 14, 13, 314, -535, -535, -535, -535, -535, -535, 316,
! 1493: -535, 317, 318, -535, 319, -535, -535, -535, -535, -535,
! 1494: 320, -535, 321, -535, -535, -535, -535, -535, -535, -535,
! 1495: -535, -535, -535, -535, -27, -535, -535, -535, -535, -535,
! 1496: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1497: -535, -535, -535, -535, 322, 323, 324, -535, -535, -535,
! 1498: -535, -535, -535, 325, -535, -535, -535, -535, 326, -535,
! 1499: -535, -535, -535, 327, -535, 329, -535, 315, -37, 335,
! 1500: 50, -535, -535, 330, 331, -535, -535, -535, 270, 332,
! 1501: 333, -535, -535, -535, 291, -535, -535, 348, 349, -535,
! 1502: -535, -535, -535, -535, -535, 336, 337, 14, 13, 338,
! 1503: -535, -535, -535, -535, -535, 339, 340, -535, -535
! 1504: };
! 1505:
! 1506: /* YYPGOTO[NTERM-NUM]. */
! 1507: static const yytype_int16 yypgoto[] =
! 1508: {
! 1509: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1510: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1511: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1512: -535, -535, -535, -535, -535, -535, -535, -88, 341, -535,
! 1513: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1514: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1515: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1516: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1517: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1518: -535, -535, -535, 19, -535, 52, -535, 113, -111, 47,
! 1519: -535, 23, -535, -535, -535, -535, -535, -535, -535, -535,
! 1520: -535, -535, -535, -535, -535, -535, 92, -535, -535, -535,
! 1521: -535, -535, -535, -535, -535, -344, -535, -535, 328, 93,
! 1522: -99, -278, -535, -535, -535, -535, -535, -55, 361, -535,
! 1523: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1524: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1525: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1526: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1527: -535, -535, -535, -535, -535, -535, -535, -535, -535, -535,
! 1528: -535, -535, -446, -333, -535, -535, -535, -535, -535, -535,
! 1529: -535, -216, -534
! 1530: };
! 1531:
! 1532: /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
! 1533: positive, shift that token. If negative, reduce the rule which
! 1534: number is the opposite. If zero, do what YYDEFACT says.
! 1535: If YYTABLE_NINF, syntax error. */
! 1536: #define YYTABLE_NINF -230
! 1537: static const yytype_int16 yytable[] =
! 1538: {
! 1539: 299, 300, 301, 153, 154, 533, 466, 78, 79, 80,
! 1540: 84, 85, 86, 87, 88, 91, 92, 156, 93, 94,
! 1541: 140, 158, 159, 160, 161, 162, 163, 164, 165, 166,
! 1542: 167, 168, 169, 172, 173, 174, 175, 636, 47, 574,
! 1543: 47, 505, 2, 527, 457, 3, 529, 128, 129, 4,
! 1544: 647, 5, 6, 7, 130, 8, 194, 425, 454, 195,
! 1545: 219, 9, 118, 119, 120, 121, 122, 123, 10, 468,
! 1546: 34, 438, 439, 440, 99, 100, 101, 102, 103, 104,
! 1547: 105, 11, 458, 648, 220, 65, 12, 106, 107, 108,
! 1548: 109, 110, 111, 112, 470, 35, 113, 114, 115, 649,
! 1549: 455, 306, 307, 66, 306, 307, 126, 36, 196, 197,
! 1550: 198, 469, 13, 199, 528, 530, 49, 48, 49, 506,
! 1551: 650, 575, 14, 66, 15, 441, 426, 427, 133, 134,
! 1552: 131, 428, 200, 142, 201, 202, 471, 143, 421, 422,
! 1553: 206, 207, 37, 144, 683, 651, 66, 145, 187, 188,
! 1554: 189, 190, 157, 423, 377, 379, 38, 127, 378, 380,
! 1555: 135, 306, 307, 124, 53, 176, 170, 95, 89, 16,
! 1556: 310, 17, 349, 303, 304, 81, 619, 620, 621, 622,
! 1557: 40, 294, 295, 296, 558, 559, 560, 435, 436, 474,
! 1558: 475, 508, 509, 52, 589, 41, 591, 44, 667, 668,
! 1559: 55, 116, 665, 311, 312, 56, 313, 45, 314, 57,
! 1560: 315, 69, 316, 317, 318, 319, 320, 321, 58, 71,
! 1561: 322, 323, 324, 431, 61, 62, 325, 326, 74, 327,
! 1562: 328, 329, 76, 330, 136, 331, 141, 332, 333, 137,
! 1563: 147, 146, 148, 149, 150, 49, 151, 334, 335, 336,
! 1564: 337, 338, 339, 340, 341, 152, 178, 204, 179, 186,
! 1565: 342, 343, 344, 180, 345, 183, 191, 203, 205, 346,
! 1566: 208, 211, 223, 212, 213, 214, 215, 216, 217, 218,
! 1567: 224, 240, 385, 245, 222, 242, 244, 246, 247, 347,
! 1568: 248, 219, 249, 250, 433, 251, 496, 252, 253, 254,
! 1569: 255, 256, 257, 258, 259, 434, 263, 442, 406, 447,
! 1570: 448, 450, 285, 411, 671, 262, 264, 386, 456, 393,
! 1571: 288, 503, 265, 272, 350, 290, 351, 352, 353, 354,
! 1572: 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
! 1573: 618, 407, 383, 384, 387, 388, 389, 390, 566, 391,
! 1574: 392, 394, 395, 396, 635, 397, 398, 399, 400, 401,
! 1575: 402, 403, 404, 405, 410, 412, 413, 414, 416, 443,
! 1576: 476, 444, 445, 446, 449, 452, 453, 459, 461, 462,
! 1577: 463, 464, 465, 511, 467, 472, 674, 473, 477, 0,
! 1578: 73, 0, 478, 664, 0, 420, 0, 0, 479, 0,
! 1579: 0, 480, 490, 481, 482, 483, 484, 485, 486, 487,
! 1580: 488, 489, 492, 494, 495, 497, 498, 499, 500, 501,
! 1581: 502, 510, 516, 517, 519, 542, 520, 522, 556, 557,
! 1582: 563, 565, 570, 571, 578, 139, 0, 0, 573, 576,
! 1583: 0, 577, 0, 0, 0, 580, 0, 630, 583, 585,
! 1584: 586, 587, 588, 593, 594, 595, 596, 597, 598, 599,
! 1585: 600, 682, 601, 602, 603, 605, 606, 607, 608, 609,
! 1586: 610, 611, 612, 613, 614, 615, 616, 617, 627, 628,
! 1587: 629, 632, 0, 634, 637, -229, 639, 640, 641, 642,
! 1588: 644, 646, 655, 656, 657, 666, 661, 662, 658, 663,
! 1589: 669, 670, 672, 673, 677, 678, 680, 681, 684, 687,
! 1590: 688, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 1591: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 1592: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 1593: 0, 0, 0, 0, 0, 0, 0, 0, 302
! 1594: };
! 1595:
! 1596: static const yytype_int16 yycheck[] =
! 1597: {
! 1598: 216, 217, 218, 91, 92, 451, 339, 4, 5, 6,
! 1599: 14, 15, 16, 17, 18, 20, 21, 25, 23, 24,
! 1600: 75, 27, 28, 29, 30, 31, 32, 33, 34, 35,
! 1601: 36, 37, 38, 40, 41, 42, 43, 571, 83, 88,
! 1602: 83, 78, 0, 102, 119, 3, 102, 160, 161, 7,
! 1603: 77, 9, 10, 11, 5, 13, 52, 77, 115, 55,
! 1604: 138, 19, 71, 72, 73, 74, 75, 76, 26, 115,
! 1605: 171, 106, 107, 108, 45, 46, 47, 48, 49, 50,
! 1606: 51, 39, 157, 110, 162, 83, 44, 58, 59, 60,
! 1607: 61, 62, 63, 64, 115, 8, 67, 68, 69, 126,
! 1608: 157, 160, 161, 101, 160, 161, 84, 160, 52, 53,
! 1609: 54, 157, 70, 57, 447, 448, 161, 160, 161, 156,
! 1610: 147, 170, 80, 101, 82, 160, 146, 147, 83, 84,
! 1611: 81, 151, 53, 156, 55, 56, 157, 160, 141, 142,
! 1612: 65, 66, 156, 156, 678, 172, 101, 160, 52, 53,
! 1613: 54, 55, 160, 156, 156, 156, 12, 65, 160, 160,
! 1614: 68, 160, 161, 172, 157, 172, 172, 172, 172, 127,
! 1615: 225, 129, 227, 139, 140, 172, 163, 164, 165, 166,
! 1616: 171, 167, 168, 169, 153, 154, 155, 107, 108, 148,
! 1617: 149, 148, 149, 128, 527, 171, 529, 171, 148, 149,
! 1618: 160, 172, 648, 86, 87, 170, 89, 171, 91, 170,
! 1619: 93, 139, 95, 96, 97, 98, 99, 100, 170, 85,
! 1620: 103, 104, 105, 311, 171, 171, 109, 110, 85, 112,
! 1621: 113, 114, 170, 116, 160, 118, 170, 120, 121, 171,
! 1622: 170, 160, 157, 157, 156, 161, 157, 130, 131, 132,
! 1623: 133, 134, 135, 136, 137, 157, 161, 156, 161, 160,
! 1624: 143, 144, 145, 161, 147, 161, 160, 160, 156, 152,
! 1625: 160, 156, 101, 157, 156, 156, 156, 156, 156, 156,
! 1626: 171, 170, 263, 156, 160, 160, 160, 156, 160, 172,
! 1627: 160, 138, 160, 157, 90, 160, 407, 160, 160, 160,
! 1628: 160, 160, 160, 156, 156, 92, 173, 107, 138, 101,
! 1629: 101, 156, 161, 290, 658, 170, 170, 265, 117, 272,
! 1630: 207, 420, 173, 173, 170, 173, 170, 170, 170, 170,
! 1631: 170, 170, 170, 170, 170, 170, 170, 170, 160, 170,
! 1632: 556, 173, 170, 170, 170, 170, 170, 170, 78, 170,
! 1633: 170, 170, 170, 170, 570, 170, 170, 170, 170, 170,
! 1634: 170, 170, 170, 170, 170, 170, 170, 170, 170, 157,
! 1635: 160, 157, 157, 157, 157, 157, 157, 157, 157, 156,
! 1636: 156, 156, 156, 172, 157, 156, 664, 157, 156, -1,
! 1637: 49, -1, 170, 78, -1, 302, -1, -1, 170, -1,
! 1638: -1, 170, 160, 170, 170, 170, 170, 170, 170, 170,
! 1639: 170, 170, 160, 170, 170, 170, 170, 170, 170, 170,
! 1640: 170, 156, 160, 160, 160, 171, 160, 160, 156, 156,
! 1641: 170, 170, 156, 156, 160, 74, -1, -1, 170, 170,
! 1642: -1, 170, -1, -1, -1, 170, -1, 156, 170, 170,
! 1643: 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
! 1644: 170, 677, 170, 170, 170, 170, 170, 170, 170, 170,
! 1645: 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
! 1646: 170, 170, -1, 170, 170, 173, 170, 170, 170, 170,
! 1647: 170, 170, 170, 170, 170, 160, 170, 170, 173, 170,
! 1648: 170, 170, 170, 170, 156, 156, 170, 170, 170, 170,
! 1649: 170, -1, -1, -1, -1, -1, -1, -1, -1, -1,
! 1650: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
! 1651: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
! 1652: -1, -1, -1, -1, -1, -1, -1, -1, 220
! 1653: };
! 1654:
! 1655: /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
! 1656: symbol of state STATE-NUM. */
! 1657: static const yytype_uint16 yystos[] =
! 1658: {
! 1659: 0, 175, 0, 3, 7, 9, 10, 11, 13, 19,
! 1660: 26, 39, 44, 70, 80, 82, 127, 129, 176, 177,
! 1661: 185, 187, 189, 190, 191, 192, 194, 202, 213, 223,
! 1662: 239, 277, 286, 306, 171, 8, 160, 156, 12, 193,
! 1663: 171, 171, 224, 214, 171, 171, 287, 83, 160, 161,
! 1664: 211, 312, 128, 157, 178, 160, 170, 170, 170, 195,
! 1665: 203, 171, 171, 240, 278, 83, 101, 289, 290, 139,
! 1666: 212, 85, 308, 212, 85, 310, 170, 188, 4, 5,
! 1667: 6, 172, 179, 186, 14, 15, 16, 17, 18, 172,
! 1668: 196, 20, 21, 23, 24, 172, 204, 225, 215, 45,
! 1669: 46, 47, 48, 49, 50, 51, 58, 59, 60, 61,
! 1670: 62, 63, 64, 67, 68, 69, 172, 241, 71, 72,
! 1671: 73, 74, 75, 76, 172, 279, 84, 290, 160, 161,
! 1672: 5, 81, 291, 83, 84, 290, 160, 171, 311, 312,
! 1673: 311, 170, 156, 160, 156, 160, 160, 170, 157, 157,
! 1674: 156, 157, 157, 211, 211, 210, 25, 160, 27, 28,
! 1675: 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
! 1676: 172, 226, 40, 41, 42, 43, 172, 216, 161, 161,
! 1677: 161, 267, 268, 161, 269, 270, 160, 52, 53, 54,
! 1678: 55, 160, 273, 274, 52, 55, 52, 53, 54, 57,
! 1679: 53, 55, 56, 160, 156, 156, 65, 66, 160, 275,
! 1680: 276, 156, 157, 156, 156, 156, 156, 156, 156, 138,
! 1681: 162, 302, 160, 101, 171, 307, 313, 309, 181, 180,
! 1682: 183, 182, 184, 197, 198, 199, 200, 201, 205, 206,
! 1683: 170, 209, 160, 208, 160, 156, 156, 160, 160, 160,
! 1684: 157, 160, 160, 160, 160, 160, 160, 160, 156, 156,
! 1685: 242, 243, 170, 173, 170, 173, 247, 248, 249, 250,
! 1686: 251, 252, 173, 253, 254, 256, 257, 258, 255, 264,
! 1687: 265, 263, 266, 259, 262, 161, 271, 272, 271, 246,
! 1688: 173, 260, 261, 280, 167, 168, 169, 375, 282, 375,
! 1689: 375, 375, 302, 139, 140, 303, 160, 161, 367, 292,
! 1690: 311, 86, 87, 89, 91, 93, 95, 96, 97, 98,
! 1691: 99, 100, 103, 104, 105, 109, 110, 112, 113, 114,
! 1692: 116, 118, 120, 121, 130, 131, 132, 133, 134, 135,
! 1693: 136, 137, 143, 144, 145, 147, 152, 172, 314, 311,
! 1694: 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
! 1695: 170, 170, 170, 160, 170, 228, 229, 227, 230, 232,
! 1696: 233, 231, 234, 235, 236, 237, 238, 156, 160, 156,
! 1697: 160, 221, 222, 170, 170, 267, 269, 170, 170, 170,
! 1698: 170, 170, 170, 273, 170, 170, 170, 170, 170, 170,
! 1699: 170, 170, 170, 170, 170, 170, 138, 173, 244, 245,
! 1700: 170, 275, 170, 170, 170, 281, 170, 283, 284, 285,
! 1701: 303, 141, 142, 156, 304, 77, 146, 147, 151, 288,
! 1702: 293, 211, 316, 90, 92, 107, 108, 363, 106, 107,
! 1703: 108, 160, 107, 157, 157, 157, 157, 101, 101, 157,
! 1704: 156, 335, 157, 157, 115, 157, 117, 119, 157, 157,
! 1705: 361, 157, 156, 156, 156, 156, 367, 157, 115, 157,
! 1706: 115, 157, 156, 157, 148, 149, 160, 156, 170, 170,
! 1707: 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
! 1708: 160, 217, 160, 219, 170, 170, 272, 170, 170, 170,
! 1709: 170, 170, 170, 304, 298, 78, 156, 366, 148, 149,
! 1710: 156, 172, 315, 362, 317, 318, 160, 160, 322, 160,
! 1711: 160, 319, 160, 324, 325, 326, 327, 102, 367, 102,
! 1712: 367, 333, 334, 366, 336, 348, 350, 349, 359, 346,
! 1713: 345, 347, 171, 351, 352, 353, 354, 357, 330, 344,
! 1714: 356, 355, 338, 337, 339, 343, 156, 156, 153, 154,
! 1715: 155, 207, 218, 170, 220, 170, 78, 299, 301, 294,
! 1716: 156, 156, 295, 170, 88, 170, 170, 170, 160, 365,
! 1717: 170, 320, 321, 170, 323, 170, 170, 170, 170, 367,
! 1718: 328, 367, 331, 170, 170, 170, 170, 170, 170, 170,
! 1719: 170, 170, 170, 170, 368, 170, 170, 170, 170, 170,
! 1720: 170, 170, 170, 170, 170, 170, 170, 170, 375, 163,
! 1721: 164, 165, 166, 376, 340, 341, 342, 170, 170, 170,
! 1722: 156, 305, 170, 300, 170, 375, 376, 170, 364, 170,
! 1723: 170, 170, 170, 329, 170, 332, 170, 77, 110, 126,
! 1724: 147, 172, 369, 358, 360, 170, 170, 170, 173, 296,
! 1725: 297, 170, 170, 170, 78, 366, 160, 148, 149, 170,
! 1726: 170, 299, 170, 170, 305, 372, 373, 156, 156, 374,
! 1727: 170, 170, 375, 376, 170, 370, 371, 170, 170
! 1728: };
! 1729:
! 1730: #define yyerrok (yyerrstatus = 0)
! 1731: #define yyclearin (yychar = YYEMPTY)
! 1732: #define YYEMPTY (-2)
! 1733: #define YYEOF 0
! 1734:
! 1735: #define YYACCEPT goto yyacceptlab
! 1736: #define YYABORT goto yyabortlab
! 1737: #define YYERROR goto yyerrorlab
! 1738:
! 1739:
! 1740: /* Like YYERROR except do call yyerror. This remains here temporarily
! 1741: to ease the transition to the new meaning of YYERROR, for GCC.
! 1742: Once GCC version 2 has supplanted version 1, this can go. */
! 1743:
! 1744: #define YYFAIL goto yyerrlab
! 1745:
! 1746: #define YYRECOVERING() (!!yyerrstatus)
! 1747:
! 1748: #define YYBACKUP(Token, Value) \
! 1749: do \
! 1750: if (yychar == YYEMPTY && yylen == 1) \
! 1751: { \
! 1752: yychar = (Token); \
! 1753: yylval = (Value); \
! 1754: yytoken = YYTRANSLATE (yychar); \
! 1755: YYPOPSTACK (1); \
! 1756: goto yybackup; \
! 1757: } \
! 1758: else \
! 1759: { \
! 1760: yyerror (YY_("syntax error: cannot back up")); \
! 1761: YYERROR; \
! 1762: } \
! 1763: while (YYID (0))
! 1764:
! 1765:
! 1766: #define YYTERROR 1
! 1767: #define YYERRCODE 256
! 1768:
! 1769:
! 1770: /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
! 1771: If N is 0, then set CURRENT to the empty location which ends
! 1772: the previous symbol: RHS[0] (always defined). */
! 1773:
! 1774: #define YYRHSLOC(Rhs, K) ((Rhs)[K])
! 1775: #ifndef YYLLOC_DEFAULT
! 1776: # define YYLLOC_DEFAULT(Current, Rhs, N) \
! 1777: do \
! 1778: if (YYID (N)) \
! 1779: { \
! 1780: (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
! 1781: (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
! 1782: (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
! 1783: (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
! 1784: } \
! 1785: else \
! 1786: { \
! 1787: (Current).first_line = (Current).last_line = \
! 1788: YYRHSLOC (Rhs, 0).last_line; \
! 1789: (Current).first_column = (Current).last_column = \
! 1790: YYRHSLOC (Rhs, 0).last_column; \
! 1791: } \
! 1792: while (YYID (0))
! 1793: #endif
! 1794:
! 1795:
! 1796: /* YY_LOCATION_PRINT -- Print the location on the stream.
! 1797: This macro was not mandated originally: define only if we know
! 1798: we won't break user code: when these are the locations we know. */
! 1799:
! 1800: #ifndef YY_LOCATION_PRINT
! 1801: # if YYLTYPE_IS_TRIVIAL
! 1802: # define YY_LOCATION_PRINT(File, Loc) \
! 1803: fprintf (File, "%d.%d-%d.%d", \
! 1804: (Loc).first_line, (Loc).first_column, \
! 1805: (Loc).last_line, (Loc).last_column)
! 1806: # else
! 1807: # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
! 1808: # endif
! 1809: #endif
! 1810:
! 1811:
! 1812: /* YYLEX -- calling `yylex' with the right arguments. */
! 1813:
! 1814: #ifdef YYLEX_PARAM
! 1815: # define YYLEX yylex (YYLEX_PARAM)
! 1816: #else
! 1817: # define YYLEX yylex ()
! 1818: #endif
! 1819:
! 1820: /* Enable debugging if requested. */
! 1821: #if YYDEBUG
! 1822:
! 1823: # ifndef YYFPRINTF
! 1824: # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
! 1825: # define YYFPRINTF fprintf
! 1826: # endif
! 1827:
! 1828: # define YYDPRINTF(Args) \
! 1829: do { \
! 1830: if (yydebug) \
! 1831: YYFPRINTF Args; \
! 1832: } while (YYID (0))
! 1833:
! 1834: # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
! 1835: do { \
! 1836: if (yydebug) \
! 1837: { \
! 1838: YYFPRINTF (stderr, "%s ", Title); \
! 1839: yy_symbol_print (stderr, \
! 1840: Type, Value); \
! 1841: YYFPRINTF (stderr, "\n"); \
! 1842: } \
! 1843: } while (YYID (0))
! 1844:
! 1845:
! 1846: /*--------------------------------.
! 1847: | Print this symbol on YYOUTPUT. |
! 1848: `--------------------------------*/
! 1849:
! 1850: /*ARGSUSED*/
! 1851: #if (defined __STDC__ || defined __C99__FUNC__ \
! 1852: || defined __cplusplus || defined _MSC_VER)
! 1853: static void
! 1854: yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
! 1855: #else
! 1856: static void
! 1857: yy_symbol_value_print (yyoutput, yytype, yyvaluep)
! 1858: FILE *yyoutput;
! 1859: int yytype;
! 1860: YYSTYPE const * const yyvaluep;
! 1861: #endif
! 1862: {
! 1863: if (!yyvaluep)
! 1864: return;
! 1865: # ifdef YYPRINT
! 1866: if (yytype < YYNTOKENS)
! 1867: YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
! 1868: # else
! 1869: YYUSE (yyoutput);
! 1870: # endif
! 1871: switch (yytype)
! 1872: {
! 1873: default:
! 1874: break;
! 1875: }
! 1876: }
! 1877:
! 1878:
! 1879: /*--------------------------------.
! 1880: | Print this symbol on YYOUTPUT. |
! 1881: `--------------------------------*/
! 1882:
! 1883: #if (defined __STDC__ || defined __C99__FUNC__ \
! 1884: || defined __cplusplus || defined _MSC_VER)
! 1885: static void
! 1886: yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
! 1887: #else
! 1888: static void
! 1889: yy_symbol_print (yyoutput, yytype, yyvaluep)
! 1890: FILE *yyoutput;
! 1891: int yytype;
! 1892: YYSTYPE const * const yyvaluep;
! 1893: #endif
! 1894: {
! 1895: if (yytype < YYNTOKENS)
! 1896: YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
! 1897: else
! 1898: YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
! 1899:
! 1900: yy_symbol_value_print (yyoutput, yytype, yyvaluep);
! 1901: YYFPRINTF (yyoutput, ")");
! 1902: }
! 1903:
! 1904: /*------------------------------------------------------------------.
! 1905: | yy_stack_print -- Print the state stack from its BOTTOM up to its |
! 1906: | TOP (included). |
! 1907: `------------------------------------------------------------------*/
! 1908:
! 1909: #if (defined __STDC__ || defined __C99__FUNC__ \
! 1910: || defined __cplusplus || defined _MSC_VER)
! 1911: static void
! 1912: yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
! 1913: #else
! 1914: static void
! 1915: yy_stack_print (yybottom, yytop)
! 1916: yytype_int16 *yybottom;
! 1917: yytype_int16 *yytop;
! 1918: #endif
! 1919: {
! 1920: YYFPRINTF (stderr, "Stack now");
! 1921: for (; yybottom <= yytop; yybottom++)
! 1922: {
! 1923: int yybot = *yybottom;
! 1924: YYFPRINTF (stderr, " %d", yybot);
! 1925: }
! 1926: YYFPRINTF (stderr, "\n");
! 1927: }
! 1928:
! 1929: # define YY_STACK_PRINT(Bottom, Top) \
! 1930: do { \
! 1931: if (yydebug) \
! 1932: yy_stack_print ((Bottom), (Top)); \
! 1933: } while (YYID (0))
! 1934:
! 1935:
! 1936: /*------------------------------------------------.
! 1937: | Report that the YYRULE is going to be reduced. |
! 1938: `------------------------------------------------*/
! 1939:
! 1940: #if (defined __STDC__ || defined __C99__FUNC__ \
! 1941: || defined __cplusplus || defined _MSC_VER)
! 1942: static void
! 1943: yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
! 1944: #else
! 1945: static void
! 1946: yy_reduce_print (yyvsp, yyrule)
! 1947: YYSTYPE *yyvsp;
! 1948: int yyrule;
! 1949: #endif
! 1950: {
! 1951: int yynrhs = yyr2[yyrule];
! 1952: int yyi;
! 1953: unsigned long int yylno = yyrline[yyrule];
! 1954: YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
! 1955: yyrule - 1, yylno);
! 1956: /* The symbols being reduced. */
! 1957: for (yyi = 0; yyi < yynrhs; yyi++)
! 1958: {
! 1959: YYFPRINTF (stderr, " $%d = ", yyi + 1);
! 1960: yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
! 1961: &(yyvsp[(yyi + 1) - (yynrhs)])
! 1962: );
! 1963: YYFPRINTF (stderr, "\n");
! 1964: }
! 1965: }
! 1966:
! 1967: # define YY_REDUCE_PRINT(Rule) \
! 1968: do { \
! 1969: if (yydebug) \
! 1970: yy_reduce_print (yyvsp, Rule); \
! 1971: } while (YYID (0))
! 1972:
! 1973: /* Nonzero means print parse trace. It is left uninitialized so that
! 1974: multiple parsers can coexist. */
! 1975: int yydebug;
! 1976: #else /* !YYDEBUG */
! 1977: # define YYDPRINTF(Args)
! 1978: # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
! 1979: # define YY_STACK_PRINT(Bottom, Top)
! 1980: # define YY_REDUCE_PRINT(Rule)
! 1981: #endif /* !YYDEBUG */
! 1982:
! 1983:
! 1984: /* YYINITDEPTH -- initial size of the parser's stacks. */
! 1985: #ifndef YYINITDEPTH
! 1986: # define YYINITDEPTH 200
! 1987: #endif
! 1988:
! 1989: /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
! 1990: if the built-in stack extension method is used).
! 1991:
! 1992: Do not make this value too large; the results are undefined if
! 1993: YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
! 1994: evaluated with infinite-precision integer arithmetic. */
! 1995:
! 1996: #ifndef YYMAXDEPTH
! 1997: # define YYMAXDEPTH 10000
! 1998: #endif
! 1999:
! 2000:
! 2001:
! 2002: #if YYERROR_VERBOSE
! 2003:
! 2004: # ifndef yystrlen
! 2005: # if defined __GLIBC__ && defined _STRING_H
! 2006: # define yystrlen strlen
! 2007: # else
! 2008: /* Return the length of YYSTR. */
! 2009: #if (defined __STDC__ || defined __C99__FUNC__ \
! 2010: || defined __cplusplus || defined _MSC_VER)
! 2011: static YYSIZE_T
! 2012: yystrlen (const char *yystr)
! 2013: #else
! 2014: static YYSIZE_T
! 2015: yystrlen (yystr)
! 2016: const char *yystr;
! 2017: #endif
! 2018: {
! 2019: YYSIZE_T yylen;
! 2020: for (yylen = 0; yystr[yylen]; yylen++)
! 2021: continue;
! 2022: return yylen;
! 2023: }
! 2024: # endif
! 2025: # endif
! 2026:
! 2027: # ifndef yystpcpy
! 2028: # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
! 2029: # define yystpcpy stpcpy
! 2030: # else
! 2031: /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
! 2032: YYDEST. */
! 2033: #if (defined __STDC__ || defined __C99__FUNC__ \
! 2034: || defined __cplusplus || defined _MSC_VER)
! 2035: static char *
! 2036: yystpcpy (char *yydest, const char *yysrc)
! 2037: #else
! 2038: static char *
! 2039: yystpcpy (yydest, yysrc)
! 2040: char *yydest;
! 2041: const char *yysrc;
! 2042: #endif
! 2043: {
! 2044: char *yyd = yydest;
! 2045: const char *yys = yysrc;
! 2046:
! 2047: while ((*yyd++ = *yys++) != '\0')
! 2048: continue;
! 2049:
! 2050: return yyd - 1;
! 2051: }
! 2052: # endif
! 2053: # endif
! 2054:
! 2055: # ifndef yytnamerr
! 2056: /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
! 2057: quotes and backslashes, so that it's suitable for yyerror. The
! 2058: heuristic is that double-quoting is unnecessary unless the string
! 2059: contains an apostrophe, a comma, or backslash (other than
! 2060: backslash-backslash). YYSTR is taken from yytname. If YYRES is
! 2061: null, do not copy; instead, return the length of what the result
! 2062: would have been. */
! 2063: static YYSIZE_T
! 2064: yytnamerr (char *yyres, const char *yystr)
! 2065: {
! 2066: if (*yystr == '"')
! 2067: {
! 2068: YYSIZE_T yyn = 0;
! 2069: char const *yyp = yystr;
! 2070:
! 2071: for (;;)
! 2072: switch (*++yyp)
! 2073: {
! 2074: case '\'':
! 2075: case ',':
! 2076: goto do_not_strip_quotes;
! 2077:
! 2078: case '\\':
! 2079: if (*++yyp != '\\')
! 2080: goto do_not_strip_quotes;
! 2081: /* Fall through. */
! 2082: default:
! 2083: if (yyres)
! 2084: yyres[yyn] = *yyp;
! 2085: yyn++;
! 2086: break;
! 2087:
! 2088: case '"':
! 2089: if (yyres)
! 2090: yyres[yyn] = '\0';
! 2091: return yyn;
! 2092: }
! 2093: do_not_strip_quotes: ;
! 2094: }
! 2095:
! 2096: if (! yyres)
! 2097: return yystrlen (yystr);
! 2098:
! 2099: return yystpcpy (yyres, yystr) - yyres;
! 2100: }
! 2101: # endif
! 2102:
! 2103: /* Copy into YYRESULT an error message about the unexpected token
! 2104: YYCHAR while in state YYSTATE. Return the number of bytes copied,
! 2105: including the terminating null byte. If YYRESULT is null, do not
! 2106: copy anything; just return the number of bytes that would be
! 2107: copied. As a special case, return 0 if an ordinary "syntax error"
! 2108: message will do. Return YYSIZE_MAXIMUM if overflow occurs during
! 2109: size calculation. */
! 2110: static YYSIZE_T
! 2111: yysyntax_error (char *yyresult, int yystate, int yychar)
! 2112: {
! 2113: int yyn = yypact[yystate];
! 2114:
! 2115: if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
! 2116: return 0;
! 2117: else
! 2118: {
! 2119: int yytype = YYTRANSLATE (yychar);
! 2120: YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
! 2121: YYSIZE_T yysize = yysize0;
! 2122: YYSIZE_T yysize1;
! 2123: int yysize_overflow = 0;
! 2124: enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
! 2125: char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
! 2126: int yyx;
! 2127:
! 2128: # if 0
! 2129: /* This is so xgettext sees the translatable formats that are
! 2130: constructed on the fly. */
! 2131: YY_("syntax error, unexpected %s");
! 2132: YY_("syntax error, unexpected %s, expecting %s");
! 2133: YY_("syntax error, unexpected %s, expecting %s or %s");
! 2134: YY_("syntax error, unexpected %s, expecting %s or %s or %s");
! 2135: YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
! 2136: # endif
! 2137: char *yyfmt;
! 2138: char const *yyf;
! 2139: static char const yyunexpected[] = "syntax error, unexpected %s";
! 2140: static char const yyexpecting[] = ", expecting %s";
! 2141: static char const yyor[] = " or %s";
! 2142: char yyformat[sizeof yyunexpected
! 2143: + sizeof yyexpecting - 1
! 2144: + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
! 2145: * (sizeof yyor - 1))];
! 2146: char const *yyprefix = yyexpecting;
! 2147:
! 2148: /* Start YYX at -YYN if negative to avoid negative indexes in
! 2149: YYCHECK. */
! 2150: int yyxbegin = yyn < 0 ? -yyn : 0;
! 2151:
! 2152: /* Stay within bounds of both yycheck and yytname. */
! 2153: int yychecklim = YYLAST - yyn + 1;
! 2154: int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
! 2155: int yycount = 1;
! 2156:
! 2157: yyarg[0] = yytname[yytype];
! 2158: yyfmt = yystpcpy (yyformat, yyunexpected);
! 2159:
! 2160: for (yyx = yyxbegin; yyx < yyxend; ++yyx)
! 2161: if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
! 2162: {
! 2163: if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
! 2164: {
! 2165: yycount = 1;
! 2166: yysize = yysize0;
! 2167: yyformat[sizeof yyunexpected - 1] = '\0';
! 2168: break;
! 2169: }
! 2170: yyarg[yycount++] = yytname[yyx];
! 2171: yysize1 = yysize + yytnamerr (0, yytname[yyx]);
! 2172: yysize_overflow |= (yysize1 < yysize);
! 2173: yysize = yysize1;
! 2174: yyfmt = yystpcpy (yyfmt, yyprefix);
! 2175: yyprefix = yyor;
! 2176: }
! 2177:
! 2178: yyf = YY_(yyformat);
! 2179: yysize1 = yysize + yystrlen (yyf);
! 2180: yysize_overflow |= (yysize1 < yysize);
! 2181: yysize = yysize1;
! 2182:
! 2183: if (yysize_overflow)
! 2184: return YYSIZE_MAXIMUM;
! 2185:
! 2186: if (yyresult)
! 2187: {
! 2188: /* Avoid sprintf, as that infringes on the user's name space.
! 2189: Don't have undefined behavior even if the translation
! 2190: produced a string with the wrong number of "%s"s. */
! 2191: char *yyp = yyresult;
! 2192: int yyi = 0;
! 2193: while ((*yyp = *yyf) != '\0')
! 2194: {
! 2195: if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
! 2196: {
! 2197: yyp += yytnamerr (yyp, yyarg[yyi++]);
! 2198: yyf += 2;
! 2199: }
! 2200: else
! 2201: {
! 2202: yyp++;
! 2203: yyf++;
! 2204: }
! 2205: }
! 2206: }
! 2207: return yysize;
! 2208: }
! 2209: }
! 2210: #endif /* YYERROR_VERBOSE */
! 2211:
! 2212:
! 2213: /*-----------------------------------------------.
! 2214: | Release the memory associated to this symbol. |
! 2215: `-----------------------------------------------*/
! 2216:
! 2217: /*ARGSUSED*/
! 2218: #if (defined __STDC__ || defined __C99__FUNC__ \
! 2219: || defined __cplusplus || defined _MSC_VER)
! 2220: static void
! 2221: yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
! 2222: #else
! 2223: static void
! 2224: yydestruct (yymsg, yytype, yyvaluep)
! 2225: const char *yymsg;
! 2226: int yytype;
! 2227: YYSTYPE *yyvaluep;
! 2228: #endif
! 2229: {
! 2230: YYUSE (yyvaluep);
! 2231:
! 2232: if (!yymsg)
! 2233: yymsg = "Deleting";
! 2234: YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
! 2235:
! 2236: switch (yytype)
! 2237: {
! 2238:
! 2239: default:
! 2240: break;
! 2241: }
! 2242: }
! 2243:
! 2244: /* Prevent warnings from -Wmissing-prototypes. */
! 2245: #ifdef YYPARSE_PARAM
! 2246: #if defined __STDC__ || defined __cplusplus
! 2247: int yyparse (void *YYPARSE_PARAM);
! 2248: #else
! 2249: int yyparse ();
! 2250: #endif
! 2251: #else /* ! YYPARSE_PARAM */
! 2252: #if defined __STDC__ || defined __cplusplus
! 2253: int yyparse (void);
! 2254: #else
! 2255: int yyparse ();
! 2256: #endif
! 2257: #endif /* ! YYPARSE_PARAM */
! 2258:
! 2259:
! 2260: /* The lookahead symbol. */
! 2261: int yychar;
! 2262:
! 2263: /* The semantic value of the lookahead symbol. */
! 2264: YYSTYPE yylval;
! 2265:
! 2266: /* Number of syntax errors so far. */
! 2267: int yynerrs;
! 2268:
! 2269:
! 2270:
! 2271: /*-------------------------.
! 2272: | yyparse or yypush_parse. |
! 2273: `-------------------------*/
! 2274:
! 2275: #ifdef YYPARSE_PARAM
! 2276: #if (defined __STDC__ || defined __C99__FUNC__ \
! 2277: || defined __cplusplus || defined _MSC_VER)
! 2278: int
! 2279: yyparse (void *YYPARSE_PARAM)
! 2280: #else
! 2281: int
! 2282: yyparse (YYPARSE_PARAM)
! 2283: void *YYPARSE_PARAM;
! 2284: #endif
! 2285: #else /* ! YYPARSE_PARAM */
! 2286: #if (defined __STDC__ || defined __C99__FUNC__ \
! 2287: || defined __cplusplus || defined _MSC_VER)
! 2288: int
! 2289: yyparse (void)
! 2290: #else
! 2291: int
! 2292: yyparse ()
! 2293:
! 2294: #endif
! 2295: #endif
! 2296: {
! 2297:
! 2298:
! 2299: int yystate;
! 2300: /* Number of tokens to shift before error messages enabled. */
! 2301: int yyerrstatus;
! 2302:
! 2303: /* The stacks and their tools:
! 2304: `yyss': related to states.
! 2305: `yyvs': related to semantic values.
! 2306:
! 2307: Refer to the stacks thru separate pointers, to allow yyoverflow
! 2308: to reallocate them elsewhere. */
! 2309:
! 2310: /* The state stack. */
! 2311: yytype_int16 yyssa[YYINITDEPTH];
! 2312: yytype_int16 *yyss;
! 2313: yytype_int16 *yyssp;
! 2314:
! 2315: /* The semantic value stack. */
! 2316: YYSTYPE yyvsa[YYINITDEPTH];
! 2317: YYSTYPE *yyvs;
! 2318: YYSTYPE *yyvsp;
! 2319:
! 2320: YYSIZE_T yystacksize;
! 2321:
! 2322: int yyn;
! 2323: int yyresult;
! 2324: /* Lookahead token as an internal (translated) token number. */
! 2325: int yytoken;
! 2326: /* The variables used to return semantic value and location from the
! 2327: action routines. */
! 2328: YYSTYPE yyval;
! 2329:
! 2330: #if YYERROR_VERBOSE
! 2331: /* Buffer for error messages, and its allocated size. */
! 2332: char yymsgbuf[128];
! 2333: char *yymsg = yymsgbuf;
! 2334: YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
! 2335: #endif
! 2336:
! 2337: #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
! 2338:
! 2339: /* The number of symbols on the RHS of the reduced rule.
! 2340: Keep to zero when no symbol should be popped. */
! 2341: int yylen = 0;
! 2342:
! 2343: yytoken = 0;
! 2344: yyss = yyssa;
! 2345: yyvs = yyvsa;
! 2346: yystacksize = YYINITDEPTH;
! 2347:
! 2348: YYDPRINTF ((stderr, "Starting parse\n"));
! 2349:
! 2350: yystate = 0;
! 2351: yyerrstatus = 0;
! 2352: yynerrs = 0;
! 2353: yychar = YYEMPTY; /* Cause a token to be read. */
! 2354:
! 2355: /* Initialize stack pointers.
! 2356: Waste one element of value and location stack
! 2357: so that they stay on the same level as the state stack.
! 2358: The wasted elements are never initialized. */
! 2359: yyssp = yyss;
! 2360: yyvsp = yyvs;
! 2361:
! 2362: goto yysetstate;
! 2363:
! 2364: /*------------------------------------------------------------.
! 2365: | yynewstate -- Push a new state, which is found in yystate. |
! 2366: `------------------------------------------------------------*/
! 2367: yynewstate:
! 2368: /* In all cases, when you get here, the value and location stacks
! 2369: have just been pushed. So pushing a state here evens the stacks. */
! 2370: yyssp++;
! 2371:
! 2372: yysetstate:
! 2373: *yyssp = yystate;
! 2374:
! 2375: if (yyss + yystacksize - 1 <= yyssp)
! 2376: {
! 2377: /* Get the current used size of the three stacks, in elements. */
! 2378: YYSIZE_T yysize = yyssp - yyss + 1;
! 2379:
! 2380: #ifdef yyoverflow
! 2381: {
! 2382: /* Give user a chance to reallocate the stack. Use copies of
! 2383: these so that the &'s don't force the real ones into
! 2384: memory. */
! 2385: YYSTYPE *yyvs1 = yyvs;
! 2386: yytype_int16 *yyss1 = yyss;
! 2387:
! 2388: /* Each stack pointer address is followed by the size of the
! 2389: data in use in that stack, in bytes. This used to be a
! 2390: conditional around just the two extra args, but that might
! 2391: be undefined if yyoverflow is a macro. */
! 2392: yyoverflow (YY_("memory exhausted"),
! 2393: &yyss1, yysize * sizeof (*yyssp),
! 2394: &yyvs1, yysize * sizeof (*yyvsp),
! 2395: &yystacksize);
! 2396:
! 2397: yyss = yyss1;
! 2398: yyvs = yyvs1;
! 2399: }
! 2400: #else /* no yyoverflow */
! 2401: # ifndef YYSTACK_RELOCATE
! 2402: goto yyexhaustedlab;
! 2403: # else
! 2404: /* Extend the stack our own way. */
! 2405: if (YYMAXDEPTH <= yystacksize)
! 2406: goto yyexhaustedlab;
! 2407: yystacksize *= 2;
! 2408: if (YYMAXDEPTH < yystacksize)
! 2409: yystacksize = YYMAXDEPTH;
! 2410:
! 2411: {
! 2412: yytype_int16 *yyss1 = yyss;
! 2413: union yyalloc *yyptr =
! 2414: (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
! 2415: if (! yyptr)
! 2416: goto yyexhaustedlab;
! 2417: YYSTACK_RELOCATE (yyss_alloc, yyss);
! 2418: YYSTACK_RELOCATE (yyvs_alloc, yyvs);
! 2419: # undef YYSTACK_RELOCATE
! 2420: if (yyss1 != yyssa)
! 2421: YYSTACK_FREE (yyss1);
! 2422: }
! 2423: # endif
! 2424: #endif /* no yyoverflow */
! 2425:
! 2426: yyssp = yyss + yysize - 1;
! 2427: yyvsp = yyvs + yysize - 1;
! 2428:
! 2429: YYDPRINTF ((stderr, "Stack size increased to %lu\n",
! 2430: (unsigned long int) yystacksize));
! 2431:
! 2432: if (yyss + yystacksize - 1 <= yyssp)
! 2433: YYABORT;
! 2434: }
! 2435:
! 2436: YYDPRINTF ((stderr, "Entering state %d\n", yystate));
! 2437:
! 2438: if (yystate == YYFINAL)
! 2439: YYACCEPT;
! 2440:
! 2441: goto yybackup;
! 2442:
! 2443: /*-----------.
! 2444: | yybackup. |
! 2445: `-----------*/
! 2446: yybackup:
! 2447:
! 2448: /* Do appropriate processing given the current state. Read a
! 2449: lookahead token if we need one and don't already have one. */
! 2450:
! 2451: /* First try to decide what to do without reference to lookahead token. */
! 2452: yyn = yypact[yystate];
! 2453: if (yyn == YYPACT_NINF)
! 2454: goto yydefault;
! 2455:
! 2456: /* Not known => get a lookahead token if don't already have one. */
! 2457:
! 2458: /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
! 2459: if (yychar == YYEMPTY)
! 2460: {
! 2461: YYDPRINTF ((stderr, "Reading a token: "));
! 2462: yychar = YYLEX;
! 2463: }
! 2464:
! 2465: if (yychar <= YYEOF)
! 2466: {
! 2467: yychar = yytoken = YYEOF;
! 2468: YYDPRINTF ((stderr, "Now at end of input.\n"));
! 2469: }
! 2470: else
! 2471: {
! 2472: yytoken = YYTRANSLATE (yychar);
! 2473: YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
! 2474: }
! 2475:
! 2476: /* If the proper action on seeing token YYTOKEN is to reduce or to
! 2477: detect an error, take that action. */
! 2478: yyn += yytoken;
! 2479: if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
! 2480: goto yydefault;
! 2481: yyn = yytable[yyn];
! 2482: if (yyn <= 0)
! 2483: {
! 2484: if (yyn == 0 || yyn == YYTABLE_NINF)
! 2485: goto yyerrlab;
! 2486: yyn = -yyn;
! 2487: goto yyreduce;
! 2488: }
! 2489:
! 2490: /* Count tokens shifted since error; after three, turn off error
! 2491: status. */
! 2492: if (yyerrstatus)
! 2493: yyerrstatus--;
! 2494:
! 2495: /* Shift the lookahead token. */
! 2496: YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
! 2497:
! 2498: /* Discard the shifted token. */
! 2499: yychar = YYEMPTY;
! 2500:
! 2501: yystate = yyn;
! 2502: *++yyvsp = yylval;
! 2503:
! 2504: goto yynewstate;
! 2505:
! 2506:
! 2507: /*-----------------------------------------------------------.
! 2508: | yydefault -- do the default action for the current state. |
! 2509: `-----------------------------------------------------------*/
! 2510: yydefault:
! 2511: yyn = yydefact[yystate];
! 2512: if (yyn == 0)
! 2513: goto yyerrlab;
! 2514: goto yyreduce;
! 2515:
! 2516:
! 2517: /*-----------------------------.
! 2518: | yyreduce -- Do a reduction. |
! 2519: `-----------------------------*/
! 2520: yyreduce:
! 2521: /* yyn is the number of a rule to reduce with. */
! 2522: yylen = yyr2[yyn];
! 2523:
! 2524: /* If YYLEN is nonzero, implement the default value of the action:
! 2525: `$$ = $1'.
! 2526:
! 2527: Otherwise, the following line sets YYVAL to garbage.
! 2528: This behavior is undocumented and Bison
! 2529: users should not rely upon it. Assigning to YYVAL
! 2530: unconditionally makes the parser a bit smaller, and it avoids a
! 2531: GCC warning that YYVAL may be used uninitialized. */
! 2532: yyval = yyvsp[1-yylen];
! 2533:
! 2534:
! 2535: YY_REDUCE_PRINT (yyn);
! 2536: switch (yyn)
! 2537: {
! 2538: case 22:
! 2539:
! 2540: /* Line 1455 of yacc.c */
! 2541: #line 298 "cfparse.y"
! 2542: {
! 2543: struct passwd *pw;
! 2544:
! 2545: if ((pw = getpwnam((yyvsp[(2) - (2)].val)->v)) == NULL) {
! 2546: yyerror("unknown user \"%s\"", (yyvsp[(2) - (2)].val)->v);
! 2547: return -1;
! 2548: }
! 2549: lcconf->uid = pw->pw_uid;
! 2550: }
! 2551: break;
! 2552:
! 2553: case 24:
! 2554:
! 2555: /* Line 1455 of yacc.c */
! 2556: #line 308 "cfparse.y"
! 2557: { lcconf->uid = (yyvsp[(2) - (2)].num); }
! 2558: break;
! 2559:
! 2560: case 26:
! 2561:
! 2562: /* Line 1455 of yacc.c */
! 2563: #line 310 "cfparse.y"
! 2564: {
! 2565: struct group *gr;
! 2566:
! 2567: if ((gr = getgrnam((yyvsp[(2) - (2)].val)->v)) == NULL) {
! 2568: yyerror("unknown group \"%s\"", (yyvsp[(2) - (2)].val)->v);
! 2569: return -1;
! 2570: }
! 2571: lcconf->gid = gr->gr_gid;
! 2572: }
! 2573: break;
! 2574:
! 2575: case 28:
! 2576:
! 2577: /* Line 1455 of yacc.c */
! 2578: #line 320 "cfparse.y"
! 2579: { lcconf->gid = (yyvsp[(2) - (2)].num); }
! 2580: break;
! 2581:
! 2582: case 30:
! 2583:
! 2584: /* Line 1455 of yacc.c */
! 2585: #line 321 "cfparse.y"
! 2586: { lcconf->chroot = (yyvsp[(2) - (2)].val)->v; }
! 2587: break;
! 2588:
! 2589: case 32:
! 2590:
! 2591: /* Line 1455 of yacc.c */
! 2592: #line 327 "cfparse.y"
! 2593: {
! 2594: if ((yyvsp[(2) - (3)].num) >= LC_PATHTYPE_MAX) {
! 2595: yyerror("invalid path type %d", (yyvsp[(2) - (3)].num));
! 2596: return -1;
! 2597: }
! 2598:
! 2599: /* free old pathinfo */
! 2600: if (lcconf->pathinfo[(yyvsp[(2) - (3)].num)])
! 2601: racoon_free(lcconf->pathinfo[(yyvsp[(2) - (3)].num)]);
! 2602:
! 2603: /* set new pathinfo */
! 2604: lcconf->pathinfo[(yyvsp[(2) - (3)].num)] = racoon_strdup((yyvsp[(3) - (3)].val)->v);
! 2605: STRDUP_FATAL(lcconf->pathinfo[(yyvsp[(2) - (3)].num)]);
! 2606: vfree((yyvsp[(3) - (3)].val));
! 2607: }
! 2608: break;
! 2609:
! 2610: case 34:
! 2611:
! 2612: /* Line 1455 of yacc.c */
! 2613: #line 347 "cfparse.y"
! 2614: { lcconf->complex_bundle = (yyvsp[(2) - (2)].num); }
! 2615: break;
! 2616:
! 2617: case 36:
! 2618:
! 2619: /* Line 1455 of yacc.c */
! 2620: #line 353 "cfparse.y"
! 2621: {
! 2622: char path[MAXPATHLEN];
! 2623:
! 2624: getpathname(path, sizeof(path),
! 2625: LC_PATHTYPE_INCLUDE, (yyvsp[(2) - (3)].val)->v);
! 2626: vfree((yyvsp[(2) - (3)].val));
! 2627: if (yycf_switch_buffer(path) != 0)
! 2628: return -1;
! 2629: }
! 2630: break;
! 2631:
! 2632: case 37:
! 2633:
! 2634: /* Line 1455 of yacc.c */
! 2635: #line 367 "cfparse.y"
! 2636: {
! 2637: lcconf->pfkey_buffer_size = (yyvsp[(2) - (3)].num);
! 2638: }
! 2639: break;
! 2640:
! 2641: case 38:
! 2642:
! 2643: /* Line 1455 of yacc.c */
! 2644: #line 374 "cfparse.y"
! 2645: {
! 2646: if ((yyvsp[(2) - (3)].num) >= LC_GSSENC_MAX) {
! 2647: yyerror("invalid GSS ID encoding %d", (yyvsp[(2) - (3)].num));
! 2648: return -1;
! 2649: }
! 2650: lcconf->gss_id_enc = (yyvsp[(2) - (3)].num);
! 2651: }
! 2652: break;
! 2653:
! 2654: case 40:
! 2655:
! 2656: /* Line 1455 of yacc.c */
! 2657: #line 389 "cfparse.y"
! 2658: {
! 2659: /*
! 2660: * set the loglevel to the value specified
! 2661: * in the configuration file plus the number
! 2662: * of -d options specified on the command line
! 2663: */
! 2664: loglevel += (yyvsp[(1) - (1)].num) - oldloglevel;
! 2665: oldloglevel = (yyvsp[(1) - (1)].num);
! 2666: }
! 2667: break;
! 2668:
! 2669: case 44:
! 2670:
! 2671: /* Line 1455 of yacc.c */
! 2672: #line 409 "cfparse.y"
! 2673: { lcconf->pad_random = (yyvsp[(2) - (2)].num); }
! 2674: break;
! 2675:
! 2676: case 46:
! 2677:
! 2678: /* Line 1455 of yacc.c */
! 2679: #line 410 "cfparse.y"
! 2680: { lcconf->pad_randomlen = (yyvsp[(2) - (2)].num); }
! 2681: break;
! 2682:
! 2683: case 48:
! 2684:
! 2685: /* Line 1455 of yacc.c */
! 2686: #line 411 "cfparse.y"
! 2687: { lcconf->pad_maxsize = (yyvsp[(2) - (2)].num); }
! 2688: break;
! 2689:
! 2690: case 50:
! 2691:
! 2692: /* Line 1455 of yacc.c */
! 2693: #line 412 "cfparse.y"
! 2694: { lcconf->pad_strict = (yyvsp[(2) - (2)].num); }
! 2695: break;
! 2696:
! 2697: case 52:
! 2698:
! 2699: /* Line 1455 of yacc.c */
! 2700: #line 413 "cfparse.y"
! 2701: { lcconf->pad_excltail = (yyvsp[(2) - (2)].num); }
! 2702: break;
! 2703:
! 2704: case 57:
! 2705:
! 2706: /* Line 1455 of yacc.c */
! 2707: #line 426 "cfparse.y"
! 2708: {
! 2709: myaddr_listen((yyvsp[(2) - (2)].saddr), FALSE);
! 2710: racoon_free((yyvsp[(2) - (2)].saddr));
! 2711: }
! 2712: break;
! 2713:
! 2714: case 59:
! 2715:
! 2716: /* Line 1455 of yacc.c */
! 2717: #line 432 "cfparse.y"
! 2718: {
! 2719: #ifdef ENABLE_NATT
! 2720: myaddr_listen((yyvsp[(2) - (2)].saddr), TRUE);
! 2721: racoon_free((yyvsp[(2) - (2)].saddr));
! 2722: #else
! 2723: racoon_free((yyvsp[(2) - (2)].saddr));
! 2724: yyerror("NAT-T support not compiled in.");
! 2725: #endif
! 2726: }
! 2727: break;
! 2728:
! 2729: case 61:
! 2730:
! 2731: /* Line 1455 of yacc.c */
! 2732: #line 443 "cfparse.y"
! 2733: {
! 2734: #ifdef ENABLE_ADMINPORT
! 2735: adminsock_conf((yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].num));
! 2736: #else
! 2737: yywarn("admin port support not compiled in");
! 2738: #endif
! 2739: }
! 2740: break;
! 2741:
! 2742: case 63:
! 2743:
! 2744: /* Line 1455 of yacc.c */
! 2745: #line 452 "cfparse.y"
! 2746: {
! 2747: #ifdef ENABLE_ADMINPORT
! 2748: adminsock_conf((yyvsp[(2) - (2)].val), NULL, NULL, -1);
! 2749: #else
! 2750: yywarn("admin port support not compiled in");
! 2751: #endif
! 2752: }
! 2753: break;
! 2754:
! 2755: case 65:
! 2756:
! 2757: /* Line 1455 of yacc.c */
! 2758: #line 461 "cfparse.y"
! 2759: {
! 2760: #ifdef ENABLE_ADMINPORT
! 2761: adminsock_path = NULL;
! 2762: #else
! 2763: yywarn("admin port support not compiled in");
! 2764: #endif
! 2765: }
! 2766: break;
! 2767:
! 2768: case 67:
! 2769:
! 2770: /* Line 1455 of yacc.c */
! 2771: #line 469 "cfparse.y"
! 2772: { lcconf->strict_address = TRUE; }
! 2773: break;
! 2774:
! 2775: case 69:
! 2776:
! 2777: /* Line 1455 of yacc.c */
! 2778: #line 473 "cfparse.y"
! 2779: {
! 2780: char portbuf[10];
! 2781:
! 2782: snprintf(portbuf, sizeof(portbuf), "%ld", (yyvsp[(2) - (2)].num));
! 2783: (yyval.saddr) = str2saddr((yyvsp[(1) - (2)].val)->v, portbuf);
! 2784: vfree((yyvsp[(1) - (2)].val));
! 2785: if (!(yyval.saddr))
! 2786: return -1;
! 2787: }
! 2788: break;
! 2789:
! 2790: case 70:
! 2791:
! 2792: /* Line 1455 of yacc.c */
! 2793: #line 484 "cfparse.y"
! 2794: { (yyval.num) = PORT_ISAKMP; }
! 2795: break;
! 2796:
! 2797: case 71:
! 2798:
! 2799: /* Line 1455 of yacc.c */
! 2800: #line 485 "cfparse.y"
! 2801: { (yyval.num) = (yyvsp[(1) - (1)].num); }
! 2802: break;
! 2803:
! 2804: case 72:
! 2805:
! 2806: /* Line 1455 of yacc.c */
! 2807: #line 490 "cfparse.y"
! 2808: {
! 2809: #ifndef ENABLE_HYBRID
! 2810: yyerror("racoon not configured with --enable-hybrid");
! 2811: return -1;
! 2812: #endif
! 2813: #ifndef HAVE_LIBRADIUS
! 2814: yyerror("racoon not configured with --with-libradius");
! 2815: return -1;
! 2816: #endif
! 2817: #ifdef ENABLE_HYBRID
! 2818: #ifdef HAVE_LIBRADIUS
! 2819: xauth_rad_config.timeout = 3;
! 2820: xauth_rad_config.retries = 3;
! 2821: #endif
! 2822: #endif
! 2823: }
! 2824: break;
! 2825:
! 2826: case 76:
! 2827:
! 2828: /* Line 1455 of yacc.c */
! 2829: #line 513 "cfparse.y"
! 2830: {
! 2831: #ifdef ENABLE_HYBRID
! 2832: #ifdef HAVE_LIBRADIUS
! 2833: int i = xauth_rad_config.auth_server_count;
! 2834: if (i == RADIUS_MAX_SERVERS) {
! 2835: yyerror("maximum radius auth servers exceeded");
! 2836: return -1;
! 2837: }
! 2838:
! 2839: xauth_rad_config.auth_server_list[i].host = vdup((yyvsp[(2) - (3)].val));
! 2840: xauth_rad_config.auth_server_list[i].secret = vdup((yyvsp[(3) - (3)].val));
! 2841: xauth_rad_config.auth_server_list[i].port = 0; // default port
! 2842: xauth_rad_config.auth_server_count++;
! 2843: #endif
! 2844: #endif
! 2845: }
! 2846: break;
! 2847:
! 2848: case 78:
! 2849:
! 2850: /* Line 1455 of yacc.c */
! 2851: #line 531 "cfparse.y"
! 2852: {
! 2853: #ifdef ENABLE_HYBRID
! 2854: #ifdef HAVE_LIBRADIUS
! 2855: int i = xauth_rad_config.auth_server_count;
! 2856: if (i == RADIUS_MAX_SERVERS) {
! 2857: yyerror("maximum radius auth servers exceeded");
! 2858: return -1;
! 2859: }
! 2860:
! 2861: xauth_rad_config.auth_server_list[i].host = vdup((yyvsp[(2) - (4)].val));
! 2862: xauth_rad_config.auth_server_list[i].secret = vdup((yyvsp[(4) - (4)].val));
! 2863: xauth_rad_config.auth_server_list[i].port = (yyvsp[(3) - (4)].num);
! 2864: xauth_rad_config.auth_server_count++;
! 2865: #endif
! 2866: #endif
! 2867: }
! 2868: break;
! 2869:
! 2870: case 80:
! 2871:
! 2872: /* Line 1455 of yacc.c */
! 2873: #line 549 "cfparse.y"
! 2874: {
! 2875: #ifdef ENABLE_HYBRID
! 2876: #ifdef HAVE_LIBRADIUS
! 2877: int i = xauth_rad_config.acct_server_count;
! 2878: if (i == RADIUS_MAX_SERVERS) {
! 2879: yyerror("maximum radius account servers exceeded");
! 2880: return -1;
! 2881: }
! 2882:
! 2883: xauth_rad_config.acct_server_list[i].host = vdup((yyvsp[(2) - (3)].val));
! 2884: xauth_rad_config.acct_server_list[i].secret = vdup((yyvsp[(3) - (3)].val));
! 2885: xauth_rad_config.acct_server_list[i].port = 0; // default port
! 2886: xauth_rad_config.acct_server_count++;
! 2887: #endif
! 2888: #endif
! 2889: }
! 2890: break;
! 2891:
! 2892: case 82:
! 2893:
! 2894: /* Line 1455 of yacc.c */
! 2895: #line 567 "cfparse.y"
! 2896: {
! 2897: #ifdef ENABLE_HYBRID
! 2898: #ifdef HAVE_LIBRADIUS
! 2899: int i = xauth_rad_config.acct_server_count;
! 2900: if (i == RADIUS_MAX_SERVERS) {
! 2901: yyerror("maximum radius account servers exceeded");
! 2902: return -1;
! 2903: }
! 2904:
! 2905: xauth_rad_config.acct_server_list[i].host = vdup((yyvsp[(2) - (4)].val));
! 2906: xauth_rad_config.acct_server_list[i].secret = vdup((yyvsp[(4) - (4)].val));
! 2907: xauth_rad_config.acct_server_list[i].port = (yyvsp[(3) - (4)].num);
! 2908: xauth_rad_config.acct_server_count++;
! 2909: #endif
! 2910: #endif
! 2911: }
! 2912: break;
! 2913:
! 2914: case 84:
! 2915:
! 2916: /* Line 1455 of yacc.c */
! 2917: #line 585 "cfparse.y"
! 2918: {
! 2919: #ifdef ENABLE_HYBRID
! 2920: #ifdef HAVE_LIBRADIUS
! 2921: xauth_rad_config.timeout = (yyvsp[(2) - (2)].num);
! 2922: #endif
! 2923: #endif
! 2924: }
! 2925: break;
! 2926:
! 2927: case 86:
! 2928:
! 2929: /* Line 1455 of yacc.c */
! 2930: #line 594 "cfparse.y"
! 2931: {
! 2932: #ifdef ENABLE_HYBRID
! 2933: #ifdef HAVE_LIBRADIUS
! 2934: xauth_rad_config.retries = (yyvsp[(2) - (2)].num);
! 2935: #endif
! 2936: #endif
! 2937: }
! 2938: break;
! 2939:
! 2940: case 88:
! 2941:
! 2942: /* Line 1455 of yacc.c */
! 2943: #line 606 "cfparse.y"
! 2944: {
! 2945: #ifndef ENABLE_HYBRID
! 2946: yyerror("racoon not configured with --enable-hybrid");
! 2947: return -1;
! 2948: #endif
! 2949: #ifndef HAVE_LIBLDAP
! 2950: yyerror("racoon not configured with --with-libldap");
! 2951: return -1;
! 2952: #endif
! 2953: }
! 2954: break;
! 2955:
! 2956: case 92:
! 2957:
! 2958: /* Line 1455 of yacc.c */
! 2959: #line 623 "cfparse.y"
! 2960: {
! 2961: #ifdef ENABLE_HYBRID
! 2962: #ifdef HAVE_LIBLDAP
! 2963: if (((yyvsp[(2) - (2)].num)<2)||((yyvsp[(2) - (2)].num)>3))
! 2964: yyerror("invalid ldap protocol version (2|3)");
! 2965: xauth_ldap_config.pver = (yyvsp[(2) - (2)].num);
! 2966: #endif
! 2967: #endif
! 2968: }
! 2969: break;
! 2970:
! 2971: case 94:
! 2972:
! 2973: /* Line 1455 of yacc.c */
! 2974: #line 634 "cfparse.y"
! 2975: {
! 2976: #ifdef ENABLE_HYBRID
! 2977: #ifdef HAVE_LIBLDAP
! 2978: if (xauth_ldap_config.host != NULL)
! 2979: vfree(xauth_ldap_config.host);
! 2980: xauth_ldap_config.host = vdup((yyvsp[(2) - (2)].val));
! 2981: #endif
! 2982: #endif
! 2983: }
! 2984: break;
! 2985:
! 2986: case 96:
! 2987:
! 2988: /* Line 1455 of yacc.c */
! 2989: #line 645 "cfparse.y"
! 2990: {
! 2991: #ifdef ENABLE_HYBRID
! 2992: #ifdef HAVE_LIBLDAP
! 2993: xauth_ldap_config.port = (yyvsp[(2) - (2)].num);
! 2994: #endif
! 2995: #endif
! 2996: }
! 2997: break;
! 2998:
! 2999: case 98:
! 3000:
! 3001: /* Line 1455 of yacc.c */
! 3002: #line 654 "cfparse.y"
! 3003: {
! 3004: #ifdef ENABLE_HYBRID
! 3005: #ifdef HAVE_LIBLDAP
! 3006: if (xauth_ldap_config.base != NULL)
! 3007: vfree(xauth_ldap_config.base);
! 3008: xauth_ldap_config.base = vdup((yyvsp[(2) - (2)].val));
! 3009: #endif
! 3010: #endif
! 3011: }
! 3012: break;
! 3013:
! 3014: case 100:
! 3015:
! 3016: /* Line 1455 of yacc.c */
! 3017: #line 665 "cfparse.y"
! 3018: {
! 3019: #ifdef ENABLE_HYBRID
! 3020: #ifdef HAVE_LIBLDAP
! 3021: xauth_ldap_config.subtree = (yyvsp[(2) - (2)].num);
! 3022: #endif
! 3023: #endif
! 3024: }
! 3025: break;
! 3026:
! 3027: case 102:
! 3028:
! 3029: /* Line 1455 of yacc.c */
! 3030: #line 674 "cfparse.y"
! 3031: {
! 3032: #ifdef ENABLE_HYBRID
! 3033: #ifdef HAVE_LIBLDAP
! 3034: if (xauth_ldap_config.bind_dn != NULL)
! 3035: vfree(xauth_ldap_config.bind_dn);
! 3036: xauth_ldap_config.bind_dn = vdup((yyvsp[(2) - (2)].val));
! 3037: #endif
! 3038: #endif
! 3039: }
! 3040: break;
! 3041:
! 3042: case 104:
! 3043:
! 3044: /* Line 1455 of yacc.c */
! 3045: #line 685 "cfparse.y"
! 3046: {
! 3047: #ifdef ENABLE_HYBRID
! 3048: #ifdef HAVE_LIBLDAP
! 3049: if (xauth_ldap_config.bind_pw != NULL)
! 3050: vfree(xauth_ldap_config.bind_pw);
! 3051: xauth_ldap_config.bind_pw = vdup((yyvsp[(2) - (2)].val));
! 3052: #endif
! 3053: #endif
! 3054: }
! 3055: break;
! 3056:
! 3057: case 106:
! 3058:
! 3059: /* Line 1455 of yacc.c */
! 3060: #line 696 "cfparse.y"
! 3061: {
! 3062: #ifdef ENABLE_HYBRID
! 3063: #ifdef HAVE_LIBLDAP
! 3064: if (xauth_ldap_config.attr_user != NULL)
! 3065: vfree(xauth_ldap_config.attr_user);
! 3066: xauth_ldap_config.attr_user = vdup((yyvsp[(2) - (2)].val));
! 3067: #endif
! 3068: #endif
! 3069: }
! 3070: break;
! 3071:
! 3072: case 108:
! 3073:
! 3074: /* Line 1455 of yacc.c */
! 3075: #line 707 "cfparse.y"
! 3076: {
! 3077: #ifdef ENABLE_HYBRID
! 3078: #ifdef HAVE_LIBLDAP
! 3079: if (xauth_ldap_config.attr_addr != NULL)
! 3080: vfree(xauth_ldap_config.attr_addr);
! 3081: xauth_ldap_config.attr_addr = vdup((yyvsp[(2) - (2)].val));
! 3082: #endif
! 3083: #endif
! 3084: }
! 3085: break;
! 3086:
! 3087: case 110:
! 3088:
! 3089: /* Line 1455 of yacc.c */
! 3090: #line 718 "cfparse.y"
! 3091: {
! 3092: #ifdef ENABLE_HYBRID
! 3093: #ifdef HAVE_LIBLDAP
! 3094: if (xauth_ldap_config.attr_mask != NULL)
! 3095: vfree(xauth_ldap_config.attr_mask);
! 3096: xauth_ldap_config.attr_mask = vdup((yyvsp[(2) - (2)].val));
! 3097: #endif
! 3098: #endif
! 3099: }
! 3100: break;
! 3101:
! 3102: case 112:
! 3103:
! 3104: /* Line 1455 of yacc.c */
! 3105: #line 729 "cfparse.y"
! 3106: {
! 3107: #ifdef ENABLE_HYBRID
! 3108: #ifdef HAVE_LIBLDAP
! 3109: if (xauth_ldap_config.attr_group != NULL)
! 3110: vfree(xauth_ldap_config.attr_group);
! 3111: xauth_ldap_config.attr_group = vdup((yyvsp[(2) - (2)].val));
! 3112: #endif
! 3113: #endif
! 3114: }
! 3115: break;
! 3116:
! 3117: case 114:
! 3118:
! 3119: /* Line 1455 of yacc.c */
! 3120: #line 740 "cfparse.y"
! 3121: {
! 3122: #ifdef ENABLE_HYBRID
! 3123: #ifdef HAVE_LIBLDAP
! 3124: if (xauth_ldap_config.attr_member != NULL)
! 3125: vfree(xauth_ldap_config.attr_member);
! 3126: xauth_ldap_config.attr_member = vdup((yyvsp[(2) - (2)].val));
! 3127: #endif
! 3128: #endif
! 3129: }
! 3130: break;
! 3131:
! 3132: case 119:
! 3133:
! 3134: /* Line 1455 of yacc.c */
! 3135: #line 762 "cfparse.y"
! 3136: {
! 3137: #ifdef ENABLE_HYBRID
! 3138: if (inet_pton(AF_INET, (yyvsp[(2) - (2)].val)->v,
! 3139: &isakmp_cfg_config.network4) != 1)
! 3140: yyerror("bad IPv4 network address.");
! 3141: #else
! 3142: yyerror("racoon not configured with --enable-hybrid");
! 3143: #endif
! 3144: }
! 3145: break;
! 3146:
! 3147: case 121:
! 3148:
! 3149: /* Line 1455 of yacc.c */
! 3150: #line 773 "cfparse.y"
! 3151: {
! 3152: #ifdef ENABLE_HYBRID
! 3153: if (inet_pton(AF_INET, (yyvsp[(2) - (2)].val)->v,
! 3154: &isakmp_cfg_config.netmask4) != 1)
! 3155: yyerror("bad IPv4 netmask address.");
! 3156: #else
! 3157: yyerror("racoon not configured with --enable-hybrid");
! 3158: #endif
! 3159: }
! 3160: break;
! 3161:
! 3162: case 125:
! 3163:
! 3164: /* Line 1455 of yacc.c */
! 3165: #line 788 "cfparse.y"
! 3166: {
! 3167: #ifdef ENABLE_HYBRID
! 3168: isakmp_cfg_config.splitnet_type = UNITY_LOCAL_LAN;
! 3169: #else
! 3170: yyerror("racoon not configured with --enable-hybrid");
! 3171: #endif
! 3172: }
! 3173: break;
! 3174:
! 3175: case 127:
! 3176:
! 3177: /* Line 1455 of yacc.c */
! 3178: #line 797 "cfparse.y"
! 3179: {
! 3180: #ifdef ENABLE_HYBRID
! 3181: isakmp_cfg_config.splitnet_type = UNITY_SPLIT_INCLUDE;
! 3182: #else
! 3183: yyerror("racoon not configured with --enable-hybrid");
! 3184: #endif
! 3185: }
! 3186: break;
! 3187:
! 3188: case 129:
! 3189:
! 3190: /* Line 1455 of yacc.c */
! 3191: #line 806 "cfparse.y"
! 3192: {
! 3193: #ifndef ENABLE_HYBRID
! 3194: yyerror("racoon not configured with --enable-hybrid");
! 3195: #endif
! 3196: }
! 3197: break;
! 3198:
! 3199: case 131:
! 3200:
! 3201: /* Line 1455 of yacc.c */
! 3202: #line 813 "cfparse.y"
! 3203: {
! 3204: #ifdef ENABLE_HYBRID
! 3205: strncpy(&isakmp_cfg_config.default_domain[0],
! 3206: (yyvsp[(2) - (2)].val)->v, MAXPATHLEN);
! 3207: isakmp_cfg_config.default_domain[MAXPATHLEN] = '\0';
! 3208: vfree((yyvsp[(2) - (2)].val));
! 3209: #else
! 3210: yyerror("racoon not configured with --enable-hybrid");
! 3211: #endif
! 3212: }
! 3213: break;
! 3214:
! 3215: case 133:
! 3216:
! 3217: /* Line 1455 of yacc.c */
! 3218: #line 825 "cfparse.y"
! 3219: {
! 3220: #ifdef ENABLE_HYBRID
! 3221: isakmp_cfg_config.authsource = ISAKMP_CFG_AUTH_SYSTEM;
! 3222: #else
! 3223: yyerror("racoon not configured with --enable-hybrid");
! 3224: #endif
! 3225: }
! 3226: break;
! 3227:
! 3228: case 135:
! 3229:
! 3230: /* Line 1455 of yacc.c */
! 3231: #line 834 "cfparse.y"
! 3232: {
! 3233: #ifdef ENABLE_HYBRID
! 3234: #ifdef HAVE_LIBRADIUS
! 3235: isakmp_cfg_config.authsource = ISAKMP_CFG_AUTH_RADIUS;
! 3236: #else /* HAVE_LIBRADIUS */
! 3237: yyerror("racoon not configured with --with-libradius");
! 3238: #endif /* HAVE_LIBRADIUS */
! 3239: #else /* ENABLE_HYBRID */
! 3240: yyerror("racoon not configured with --enable-hybrid");
! 3241: #endif /* ENABLE_HYBRID */
! 3242: }
! 3243: break;
! 3244:
! 3245: case 137:
! 3246:
! 3247: /* Line 1455 of yacc.c */
! 3248: #line 847 "cfparse.y"
! 3249: {
! 3250: #ifdef ENABLE_HYBRID
! 3251: #ifdef HAVE_LIBPAM
! 3252: isakmp_cfg_config.authsource = ISAKMP_CFG_AUTH_PAM;
! 3253: #else /* HAVE_LIBPAM */
! 3254: yyerror("racoon not configured with --with-libpam");
! 3255: #endif /* HAVE_LIBPAM */
! 3256: #else /* ENABLE_HYBRID */
! 3257: yyerror("racoon not configured with --enable-hybrid");
! 3258: #endif /* ENABLE_HYBRID */
! 3259: }
! 3260: break;
! 3261:
! 3262: case 139:
! 3263:
! 3264: /* Line 1455 of yacc.c */
! 3265: #line 860 "cfparse.y"
! 3266: {
! 3267: #ifdef ENABLE_HYBRID
! 3268: #ifdef HAVE_LIBLDAP
! 3269: isakmp_cfg_config.authsource = ISAKMP_CFG_AUTH_LDAP;
! 3270: #else /* HAVE_LIBLDAP */
! 3271: yyerror("racoon not configured with --with-libldap");
! 3272: #endif /* HAVE_LIBLDAP */
! 3273: #else /* ENABLE_HYBRID */
! 3274: yyerror("racoon not configured with --enable-hybrid");
! 3275: #endif /* ENABLE_HYBRID */
! 3276: }
! 3277: break;
! 3278:
! 3279: case 141:
! 3280:
! 3281: /* Line 1455 of yacc.c */
! 3282: #line 873 "cfparse.y"
! 3283: {
! 3284: #ifndef ENABLE_HYBRID
! 3285: yyerror("racoon not configured with --enable-hybrid");
! 3286: #endif
! 3287: }
! 3288: break;
! 3289:
! 3290: case 143:
! 3291:
! 3292: /* Line 1455 of yacc.c */
! 3293: #line 880 "cfparse.y"
! 3294: {
! 3295: #ifdef ENABLE_HYBRID
! 3296: isakmp_cfg_config.groupsource = ISAKMP_CFG_GROUP_SYSTEM;
! 3297: #else
! 3298: yyerror("racoon not configured with --enable-hybrid");
! 3299: #endif
! 3300: }
! 3301: break;
! 3302:
! 3303: case 145:
! 3304:
! 3305: /* Line 1455 of yacc.c */
! 3306: #line 889 "cfparse.y"
! 3307: {
! 3308: #ifdef ENABLE_HYBRID
! 3309: #ifdef HAVE_LIBLDAP
! 3310: isakmp_cfg_config.groupsource = ISAKMP_CFG_GROUP_LDAP;
! 3311: #else /* HAVE_LIBLDAP */
! 3312: yyerror("racoon not configured with --with-libldap");
! 3313: #endif /* HAVE_LIBLDAP */
! 3314: #else /* ENABLE_HYBRID */
! 3315: yyerror("racoon not configured with --enable-hybrid");
! 3316: #endif /* ENABLE_HYBRID */
! 3317: }
! 3318: break;
! 3319:
! 3320: case 147:
! 3321:
! 3322: /* Line 1455 of yacc.c */
! 3323: #line 902 "cfparse.y"
! 3324: {
! 3325: #ifdef ENABLE_HYBRID
! 3326: isakmp_cfg_config.accounting = ISAKMP_CFG_ACCT_NONE;
! 3327: #else
! 3328: yyerror("racoon not configured with --enable-hybrid");
! 3329: #endif
! 3330: }
! 3331: break;
! 3332:
! 3333: case 149:
! 3334:
! 3335: /* Line 1455 of yacc.c */
! 3336: #line 911 "cfparse.y"
! 3337: {
! 3338: #ifdef ENABLE_HYBRID
! 3339: isakmp_cfg_config.accounting = ISAKMP_CFG_ACCT_SYSTEM;
! 3340: #else
! 3341: yyerror("racoon not configured with --enable-hybrid");
! 3342: #endif
! 3343: }
! 3344: break;
! 3345:
! 3346: case 151:
! 3347:
! 3348: /* Line 1455 of yacc.c */
! 3349: #line 920 "cfparse.y"
! 3350: {
! 3351: #ifdef ENABLE_HYBRID
! 3352: #ifdef HAVE_LIBRADIUS
! 3353: isakmp_cfg_config.accounting = ISAKMP_CFG_ACCT_RADIUS;
! 3354: #else /* HAVE_LIBRADIUS */
! 3355: yyerror("racoon not configured with --with-libradius");
! 3356: #endif /* HAVE_LIBRADIUS */
! 3357: #else /* ENABLE_HYBRID */
! 3358: yyerror("racoon not configured with --enable-hybrid");
! 3359: #endif /* ENABLE_HYBRID */
! 3360: }
! 3361: break;
! 3362:
! 3363: case 153:
! 3364:
! 3365: /* Line 1455 of yacc.c */
! 3366: #line 933 "cfparse.y"
! 3367: {
! 3368: #ifdef ENABLE_HYBRID
! 3369: #ifdef HAVE_LIBPAM
! 3370: isakmp_cfg_config.accounting = ISAKMP_CFG_ACCT_PAM;
! 3371: #else /* HAVE_LIBPAM */
! 3372: yyerror("racoon not configured with --with-libpam");
! 3373: #endif /* HAVE_LIBPAM */
! 3374: #else /* ENABLE_HYBRID */
! 3375: yyerror("racoon not configured with --enable-hybrid");
! 3376: #endif /* ENABLE_HYBRID */
! 3377: }
! 3378: break;
! 3379:
! 3380: case 155:
! 3381:
! 3382: /* Line 1455 of yacc.c */
! 3383: #line 946 "cfparse.y"
! 3384: {
! 3385: #ifdef ENABLE_HYBRID
! 3386: if (isakmp_cfg_resize_pool((yyvsp[(2) - (2)].num)) != 0)
! 3387: yyerror("cannot allocate memory for pool");
! 3388: #else /* ENABLE_HYBRID */
! 3389: yyerror("racoon not configured with --enable-hybrid");
! 3390: #endif /* ENABLE_HYBRID */
! 3391: }
! 3392: break;
! 3393:
! 3394: case 157:
! 3395:
! 3396: /* Line 1455 of yacc.c */
! 3397: #line 956 "cfparse.y"
! 3398: {
! 3399: #ifdef ENABLE_HYBRID
! 3400: isakmp_cfg_config.pfs_group = (yyvsp[(2) - (2)].num);
! 3401: #else /* ENABLE_HYBRID */
! 3402: yyerror("racoon not configured with --enable-hybrid");
! 3403: #endif /* ENABLE_HYBRID */
! 3404: }
! 3405: break;
! 3406:
! 3407: case 159:
! 3408:
! 3409: /* Line 1455 of yacc.c */
! 3410: #line 965 "cfparse.y"
! 3411: {
! 3412: #ifdef ENABLE_HYBRID
! 3413: isakmp_cfg_config.save_passwd = (yyvsp[(2) - (2)].num);
! 3414: #else /* ENABLE_HYBRID */
! 3415: yyerror("racoon not configured with --enable-hybrid");
! 3416: #endif /* ENABLE_HYBRID */
! 3417: }
! 3418: break;
! 3419:
! 3420: case 161:
! 3421:
! 3422: /* Line 1455 of yacc.c */
! 3423: #line 974 "cfparse.y"
! 3424: {
! 3425: #ifdef ENABLE_HYBRID
! 3426: isakmp_cfg_config.auth_throttle = (yyvsp[(2) - (2)].num);
! 3427: #else /* ENABLE_HYBRID */
! 3428: yyerror("racoon not configured with --enable-hybrid");
! 3429: #endif /* ENABLE_HYBRID */
! 3430: }
! 3431: break;
! 3432:
! 3433: case 163:
! 3434:
! 3435: /* Line 1455 of yacc.c */
! 3436: #line 983 "cfparse.y"
! 3437: {
! 3438: #ifdef ENABLE_HYBRID
! 3439: isakmp_cfg_config.confsource = ISAKMP_CFG_CONF_LOCAL;
! 3440: #else /* ENABLE_HYBRID */
! 3441: yyerror("racoon not configured with --enable-hybrid");
! 3442: #endif /* ENABLE_HYBRID */
! 3443: }
! 3444: break;
! 3445:
! 3446: case 165:
! 3447:
! 3448: /* Line 1455 of yacc.c */
! 3449: #line 992 "cfparse.y"
! 3450: {
! 3451: #ifdef ENABLE_HYBRID
! 3452: #ifdef HAVE_LIBRADIUS
! 3453: isakmp_cfg_config.confsource = ISAKMP_CFG_CONF_RADIUS;
! 3454: #else /* HAVE_LIBRADIUS */
! 3455: yyerror("racoon not configured with --with-libradius");
! 3456: #endif /* HAVE_LIBRADIUS */
! 3457: #else /* ENABLE_HYBRID */
! 3458: yyerror("racoon not configured with --enable-hybrid");
! 3459: #endif /* ENABLE_HYBRID */
! 3460: }
! 3461: break;
! 3462:
! 3463: case 167:
! 3464:
! 3465: /* Line 1455 of yacc.c */
! 3466: #line 1005 "cfparse.y"
! 3467: {
! 3468: #ifdef ENABLE_HYBRID
! 3469: #ifdef HAVE_LIBLDAP
! 3470: isakmp_cfg_config.confsource = ISAKMP_CFG_CONF_LDAP;
! 3471: #else /* HAVE_LIBLDAP */
! 3472: yyerror("racoon not configured with --with-libldap");
! 3473: #endif /* HAVE_LIBLDAP */
! 3474: #else /* ENABLE_HYBRID */
! 3475: yyerror("racoon not configured with --enable-hybrid");
! 3476: #endif /* ENABLE_HYBRID */
! 3477: }
! 3478: break;
! 3479:
! 3480: case 169:
! 3481:
! 3482: /* Line 1455 of yacc.c */
! 3483: #line 1018 "cfparse.y"
! 3484: {
! 3485: #ifdef ENABLE_HYBRID
! 3486: strncpy(&isakmp_cfg_config.motd[0], (yyvsp[(2) - (2)].val)->v, MAXPATHLEN);
! 3487: isakmp_cfg_config.motd[MAXPATHLEN] = '\0';
! 3488: vfree((yyvsp[(2) - (2)].val));
! 3489: #else
! 3490: yyerror("racoon not configured with --enable-hybrid");
! 3491: #endif
! 3492: }
! 3493: break;
! 3494:
! 3495: case 173:
! 3496:
! 3497: /* Line 1455 of yacc.c */
! 3498: #line 1036 "cfparse.y"
! 3499: {
! 3500: #ifdef ENABLE_HYBRID
! 3501: struct isakmp_cfg_config *icc = &isakmp_cfg_config;
! 3502:
! 3503: if (icc->dns4_index > MAXNS)
! 3504: yyerror("No more than %d DNS", MAXNS);
! 3505: if (inet_pton(AF_INET, (yyvsp[(1) - (1)].val)->v,
! 3506: &icc->dns4[icc->dns4_index++]) != 1)
! 3507: yyerror("bad IPv4 DNS address.");
! 3508: #else
! 3509: yyerror("racoon not configured with --enable-hybrid");
! 3510: #endif
! 3511: }
! 3512: break;
! 3513:
! 3514: case 176:
! 3515:
! 3516: /* Line 1455 of yacc.c */
! 3517: #line 1057 "cfparse.y"
! 3518: {
! 3519: #ifdef ENABLE_HYBRID
! 3520: struct isakmp_cfg_config *icc = &isakmp_cfg_config;
! 3521:
! 3522: if (icc->nbns4_index > MAXWINS)
! 3523: yyerror("No more than %d WINS", MAXWINS);
! 3524: if (inet_pton(AF_INET, (yyvsp[(1) - (1)].val)->v,
! 3525: &icc->nbns4[icc->nbns4_index++]) != 1)
! 3526: yyerror("bad IPv4 WINS address.");
! 3527: #else
! 3528: yyerror("racoon not configured with --enable-hybrid");
! 3529: #endif
! 3530: }
! 3531: break;
! 3532:
! 3533: case 179:
! 3534:
! 3535: /* Line 1455 of yacc.c */
! 3536: #line 1078 "cfparse.y"
! 3537: {
! 3538: #ifdef ENABLE_HYBRID
! 3539: struct isakmp_cfg_config *icc = &isakmp_cfg_config;
! 3540: struct unity_network network;
! 3541: memset(&network,0,sizeof(network));
! 3542:
! 3543: if (inet_pton(AF_INET, (yyvsp[(1) - (2)].val)->v, &network.addr4) != 1)
! 3544: yyerror("bad IPv4 SPLIT address.");
! 3545:
! 3546: /* Turn $2 (the prefix) into a subnet mask */
! 3547: network.mask4.s_addr = ((yyvsp[(2) - (2)].num)) ? htonl(~((1 << (32 - (yyvsp[(2) - (2)].num))) - 1)) : 0;
! 3548:
! 3549: /* add the network to our list */
! 3550: if (splitnet_list_add(&icc->splitnet_list, &network,&icc->splitnet_count))
! 3551: yyerror("Unable to allocate split network");
! 3552: #else
! 3553: yyerror("racoon not configured with --enable-hybrid");
! 3554: #endif
! 3555: }
! 3556: break;
! 3557:
! 3558: case 182:
! 3559:
! 3560: /* Line 1455 of yacc.c */
! 3561: #line 1105 "cfparse.y"
! 3562: {
! 3563: #ifdef ENABLE_HYBRID
! 3564: char * groupname = NULL;
! 3565: char ** grouplist = NULL;
! 3566: struct isakmp_cfg_config *icc = &isakmp_cfg_config;
! 3567:
! 3568: grouplist = racoon_realloc(icc->grouplist,
! 3569: sizeof(char**)*(icc->groupcount+1));
! 3570: if (grouplist == NULL) {
! 3571: yyerror("unable to allocate auth group list");
! 3572: return -1;
! 3573: }
! 3574:
! 3575: groupname = racoon_malloc((yyvsp[(1) - (1)].val)->l+1);
! 3576: if (groupname == NULL) {
! 3577: yyerror("unable to allocate auth group name");
! 3578: return -1;
! 3579: }
! 3580:
! 3581: memcpy(groupname,(yyvsp[(1) - (1)].val)->v,(yyvsp[(1) - (1)].val)->l);
! 3582: groupname[(yyvsp[(1) - (1)].val)->l]=0;
! 3583: grouplist[icc->groupcount]=groupname;
! 3584: icc->grouplist = grouplist;
! 3585: icc->groupcount++;
! 3586:
! 3587: vfree((yyvsp[(1) - (1)].val));
! 3588: #else
! 3589: yyerror("racoon not configured with --enable-hybrid");
! 3590: #endif
! 3591: }
! 3592: break;
! 3593:
! 3594: case 185:
! 3595:
! 3596: /* Line 1455 of yacc.c */
! 3597: #line 1143 "cfparse.y"
! 3598: {
! 3599: #ifdef ENABLE_HYBRID
! 3600: struct isakmp_cfg_config *icc = &isakmp_cfg_config;
! 3601:
! 3602: if (!icc->splitdns_len)
! 3603: {
! 3604: icc->splitdns_list = racoon_malloc((yyvsp[(1) - (1)].val)->l);
! 3605: if(icc->splitdns_list == NULL) {
! 3606: yyerror("error allocating splitdns list buffer");
! 3607: return -1;
! 3608: }
! 3609: memcpy(icc->splitdns_list,(yyvsp[(1) - (1)].val)->v,(yyvsp[(1) - (1)].val)->l);
! 3610: icc->splitdns_len = (yyvsp[(1) - (1)].val)->l;
! 3611: }
! 3612: else
! 3613: {
! 3614: int len = icc->splitdns_len + (yyvsp[(1) - (1)].val)->l + 1;
! 3615: icc->splitdns_list = racoon_realloc(icc->splitdns_list,len);
! 3616: if(icc->splitdns_list == NULL) {
! 3617: yyerror("error allocating splitdns list buffer");
! 3618: return -1;
! 3619: }
! 3620: icc->splitdns_list[icc->splitdns_len] = ',';
! 3621: memcpy(icc->splitdns_list + icc->splitdns_len + 1, (yyvsp[(1) - (1)].val)->v, (yyvsp[(1) - (1)].val)->l);
! 3622: icc->splitdns_len = len;
! 3623: }
! 3624: vfree((yyvsp[(1) - (1)].val));
! 3625: #else
! 3626: yyerror("racoon not configured with --enable-hybrid");
! 3627: #endif
! 3628: }
! 3629: break;
! 3630:
! 3631: case 189:
! 3632:
! 3633: /* Line 1455 of yacc.c */
! 3634: #line 1187 "cfparse.y"
! 3635: {
! 3636: lcconf->retry_counter = (yyvsp[(2) - (2)].num);
! 3637: }
! 3638: break;
! 3639:
! 3640: case 191:
! 3641:
! 3642: /* Line 1455 of yacc.c */
! 3643: #line 1192 "cfparse.y"
! 3644: {
! 3645: lcconf->retry_interval = (yyvsp[(2) - (3)].num) * (yyvsp[(3) - (3)].num);
! 3646: }
! 3647: break;
! 3648:
! 3649: case 193:
! 3650:
! 3651: /* Line 1455 of yacc.c */
! 3652: #line 1197 "cfparse.y"
! 3653: {
! 3654: lcconf->count_persend = (yyvsp[(2) - (2)].num);
! 3655: }
! 3656: break;
! 3657:
! 3658: case 195:
! 3659:
! 3660: /* Line 1455 of yacc.c */
! 3661: #line 1202 "cfparse.y"
! 3662: {
! 3663: lcconf->retry_checkph1 = (yyvsp[(2) - (3)].num) * (yyvsp[(3) - (3)].num);
! 3664: }
! 3665: break;
! 3666:
! 3667: case 197:
! 3668:
! 3669: /* Line 1455 of yacc.c */
! 3670: #line 1207 "cfparse.y"
! 3671: {
! 3672: lcconf->wait_ph2complete = (yyvsp[(2) - (3)].num) * (yyvsp[(3) - (3)].num);
! 3673: }
! 3674: break;
! 3675:
! 3676: case 199:
! 3677:
! 3678: /* Line 1455 of yacc.c */
! 3679: #line 1212 "cfparse.y"
! 3680: {
! 3681: #ifdef ENABLE_NATT
! 3682: if (libipsec_opt & LIBIPSEC_OPT_NATT)
! 3683: lcconf->natt_ka_interval = (yyvsp[(2) - (3)].num) * (yyvsp[(3) - (3)].num);
! 3684: else
! 3685: yyerror("libipsec lacks NAT-T support");
! 3686: #else
! 3687: yyerror("NAT-T support not compiled in.");
! 3688: #endif
! 3689: }
! 3690: break;
! 3691:
! 3692: case 201:
! 3693:
! 3694: /* Line 1455 of yacc.c */
! 3695: #line 1228 "cfparse.y"
! 3696: {
! 3697: cur_sainfo = newsainfo();
! 3698: if (cur_sainfo == NULL) {
! 3699: yyerror("failed to allocate sainfo");
! 3700: return -1;
! 3701: }
! 3702: }
! 3703: break;
! 3704:
! 3705: case 202:
! 3706:
! 3707: /* Line 1455 of yacc.c */
! 3708: #line 1236 "cfparse.y"
! 3709: {
! 3710: struct sainfo *check;
! 3711:
! 3712: /* default */
! 3713: if (cur_sainfo->algs[algclass_ipsec_enc] == 0) {
! 3714: yyerror("no encryption algorithm at %s",
! 3715: sainfo2str(cur_sainfo));
! 3716: return -1;
! 3717: }
! 3718: if (cur_sainfo->algs[algclass_ipsec_auth] == 0) {
! 3719: yyerror("no authentication algorithm at %s",
! 3720: sainfo2str(cur_sainfo));
! 3721: return -1;
! 3722: }
! 3723: if (cur_sainfo->algs[algclass_ipsec_comp] == 0) {
! 3724: yyerror("no compression algorithm at %s",
! 3725: sainfo2str(cur_sainfo));
! 3726: return -1;
! 3727: }
! 3728:
! 3729: /* duplicate check */
! 3730: check = getsainfo(cur_sainfo->idsrc,
! 3731: cur_sainfo->iddst,
! 3732: cur_sainfo->id_i,
! 3733: NULL,
! 3734: cur_sainfo->remoteid);
! 3735:
! 3736: if (check && ((check->idsrc != SAINFO_ANONYMOUS) &&
! 3737: (cur_sainfo->idsrc != SAINFO_ANONYMOUS))) {
! 3738: yyerror("duplicated sainfo: %s",
! 3739: sainfo2str(cur_sainfo));
! 3740: return -1;
! 3741: }
! 3742:
! 3743: inssainfo(cur_sainfo);
! 3744: }
! 3745: break;
! 3746:
! 3747: case 204:
! 3748:
! 3749: /* Line 1455 of yacc.c */
! 3750: #line 1276 "cfparse.y"
! 3751: {
! 3752: cur_sainfo->idsrc = SAINFO_ANONYMOUS;
! 3753: cur_sainfo->iddst = SAINFO_ANONYMOUS;
! 3754: }
! 3755: break;
! 3756:
! 3757: case 205:
! 3758:
! 3759: /* Line 1455 of yacc.c */
! 3760: #line 1281 "cfparse.y"
! 3761: {
! 3762: cur_sainfo->idsrc = SAINFO_ANONYMOUS;
! 3763: cur_sainfo->iddst = SAINFO_CLIENTADDR;
! 3764: }
! 3765: break;
! 3766:
! 3767: case 206:
! 3768:
! 3769: /* Line 1455 of yacc.c */
! 3770: #line 1286 "cfparse.y"
! 3771: {
! 3772: cur_sainfo->idsrc = SAINFO_ANONYMOUS;
! 3773: cur_sainfo->iddst = (yyvsp[(2) - (2)].val);
! 3774: }
! 3775: break;
! 3776:
! 3777: case 207:
! 3778:
! 3779: /* Line 1455 of yacc.c */
! 3780: #line 1291 "cfparse.y"
! 3781: {
! 3782: cur_sainfo->idsrc = (yyvsp[(1) - (2)].val);
! 3783: cur_sainfo->iddst = SAINFO_ANONYMOUS;
! 3784: }
! 3785: break;
! 3786:
! 3787: case 208:
! 3788:
! 3789: /* Line 1455 of yacc.c */
! 3790: #line 1296 "cfparse.y"
! 3791: {
! 3792: cur_sainfo->idsrc = (yyvsp[(1) - (2)].val);
! 3793: cur_sainfo->iddst = SAINFO_CLIENTADDR;
! 3794: }
! 3795: break;
! 3796:
! 3797: case 209:
! 3798:
! 3799: /* Line 1455 of yacc.c */
! 3800: #line 1301 "cfparse.y"
! 3801: {
! 3802: cur_sainfo->idsrc = (yyvsp[(1) - (2)].val);
! 3803: cur_sainfo->iddst = (yyvsp[(2) - (2)].val);
! 3804: }
! 3805: break;
! 3806:
! 3807: case 210:
! 3808:
! 3809: /* Line 1455 of yacc.c */
! 3810: #line 1308 "cfparse.y"
! 3811: {
! 3812: char portbuf[10];
! 3813: struct sockaddr *saddr;
! 3814:
! 3815: if (((yyvsp[(5) - (5)].num) == IPPROTO_ICMP || (yyvsp[(5) - (5)].num) == IPPROTO_ICMPV6)
! 3816: && ((yyvsp[(4) - (5)].num) != IPSEC_PORT_ANY || (yyvsp[(4) - (5)].num) != IPSEC_PORT_ANY)) {
! 3817: yyerror("port number must be \"any\".");
! 3818: return -1;
! 3819: }
! 3820:
! 3821: snprintf(portbuf, sizeof(portbuf), "%lu", (yyvsp[(4) - (5)].num));
! 3822: saddr = str2saddr((yyvsp[(2) - (5)].val)->v, portbuf);
! 3823: vfree((yyvsp[(2) - (5)].val));
! 3824: if (saddr == NULL)
! 3825: return -1;
! 3826:
! 3827: switch (saddr->sa_family) {
! 3828: case AF_INET:
! 3829: if ((yyvsp[(5) - (5)].num) == IPPROTO_ICMPV6) {
! 3830: yyerror("upper layer protocol mismatched.\n");
! 3831: racoon_free(saddr);
! 3832: return -1;
! 3833: }
! 3834: (yyval.val) = ipsecdoi_sockaddr2id(saddr,
! 3835: (yyvsp[(3) - (5)].num) == ~0 ? (sizeof(struct in_addr) << 3): (yyvsp[(3) - (5)].num),
! 3836: (yyvsp[(5) - (5)].num));
! 3837: break;
! 3838: #ifdef INET6
! 3839: case AF_INET6:
! 3840: if ((yyvsp[(5) - (5)].num) == IPPROTO_ICMP) {
! 3841: yyerror("upper layer protocol mismatched.\n");
! 3842: racoon_free(saddr);
! 3843: return -1;
! 3844: }
! 3845: (yyval.val) = ipsecdoi_sockaddr2id(saddr,
! 3846: (yyvsp[(3) - (5)].num) == ~0 ? (sizeof(struct in6_addr) << 3): (yyvsp[(3) - (5)].num),
! 3847: (yyvsp[(5) - (5)].num));
! 3848: break;
! 3849: #endif
! 3850: default:
! 3851: yyerror("invalid family: %d", saddr->sa_family);
! 3852: (yyval.val) = NULL;
! 3853: break;
! 3854: }
! 3855: racoon_free(saddr);
! 3856: if ((yyval.val) == NULL)
! 3857: return -1;
! 3858: }
! 3859: break;
! 3860:
! 3861: case 211:
! 3862:
! 3863: /* Line 1455 of yacc.c */
! 3864: #line 1357 "cfparse.y"
! 3865: {
! 3866: char portbuf[10];
! 3867: struct sockaddr *laddr = NULL, *haddr = NULL;
! 3868: char *cur = NULL;
! 3869:
! 3870: if (((yyvsp[(6) - (6)].num) == IPPROTO_ICMP || (yyvsp[(6) - (6)].num) == IPPROTO_ICMPV6)
! 3871: && ((yyvsp[(5) - (6)].num) != IPSEC_PORT_ANY || (yyvsp[(5) - (6)].num) != IPSEC_PORT_ANY)) {
! 3872: yyerror("port number must be \"any\".");
! 3873: return -1;
! 3874: }
! 3875:
! 3876: snprintf(portbuf, sizeof(portbuf), "%lu", (yyvsp[(5) - (6)].num));
! 3877:
! 3878: laddr = str2saddr((yyvsp[(2) - (6)].val)->v, portbuf);
! 3879: if (laddr == NULL) {
! 3880: return -1;
! 3881: }
! 3882: vfree((yyvsp[(2) - (6)].val));
! 3883: haddr = str2saddr((yyvsp[(3) - (6)].val)->v, portbuf);
! 3884: if (haddr == NULL) {
! 3885: racoon_free(laddr);
! 3886: return -1;
! 3887: }
! 3888: vfree((yyvsp[(3) - (6)].val));
! 3889:
! 3890: switch (laddr->sa_family) {
! 3891: case AF_INET:
! 3892: if ((yyvsp[(6) - (6)].num) == IPPROTO_ICMPV6) {
! 3893: yyerror("upper layer protocol mismatched.\n");
! 3894: if (laddr)
! 3895: racoon_free(laddr);
! 3896: if (haddr)
! 3897: racoon_free(haddr);
! 3898: return -1;
! 3899: }
! 3900: (yyval.val) = ipsecdoi_sockrange2id(laddr, haddr,
! 3901: (yyvsp[(6) - (6)].num));
! 3902: break;
! 3903: #ifdef INET6
! 3904: case AF_INET6:
! 3905: if ((yyvsp[(6) - (6)].num) == IPPROTO_ICMP) {
! 3906: yyerror("upper layer protocol mismatched.\n");
! 3907: if (laddr)
! 3908: racoon_free(laddr);
! 3909: if (haddr)
! 3910: racoon_free(haddr);
! 3911: return -1;
! 3912: }
! 3913: (yyval.val) = ipsecdoi_sockrange2id(laddr, haddr,
! 3914: (yyvsp[(6) - (6)].num));
! 3915: break;
! 3916: #endif
! 3917: default:
! 3918: yyerror("invalid family: %d", laddr->sa_family);
! 3919: (yyval.val) = NULL;
! 3920: break;
! 3921: }
! 3922: if (laddr)
! 3923: racoon_free(laddr);
! 3924: if (haddr)
! 3925: racoon_free(haddr);
! 3926: if ((yyval.val) == NULL)
! 3927: return -1;
! 3928: }
! 3929: break;
! 3930:
! 3931: case 212:
! 3932:
! 3933: /* Line 1455 of yacc.c */
! 3934: #line 1422 "cfparse.y"
! 3935: {
! 3936: struct ipsecdoi_id_b *id_b;
! 3937:
! 3938: if ((yyvsp[(1) - (2)].num) == IDTYPE_ASN1DN) {
! 3939: yyerror("id type forbidden: %d", (yyvsp[(1) - (2)].num));
! 3940: (yyval.val) = NULL;
! 3941: return -1;
! 3942: }
! 3943:
! 3944: (yyvsp[(2) - (2)].val)->l--;
! 3945:
! 3946: (yyval.val) = vmalloc(sizeof(*id_b) + (yyvsp[(2) - (2)].val)->l);
! 3947: if ((yyval.val) == NULL) {
! 3948: yyerror("failed to allocate identifier");
! 3949: return -1;
! 3950: }
! 3951:
! 3952: id_b = (struct ipsecdoi_id_b *)(yyval.val)->v;
! 3953: id_b->type = idtype2doi((yyvsp[(1) - (2)].num));
! 3954:
! 3955: id_b->proto_id = 0;
! 3956: id_b->port = 0;
! 3957:
! 3958: memcpy((yyval.val)->v + sizeof(*id_b), (yyvsp[(2) - (2)].val)->v, (yyvsp[(2) - (2)].val)->l);
! 3959: }
! 3960: break;
! 3961:
! 3962: case 213:
! 3963:
! 3964: /* Line 1455 of yacc.c */
! 3965: #line 1450 "cfparse.y"
! 3966: {
! 3967: cur_sainfo->id_i = NULL;
! 3968: }
! 3969: break;
! 3970:
! 3971: case 214:
! 3972:
! 3973: /* Line 1455 of yacc.c */
! 3974: #line 1454 "cfparse.y"
! 3975: {
! 3976: struct ipsecdoi_id_b *id_b;
! 3977: vchar_t *idv;
! 3978:
! 3979: if (set_identifier(&idv, (yyvsp[(2) - (3)].num), (yyvsp[(3) - (3)].val)) != 0) {
! 3980: yyerror("failed to set identifer.\n");
! 3981: return -1;
! 3982: }
! 3983: cur_sainfo->id_i = vmalloc(sizeof(*id_b) + idv->l);
! 3984: if (cur_sainfo->id_i == NULL) {
! 3985: yyerror("failed to allocate identifier");
! 3986: return -1;
! 3987: }
! 3988:
! 3989: id_b = (struct ipsecdoi_id_b *)cur_sainfo->id_i->v;
! 3990: id_b->type = idtype2doi((yyvsp[(2) - (3)].num));
! 3991:
! 3992: id_b->proto_id = 0;
! 3993: id_b->port = 0;
! 3994:
! 3995: memcpy(cur_sainfo->id_i->v + sizeof(*id_b),
! 3996: idv->v, idv->l);
! 3997: vfree(idv);
! 3998: }
! 3999: break;
! 4000:
! 4001: case 215:
! 4002:
! 4003: /* Line 1455 of yacc.c */
! 4004: #line 1479 "cfparse.y"
! 4005: {
! 4006: #ifdef ENABLE_HYBRID
! 4007: if ((cur_sainfo->group = vdup((yyvsp[(2) - (2)].val))) == NULL) {
! 4008: yyerror("failed to set sainfo xauth group.\n");
! 4009: return -1;
! 4010: }
! 4011: #else
! 4012: yyerror("racoon not configured with --enable-hybrid");
! 4013: return -1;
! 4014: #endif
! 4015: }
! 4016: break;
! 4017:
! 4018: case 218:
! 4019:
! 4020: /* Line 1455 of yacc.c */
! 4021: #line 1497 "cfparse.y"
! 4022: {
! 4023: cur_sainfo->pfs_group = (yyvsp[(2) - (2)].num);
! 4024: }
! 4025: break;
! 4026:
! 4027: case 220:
! 4028:
! 4029: /* Line 1455 of yacc.c */
! 4030: #line 1502 "cfparse.y"
! 4031: {
! 4032: cur_sainfo->remoteid = (yyvsp[(2) - (2)].num);
! 4033: }
! 4034: break;
! 4035:
! 4036: case 222:
! 4037:
! 4038: /* Line 1455 of yacc.c */
! 4039: #line 1507 "cfparse.y"
! 4040: {
! 4041: cur_sainfo->lifetime = (yyvsp[(3) - (4)].num) * (yyvsp[(4) - (4)].num);
! 4042: }
! 4043: break;
! 4044:
! 4045: case 224:
! 4046:
! 4047: /* Line 1455 of yacc.c */
! 4048: #line 1512 "cfparse.y"
! 4049: {
! 4050: #if 1
! 4051: yyerror("byte lifetime support is deprecated");
! 4052: return -1;
! 4053: #else
! 4054: cur_sainfo->lifebyte = fix_lifebyte((yyvsp[(3) - (4)].num) * (yyvsp[(4) - (4)].num));
! 4055: if (cur_sainfo->lifebyte == 0)
! 4056: return -1;
! 4057: #endif
! 4058: }
! 4059: break;
! 4060:
! 4061: case 226:
! 4062:
! 4063: /* Line 1455 of yacc.c */
! 4064: #line 1523 "cfparse.y"
! 4065: {
! 4066: cur_algclass = (yyvsp[(1) - (1)].num);
! 4067: }
! 4068: break;
! 4069:
! 4070: case 228:
! 4071:
! 4072: /* Line 1455 of yacc.c */
! 4073: #line 1531 "cfparse.y"
! 4074: {
! 4075: inssainfoalg(&cur_sainfo->algs[cur_algclass], (yyvsp[(1) - (1)].alg));
! 4076: }
! 4077: break;
! 4078:
! 4079: case 229:
! 4080:
! 4081: /* Line 1455 of yacc.c */
! 4082: #line 1535 "cfparse.y"
! 4083: {
! 4084: inssainfoalg(&cur_sainfo->algs[cur_algclass], (yyvsp[(1) - (1)].alg));
! 4085: }
! 4086: break;
! 4087:
! 4088: case 231:
! 4089:
! 4090: /* Line 1455 of yacc.c */
! 4091: #line 1542 "cfparse.y"
! 4092: {
! 4093: int defklen;
! 4094:
! 4095: (yyval.alg) = newsainfoalg();
! 4096: if ((yyval.alg) == NULL) {
! 4097: yyerror("failed to get algorithm allocation");
! 4098: return -1;
! 4099: }
! 4100:
! 4101: (yyval.alg)->alg = algtype2doi(cur_algclass, (yyvsp[(1) - (2)].num));
! 4102: if ((yyval.alg)->alg == -1) {
! 4103: yyerror("algorithm mismatched");
! 4104: racoon_free((yyval.alg));
! 4105: (yyval.alg) = NULL;
! 4106: return -1;
! 4107: }
! 4108:
! 4109: defklen = default_keylen(cur_algclass, (yyvsp[(1) - (2)].num));
! 4110: if (defklen == 0) {
! 4111: if ((yyvsp[(2) - (2)].num)) {
! 4112: yyerror("keylen not allowed");
! 4113: racoon_free((yyval.alg));
! 4114: (yyval.alg) = NULL;
! 4115: return -1;
! 4116: }
! 4117: } else {
! 4118: if ((yyvsp[(2) - (2)].num) && check_keylen(cur_algclass, (yyvsp[(1) - (2)].num), (yyvsp[(2) - (2)].num)) < 0) {
! 4119: yyerror("invalid keylen %d", (yyvsp[(2) - (2)].num));
! 4120: racoon_free((yyval.alg));
! 4121: (yyval.alg) = NULL;
! 4122: return -1;
! 4123: }
! 4124: }
! 4125:
! 4126: if ((yyvsp[(2) - (2)].num))
! 4127: (yyval.alg)->encklen = (yyvsp[(2) - (2)].num);
! 4128: else
! 4129: (yyval.alg)->encklen = defklen;
! 4130:
! 4131: /* check if it's supported algorithm by kernel */
! 4132: if (!(cur_algclass == algclass_ipsec_auth && (yyvsp[(1) - (2)].num) == algtype_non_auth)
! 4133: && pk_checkalg(cur_algclass, (yyvsp[(1) - (2)].num), (yyval.alg)->encklen)) {
! 4134: int a = algclass2doi(cur_algclass);
! 4135: int b = algtype2doi(cur_algclass, (yyvsp[(1) - (2)].num));
! 4136: if (a == IPSECDOI_ATTR_AUTH)
! 4137: a = IPSECDOI_PROTO_IPSEC_AH;
! 4138: yyerror("algorithm %s not supported by the kernel (missing module?)",
! 4139: s_ipsecdoi_trns(a, b));
! 4140: racoon_free((yyval.alg));
! 4141: (yyval.alg) = NULL;
! 4142: return -1;
! 4143: }
! 4144: }
! 4145: break;
! 4146:
! 4147: case 232:
! 4148:
! 4149: /* Line 1455 of yacc.c */
! 4150: #line 1597 "cfparse.y"
! 4151: { (yyval.num) = ~0; }
! 4152: break;
! 4153:
! 4154: case 233:
! 4155:
! 4156: /* Line 1455 of yacc.c */
! 4157: #line 1598 "cfparse.y"
! 4158: { (yyval.num) = (yyvsp[(1) - (1)].num); }
! 4159: break;
! 4160:
! 4161: case 234:
! 4162:
! 4163: /* Line 1455 of yacc.c */
! 4164: #line 1601 "cfparse.y"
! 4165: { (yyval.num) = IPSEC_PORT_ANY; }
! 4166: break;
! 4167:
! 4168: case 235:
! 4169:
! 4170: /* Line 1455 of yacc.c */
! 4171: #line 1602 "cfparse.y"
! 4172: { (yyval.num) = (yyvsp[(1) - (1)].num); }
! 4173: break;
! 4174:
! 4175: case 236:
! 4176:
! 4177: /* Line 1455 of yacc.c */
! 4178: #line 1603 "cfparse.y"
! 4179: { (yyval.num) = IPSEC_PORT_ANY; }
! 4180: break;
! 4181:
! 4182: case 237:
! 4183:
! 4184: /* Line 1455 of yacc.c */
! 4185: #line 1606 "cfparse.y"
! 4186: { (yyval.num) = (yyvsp[(1) - (1)].num); }
! 4187: break;
! 4188:
! 4189: case 238:
! 4190:
! 4191: /* Line 1455 of yacc.c */
! 4192: #line 1607 "cfparse.y"
! 4193: { (yyval.num) = (yyvsp[(1) - (1)].num); }
! 4194: break;
! 4195:
! 4196: case 239:
! 4197:
! 4198: /* Line 1455 of yacc.c */
! 4199: #line 1608 "cfparse.y"
! 4200: { (yyval.num) = IPSEC_ULPROTO_ANY; }
! 4201: break;
! 4202:
! 4203: case 240:
! 4204:
! 4205: /* Line 1455 of yacc.c */
! 4206: #line 1611 "cfparse.y"
! 4207: { (yyval.num) = 0; }
! 4208: break;
! 4209:
! 4210: case 241:
! 4211:
! 4212: /* Line 1455 of yacc.c */
! 4213: #line 1612 "cfparse.y"
! 4214: { (yyval.num) = (yyvsp[(1) - (1)].num); }
! 4215: break;
! 4216:
! 4217: case 242:
! 4218:
! 4219: /* Line 1455 of yacc.c */
! 4220: #line 1618 "cfparse.y"
! 4221: {
! 4222: struct remoteconf *from, *new;
! 4223:
! 4224: if (getrmconf_by_name((yyvsp[(2) - (4)].val)->v) != NULL) {
! 4225: yyerror("named remoteconf \"%s\" already exists.");
! 4226: return -1;
! 4227: }
! 4228:
! 4229: from = getrmconf_by_name((yyvsp[(4) - (4)].val)->v);
! 4230: if (from == NULL) {
! 4231: yyerror("named parent remoteconf \"%s\" does not exist.",
! 4232: (yyvsp[(4) - (4)].val)->v);
! 4233: return -1;
! 4234: }
! 4235:
! 4236: new = duprmconf_shallow(from);
! 4237: if (new == NULL) {
! 4238: yyerror("failed to duplicate remoteconf from \"%s\".",
! 4239: (yyvsp[(4) - (4)].val)->v);
! 4240: return -1;
! 4241: }
! 4242:
! 4243: new->name = racoon_strdup((yyvsp[(2) - (4)].val)->v);
! 4244: cur_rmconf = new;
! 4245:
! 4246: vfree((yyvsp[(2) - (4)].val));
! 4247: vfree((yyvsp[(4) - (4)].val));
! 4248: }
! 4249: break;
! 4250:
! 4251: case 244:
! 4252:
! 4253: /* Line 1455 of yacc.c */
! 4254: #line 1648 "cfparse.y"
! 4255: {
! 4256: struct remoteconf *new;
! 4257:
! 4258: if (getrmconf_by_name((yyvsp[(2) - (2)].val)->v) != NULL) {
! 4259: yyerror("Named remoteconf \"%s\" already exists.");
! 4260: return -1;
! 4261: }
! 4262:
! 4263: new = newrmconf();
! 4264: if (new == NULL) {
! 4265: yyerror("failed to get new remoteconf.");
! 4266: return -1;
! 4267: }
! 4268: new->name = racoon_strdup((yyvsp[(2) - (2)].val)->v);
! 4269: cur_rmconf = new;
! 4270:
! 4271: vfree((yyvsp[(2) - (2)].val));
! 4272: }
! 4273: break;
! 4274:
! 4275: case 246:
! 4276:
! 4277: /* Line 1455 of yacc.c */
! 4278: #line 1668 "cfparse.y"
! 4279: {
! 4280: struct remoteconf *from, *new;
! 4281:
! 4282: from = getrmconf((yyvsp[(4) - (4)].saddr), GETRMCONF_F_NO_ANONYMOUS);
! 4283: if (from == NULL) {
! 4284: yyerror("failed to get remoteconf for %s.",
! 4285: saddr2str((yyvsp[(4) - (4)].saddr)));
! 4286: return -1;
! 4287: }
! 4288:
! 4289: new = duprmconf_shallow(from);
! 4290: if (new == NULL) {
! 4291: yyerror("failed to duplicate remoteconf from %s.",
! 4292: saddr2str((yyvsp[(4) - (4)].saddr)));
! 4293: return -1;
! 4294: }
! 4295:
! 4296: racoon_free((yyvsp[(4) - (4)].saddr));
! 4297: new->remote = (yyvsp[(2) - (4)].saddr);
! 4298: cur_rmconf = new;
! 4299: }
! 4300: break;
! 4301:
! 4302: case 248:
! 4303:
! 4304: /* Line 1455 of yacc.c */
! 4305: #line 1691 "cfparse.y"
! 4306: {
! 4307: struct remoteconf *new;
! 4308:
! 4309: new = newrmconf();
! 4310: if (new == NULL) {
! 4311: yyerror("failed to get new remoteconf.");
! 4312: return -1;
! 4313: }
! 4314:
! 4315: new->remote = (yyvsp[(2) - (2)].saddr);
! 4316: cur_rmconf = new;
! 4317: }
! 4318: break;
! 4319:
! 4320: case 250:
! 4321:
! 4322: /* Line 1455 of yacc.c */
! 4323: #line 1708 "cfparse.y"
! 4324: {
! 4325: /* check a exchange mode */
! 4326: if (cur_rmconf->etypes == NULL) {
! 4327: yyerror("no exchange mode specified.\n");
! 4328: return -1;
! 4329: }
! 4330:
! 4331: if (cur_rmconf->idvtype == IDTYPE_UNDEFINED)
! 4332: cur_rmconf->idvtype = IDTYPE_ADDRESS;
! 4333:
! 4334: if (cur_rmconf->idvtype == IDTYPE_ASN1DN) {
! 4335: if (cur_rmconf->mycertfile) {
! 4336: if (cur_rmconf->idv)
! 4337: yywarn("Both CERT and ASN1 ID "
! 4338: "are set. Hope this is OK.\n");
! 4339: /* TODO: Preparse the DN here */
! 4340: } else if (cur_rmconf->idv) {
! 4341: /* OK, using asn1dn without X.509. */
! 4342: } else {
! 4343: yyerror("ASN1 ID not specified "
! 4344: "and no CERT defined!\n");
! 4345: return -1;
! 4346: }
! 4347: }
! 4348:
! 4349: if (duprmconf_finish(cur_rmconf))
! 4350: return -1;
! 4351:
! 4352: #if 0
! 4353: /* this pointer copy will never happen, because duprmconf_shallow
! 4354: * already copied all pointers.
! 4355: */
! 4356: if (cur_rmconf->spspec == NULL &&
! 4357: cur_rmconf->inherited_from != NULL) {
! 4358: cur_rmconf->spspec = cur_rmconf->inherited_from->spspec;
! 4359: }
! 4360: #endif
! 4361: if (set_isakmp_proposal(cur_rmconf) != 0)
! 4362: return -1;
! 4363:
! 4364: /* DH group settting if aggressive mode is there. */
! 4365: if (check_etypeok(cur_rmconf, (void*) ISAKMP_ETYPE_AGG)) {
! 4366: struct isakmpsa *p;
! 4367: int b = 0;
! 4368:
! 4369: /* DH group */
! 4370: for (p = cur_rmconf->proposal; p; p = p->next) {
! 4371: if (b == 0 || (b && b == p->dh_group)) {
! 4372: b = p->dh_group;
! 4373: continue;
! 4374: }
! 4375: yyerror("DH group must be equal "
! 4376: "in all proposals "
! 4377: "when aggressive mode is "
! 4378: "used.\n");
! 4379: return -1;
! 4380: }
! 4381: cur_rmconf->dh_group = b;
! 4382:
! 4383: if (cur_rmconf->dh_group == 0) {
! 4384: yyerror("DH group must be set in the proposal.\n");
! 4385: return -1;
! 4386: }
! 4387:
! 4388: /* DH group settting if PFS is required. */
! 4389: if (oakley_setdhgroup(cur_rmconf->dh_group,
! 4390: &cur_rmconf->dhgrp) < 0) {
! 4391: yyerror("failed to set DH value.\n");
! 4392: return -1;
! 4393: }
! 4394: }
! 4395:
! 4396: insrmconf(cur_rmconf);
! 4397: }
! 4398: break;
! 4399:
! 4400: case 251:
! 4401:
! 4402: /* Line 1455 of yacc.c */
! 4403: #line 1785 "cfparse.y"
! 4404: {
! 4405: (yyval.saddr) = newsaddr(sizeof(struct sockaddr));
! 4406: (yyval.saddr)->sa_family = AF_UNSPEC;
! 4407: ((struct sockaddr_in *)(yyval.saddr))->sin_port = htons((yyvsp[(2) - (2)].num));
! 4408: }
! 4409: break;
! 4410:
! 4411: case 252:
! 4412:
! 4413: /* Line 1455 of yacc.c */
! 4414: #line 1791 "cfparse.y"
! 4415: {
! 4416: (yyval.saddr) = (yyvsp[(1) - (1)].saddr);
! 4417: if ((yyval.saddr) == NULL) {
! 4418: yyerror("failed to allocate sockaddr");
! 4419: return -1;
! 4420: }
! 4421: }
! 4422: break;
! 4423:
! 4424: case 255:
! 4425:
! 4426: /* Line 1455 of yacc.c */
! 4427: #line 1805 "cfparse.y"
! 4428: {
! 4429: if (cur_rmconf->remote != NULL) {
! 4430: yyerror("remote_address already specified");
! 4431: return -1;
! 4432: }
! 4433: cur_rmconf->remote = (yyvsp[(2) - (2)].saddr);
! 4434: }
! 4435: break;
! 4436:
! 4437: case 257:
! 4438:
! 4439: /* Line 1455 of yacc.c */
! 4440: #line 1814 "cfparse.y"
! 4441: {
! 4442: cur_rmconf->etypes = NULL;
! 4443: }
! 4444: break;
! 4445:
! 4446: case 259:
! 4447:
! 4448: /* Line 1455 of yacc.c */
! 4449: #line 1818 "cfparse.y"
! 4450: { cur_rmconf->doitype = (yyvsp[(2) - (2)].num); }
! 4451: break;
! 4452:
! 4453: case 261:
! 4454:
! 4455: /* Line 1455 of yacc.c */
! 4456: #line 1819 "cfparse.y"
! 4457: { cur_rmconf->sittype = (yyvsp[(2) - (2)].num); }
! 4458: break;
! 4459:
! 4460: case 264:
! 4461:
! 4462: /* Line 1455 of yacc.c */
! 4463: #line 1822 "cfparse.y"
! 4464: {
! 4465: yywarn("This directive without certtype will be removed!\n");
! 4466: yywarn("Please use 'peers_certfile x509 \"%s\";' instead\n", (yyvsp[(2) - (2)].val)->v);
! 4467:
! 4468: if (cur_rmconf->peerscert != NULL) {
! 4469: yyerror("peers_certfile already defined\n");
! 4470: return -1;
! 4471: }
! 4472:
! 4473: if (load_x509((yyvsp[(2) - (2)].val)->v, &cur_rmconf->peerscertfile,
! 4474: &cur_rmconf->peerscert)) {
! 4475: yyerror("failed to load certificate \"%s\"\n",
! 4476: (yyvsp[(2) - (2)].val)->v);
! 4477: return -1;
! 4478: }
! 4479:
! 4480: vfree((yyvsp[(2) - (2)].val));
! 4481: }
! 4482: break;
! 4483:
! 4484: case 266:
! 4485:
! 4486: /* Line 1455 of yacc.c */
! 4487: #line 1842 "cfparse.y"
! 4488: {
! 4489: if (cur_rmconf->peerscert != NULL) {
! 4490: yyerror("peers_certfile already defined\n");
! 4491: return -1;
! 4492: }
! 4493:
! 4494: if (load_x509((yyvsp[(3) - (3)].val)->v, &cur_rmconf->peerscertfile,
! 4495: &cur_rmconf->peerscert)) {
! 4496: yyerror("failed to load certificate \"%s\"\n",
! 4497: (yyvsp[(3) - (3)].val)->v);
! 4498: return -1;
! 4499: }
! 4500:
! 4501: vfree((yyvsp[(3) - (3)].val));
! 4502: }
! 4503: break;
! 4504:
! 4505: case 268:
! 4506:
! 4507: /* Line 1455 of yacc.c */
! 4508: #line 1859 "cfparse.y"
! 4509: {
! 4510: char path[MAXPATHLEN];
! 4511: int ret = 0;
! 4512:
! 4513: if (cur_rmconf->peerscert != NULL) {
! 4514: yyerror("peers_certfile already defined\n");
! 4515: return -1;
! 4516: }
! 4517:
! 4518: cur_rmconf->peerscert = vmalloc(1);
! 4519: if (cur_rmconf->peerscert == NULL) {
! 4520: yyerror("failed to allocate peerscert");
! 4521: return -1;
! 4522: }
! 4523: cur_rmconf->peerscert->v[0] = ISAKMP_CERT_PLAINRSA;
! 4524:
! 4525: getpathname(path, sizeof(path),
! 4526: LC_PATHTYPE_CERT, (yyvsp[(3) - (3)].val)->v);
! 4527: if (rsa_parse_file(cur_rmconf->rsa_public, path,
! 4528: RSA_TYPE_PUBLIC)) {
! 4529: yyerror("Couldn't parse keyfile.\n", path);
! 4530: return -1;
! 4531: }
! 4532: plog(LLV_DEBUG, LOCATION, NULL,
! 4533: "Public PlainRSA keyfile parsed: %s\n", path);
! 4534:
! 4535: vfree((yyvsp[(3) - (3)].val));
! 4536: }
! 4537: break;
! 4538:
! 4539: case 270:
! 4540:
! 4541: /* Line 1455 of yacc.c */
! 4542: #line 1889 "cfparse.y"
! 4543: {
! 4544: if (cur_rmconf->peerscert != NULL) {
! 4545: yyerror("peers_certfile already defined\n");
! 4546: return -1;
! 4547: }
! 4548: cur_rmconf->peerscert = vmalloc(1);
! 4549: if (cur_rmconf->peerscert == NULL) {
! 4550: yyerror("failed to allocate peerscert");
! 4551: return -1;
! 4552: }
! 4553: cur_rmconf->peerscert->v[0] = ISAKMP_CERT_DNS;
! 4554: }
! 4555: break;
! 4556:
! 4557: case 272:
! 4558:
! 4559: /* Line 1455 of yacc.c */
! 4560: #line 1903 "cfparse.y"
! 4561: {
! 4562: if (cur_rmconf->cacert != NULL) {
! 4563: yyerror("ca_type already defined\n");
! 4564: return -1;
! 4565: }
! 4566:
! 4567: if (load_x509((yyvsp[(3) - (3)].val)->v, &cur_rmconf->cacertfile,
! 4568: &cur_rmconf->cacert)) {
! 4569: yyerror("failed to load certificate \"%s\"\n",
! 4570: (yyvsp[(3) - (3)].val)->v);
! 4571: return -1;
! 4572: }
! 4573:
! 4574: vfree((yyvsp[(3) - (3)].val));
! 4575: }
! 4576: break;
! 4577:
! 4578: case 274:
! 4579:
! 4580: /* Line 1455 of yacc.c */
! 4581: #line 1919 "cfparse.y"
! 4582: { cur_rmconf->verify_cert = (yyvsp[(2) - (2)].num); }
! 4583: break;
! 4584:
! 4585: case 276:
! 4586:
! 4587: /* Line 1455 of yacc.c */
! 4588: #line 1920 "cfparse.y"
! 4589: { cur_rmconf->send_cert = (yyvsp[(2) - (2)].num); }
! 4590: break;
! 4591:
! 4592: case 278:
! 4593:
! 4594: /* Line 1455 of yacc.c */
! 4595: #line 1921 "cfparse.y"
! 4596: { cur_rmconf->send_cr = (yyvsp[(2) - (2)].num); }
! 4597: break;
! 4598:
! 4599: case 280:
! 4600:
! 4601: /* Line 1455 of yacc.c */
! 4602: #line 1922 "cfparse.y"
! 4603: { cur_rmconf->match_empty_cr = (yyvsp[(2) - (2)].num); }
! 4604: break;
! 4605:
! 4606: case 282:
! 4607:
! 4608: /* Line 1455 of yacc.c */
! 4609: #line 1924 "cfparse.y"
! 4610: {
! 4611: if (set_identifier(&cur_rmconf->idv, (yyvsp[(2) - (3)].num), (yyvsp[(3) - (3)].val)) != 0) {
! 4612: yyerror("failed to set identifer.\n");
! 4613: return -1;
! 4614: }
! 4615: cur_rmconf->idvtype = (yyvsp[(2) - (3)].num);
! 4616: }
! 4617: break;
! 4618:
! 4619: case 284:
! 4620:
! 4621: /* Line 1455 of yacc.c */
! 4622: #line 1933 "cfparse.y"
! 4623: {
! 4624: if (set_identifier_qual(&cur_rmconf->idv, (yyvsp[(2) - (4)].num), (yyvsp[(4) - (4)].val), (yyvsp[(3) - (4)].num)) != 0) {
! 4625: yyerror("failed to set identifer.\n");
! 4626: return -1;
! 4627: }
! 4628: cur_rmconf->idvtype = (yyvsp[(2) - (4)].num);
! 4629: }
! 4630: break;
! 4631:
! 4632: case 286:
! 4633:
! 4634: /* Line 1455 of yacc.c */
! 4635: #line 1942 "cfparse.y"
! 4636: {
! 4637: #ifdef ENABLE_HYBRID
! 4638: /* formerly identifier type login */
! 4639: if (xauth_rmconf_used(&cur_rmconf->xauth) == -1) {
! 4640: yyerror("failed to allocate xauth state\n");
! 4641: return -1;
! 4642: }
! 4643: if ((cur_rmconf->xauth->login = vdup((yyvsp[(2) - (2)].val))) == NULL) {
! 4644: yyerror("failed to set identifer.\n");
! 4645: return -1;
! 4646: }
! 4647: #else
! 4648: yyerror("racoon not configured with --enable-hybrid");
! 4649: #endif
! 4650: }
! 4651: break;
! 4652:
! 4653: case 288:
! 4654:
! 4655: /* Line 1455 of yacc.c */
! 4656: #line 1959 "cfparse.y"
! 4657: {
! 4658: struct idspec *id;
! 4659: id = newidspec();
! 4660: if (id == NULL) {
! 4661: yyerror("failed to allocate idspec");
! 4662: return -1;
! 4663: }
! 4664: if (set_identifier(&id->id, (yyvsp[(2) - (3)].num), (yyvsp[(3) - (3)].val)) != 0) {
! 4665: yyerror("failed to set identifer.\n");
! 4666: racoon_free(id);
! 4667: return -1;
! 4668: }
! 4669: id->idtype = (yyvsp[(2) - (3)].num);
! 4670: genlist_append (cur_rmconf->idvl_p, id);
! 4671: }
! 4672: break;
! 4673:
! 4674: case 290:
! 4675:
! 4676: /* Line 1455 of yacc.c */
! 4677: #line 1976 "cfparse.y"
! 4678: {
! 4679: struct idspec *id;
! 4680: id = newidspec();
! 4681: if (id == NULL) {
! 4682: yyerror("failed to allocate idspec");
! 4683: return -1;
! 4684: }
! 4685: if (set_identifier_qual(&id->id, (yyvsp[(2) - (4)].num), (yyvsp[(4) - (4)].val), (yyvsp[(3) - (4)].num)) != 0) {
! 4686: yyerror("failed to set identifer.\n");
! 4687: racoon_free(id);
! 4688: return -1;
! 4689: }
! 4690: id->idtype = (yyvsp[(2) - (4)].num);
! 4691: genlist_append (cur_rmconf->idvl_p, id);
! 4692: }
! 4693: break;
! 4694:
! 4695: case 292:
! 4696:
! 4697: /* Line 1455 of yacc.c */
! 4698: #line 1992 "cfparse.y"
! 4699: { cur_rmconf->verify_identifier = (yyvsp[(2) - (2)].num); }
! 4700: break;
! 4701:
! 4702: case 294:
! 4703:
! 4704: /* Line 1455 of yacc.c */
! 4705: #line 1993 "cfparse.y"
! 4706: { cur_rmconf->nonce_size = (yyvsp[(2) - (2)].num); }
! 4707: break;
! 4708:
! 4709: case 296:
! 4710:
! 4711: /* Line 1455 of yacc.c */
! 4712: #line 1995 "cfparse.y"
! 4713: {
! 4714: yyerror("dh_group cannot be defined here.");
! 4715: return -1;
! 4716: }
! 4717: break;
! 4718:
! 4719: case 298:
! 4720:
! 4721: /* Line 1455 of yacc.c */
! 4722: #line 2000 "cfparse.y"
! 4723: { cur_rmconf->passive = (yyvsp[(2) - (2)].num); }
! 4724: break;
! 4725:
! 4726: case 300:
! 4727:
! 4728: /* Line 1455 of yacc.c */
! 4729: #line 2001 "cfparse.y"
! 4730: { cur_rmconf->ike_frag = (yyvsp[(2) - (2)].num); }
! 4731: break;
! 4732:
! 4733: case 302:
! 4734:
! 4735: /* Line 1455 of yacc.c */
! 4736: #line 2002 "cfparse.y"
! 4737: { cur_rmconf->ike_frag = ISAKMP_FRAG_FORCE; }
! 4738: break;
! 4739:
! 4740: case 304:
! 4741:
! 4742: /* Line 1455 of yacc.c */
! 4743: #line 2003 "cfparse.y"
! 4744: {
! 4745: #ifdef SADB_X_EXT_NAT_T_FRAG
! 4746: if (libipsec_opt & LIBIPSEC_OPT_FRAG)
! 4747: cur_rmconf->esp_frag = (yyvsp[(2) - (2)].num);
! 4748: else
! 4749: yywarn("libipsec lacks IKE frag support");
! 4750: #else
! 4751: yywarn("Your kernel does not support esp_frag");
! 4752: #endif
! 4753: }
! 4754: break;
! 4755:
! 4756: case 306:
! 4757:
! 4758: /* Line 1455 of yacc.c */
! 4759: #line 2013 "cfparse.y"
! 4760: {
! 4761: if (cur_rmconf->script[SCRIPT_PHASE1_UP] != NULL)
! 4762: vfree(cur_rmconf->script[SCRIPT_PHASE1_UP]);
! 4763:
! 4764: cur_rmconf->script[SCRIPT_PHASE1_UP] =
! 4765: script_path_add(vdup((yyvsp[(2) - (3)].val)));
! 4766: }
! 4767: break;
! 4768:
! 4769: case 308:
! 4770:
! 4771: /* Line 1455 of yacc.c */
! 4772: #line 2020 "cfparse.y"
! 4773: {
! 4774: if (cur_rmconf->script[SCRIPT_PHASE1_DOWN] != NULL)
! 4775: vfree(cur_rmconf->script[SCRIPT_PHASE1_DOWN]);
! 4776:
! 4777: cur_rmconf->script[SCRIPT_PHASE1_DOWN] =
! 4778: script_path_add(vdup((yyvsp[(2) - (3)].val)));
! 4779: }
! 4780: break;
! 4781:
! 4782: case 310:
! 4783:
! 4784: /* Line 1455 of yacc.c */
! 4785: #line 2027 "cfparse.y"
! 4786: {
! 4787: if (cur_rmconf->script[SCRIPT_PHASE1_DEAD] != NULL)
! 4788: vfree(cur_rmconf->script[SCRIPT_PHASE1_DEAD]);
! 4789:
! 4790: cur_rmconf->script[SCRIPT_PHASE1_DEAD] =
! 4791: script_path_add(vdup((yyvsp[(2) - (3)].val)));
! 4792: }
! 4793: break;
! 4794:
! 4795: case 312:
! 4796:
! 4797: /* Line 1455 of yacc.c */
! 4798: #line 2034 "cfparse.y"
! 4799: { cur_rmconf->mode_cfg = (yyvsp[(2) - (2)].num); }
! 4800: break;
! 4801:
! 4802: case 314:
! 4803:
! 4804: /* Line 1455 of yacc.c */
! 4805: #line 2035 "cfparse.y"
! 4806: {
! 4807: cur_rmconf->weak_phase1_check = (yyvsp[(2) - (2)].num);
! 4808: }
! 4809: break;
! 4810:
! 4811: case 316:
! 4812:
! 4813: /* Line 1455 of yacc.c */
! 4814: #line 2038 "cfparse.y"
! 4815: { cur_rmconf->gen_policy = (yyvsp[(2) - (2)].num); }
! 4816: break;
! 4817:
! 4818: case 318:
! 4819:
! 4820: /* Line 1455 of yacc.c */
! 4821: #line 2039 "cfparse.y"
! 4822: { cur_rmconf->gen_policy = (yyvsp[(2) - (2)].num); }
! 4823: break;
! 4824:
! 4825: case 320:
! 4826:
! 4827: /* Line 1455 of yacc.c */
! 4828: #line 2040 "cfparse.y"
! 4829: { cur_rmconf->support_proxy = (yyvsp[(2) - (2)].num); }
! 4830: break;
! 4831:
! 4832: case 322:
! 4833:
! 4834: /* Line 1455 of yacc.c */
! 4835: #line 2041 "cfparse.y"
! 4836: { cur_rmconf->ini_contact = (yyvsp[(2) - (2)].num); }
! 4837: break;
! 4838:
! 4839: case 324:
! 4840:
! 4841: /* Line 1455 of yacc.c */
! 4842: #line 2043 "cfparse.y"
! 4843: {
! 4844: #ifdef ENABLE_NATT
! 4845: if (libipsec_opt & LIBIPSEC_OPT_NATT)
! 4846: cur_rmconf->nat_traversal = (yyvsp[(2) - (2)].num);
! 4847: else
! 4848: yyerror("libipsec lacks NAT-T support");
! 4849: #else
! 4850: yyerror("NAT-T support not compiled in.");
! 4851: #endif
! 4852: }
! 4853: break;
! 4854:
! 4855: case 326:
! 4856:
! 4857: /* Line 1455 of yacc.c */
! 4858: #line 2054 "cfparse.y"
! 4859: {
! 4860: #ifdef ENABLE_NATT
! 4861: if (libipsec_opt & LIBIPSEC_OPT_NATT)
! 4862: cur_rmconf->nat_traversal = NATT_FORCE;
! 4863: else
! 4864: yyerror("libipsec lacks NAT-T support");
! 4865: #else
! 4866: yyerror("NAT-T support not compiled in.");
! 4867: #endif
! 4868: }
! 4869: break;
! 4870:
! 4871: case 328:
! 4872:
! 4873: /* Line 1455 of yacc.c */
! 4874: #line 2065 "cfparse.y"
! 4875: {
! 4876: #ifdef ENABLE_DPD
! 4877: cur_rmconf->dpd = (yyvsp[(2) - (2)].num);
! 4878: #else
! 4879: yyerror("DPD support not compiled in.");
! 4880: #endif
! 4881: }
! 4882: break;
! 4883:
! 4884: case 330:
! 4885:
! 4886: /* Line 1455 of yacc.c */
! 4887: #line 2073 "cfparse.y"
! 4888: {
! 4889: #ifdef ENABLE_DPD
! 4890: cur_rmconf->dpd_interval = (yyvsp[(2) - (2)].num);
! 4891: #else
! 4892: yyerror("DPD support not compiled in.");
! 4893: #endif
! 4894: }
! 4895: break;
! 4896:
! 4897: case 332:
! 4898:
! 4899: /* Line 1455 of yacc.c */
! 4900: #line 2082 "cfparse.y"
! 4901: {
! 4902: #ifdef ENABLE_DPD
! 4903: cur_rmconf->dpd_retry = (yyvsp[(2) - (2)].num);
! 4904: #else
! 4905: yyerror("DPD support not compiled in.");
! 4906: #endif
! 4907: }
! 4908: break;
! 4909:
! 4910: case 334:
! 4911:
! 4912: /* Line 1455 of yacc.c */
! 4913: #line 2091 "cfparse.y"
! 4914: {
! 4915: #ifdef ENABLE_DPD
! 4916: cur_rmconf->dpd_maxfails = (yyvsp[(2) - (2)].num);
! 4917: #else
! 4918: yyerror("DPD support not compiled in.");
! 4919: #endif
! 4920: }
! 4921: break;
! 4922:
! 4923: case 336:
! 4924:
! 4925: /* Line 1455 of yacc.c */
! 4926: #line 2099 "cfparse.y"
! 4927: { cur_rmconf->rekey = (yyvsp[(2) - (2)].num); }
! 4928: break;
! 4929:
! 4930: case 338:
! 4931:
! 4932: /* Line 1455 of yacc.c */
! 4933: #line 2100 "cfparse.y"
! 4934: { cur_rmconf->rekey = REKEY_FORCE; }
! 4935: break;
! 4936:
! 4937: case 340:
! 4938:
! 4939: /* Line 1455 of yacc.c */
! 4940: #line 2102 "cfparse.y"
! 4941: {
! 4942: cur_rmconf->ph1id = (yyvsp[(2) - (2)].num);
! 4943: }
! 4944: break;
! 4945:
! 4946: case 342:
! 4947:
! 4948: /* Line 1455 of yacc.c */
! 4949: #line 2107 "cfparse.y"
! 4950: {
! 4951: cur_rmconf->lifetime = (yyvsp[(3) - (4)].num) * (yyvsp[(4) - (4)].num);
! 4952: }
! 4953: break;
! 4954:
! 4955: case 344:
! 4956:
! 4957: /* Line 1455 of yacc.c */
! 4958: #line 2111 "cfparse.y"
! 4959: { cur_rmconf->pcheck_level = (yyvsp[(2) - (2)].num); }
! 4960: break;
! 4961:
! 4962: case 346:
! 4963:
! 4964: /* Line 1455 of yacc.c */
! 4965: #line 2113 "cfparse.y"
! 4966: {
! 4967: #if 1
! 4968: yyerror("byte lifetime support is deprecated in Phase1");
! 4969: return -1;
! 4970: #else
! 4971: yywarn("the lifetime of bytes in phase 1 "
! 4972: "will be ignored at the moment.");
! 4973: cur_rmconf->lifebyte = fix_lifebyte((yyvsp[(3) - (4)].num) * (yyvsp[(4) - (4)].num));
! 4974: if (cur_rmconf->lifebyte == 0)
! 4975: return -1;
! 4976: #endif
! 4977: }
! 4978: break;
! 4979:
! 4980: case 348:
! 4981:
! 4982: /* Line 1455 of yacc.c */
! 4983: #line 2127 "cfparse.y"
! 4984: {
! 4985: struct secprotospec *spspec;
! 4986:
! 4987: spspec = newspspec();
! 4988: if (spspec == NULL)
! 4989: return -1;
! 4990: insspspec(cur_rmconf, spspec);
! 4991: }
! 4992: break;
! 4993:
! 4994: case 351:
! 4995:
! 4996: /* Line 1455 of yacc.c */
! 4997: #line 2140 "cfparse.y"
! 4998: {
! 4999: struct etypes *new;
! 5000: new = racoon_malloc(sizeof(struct etypes));
! 5001: if (new == NULL) {
! 5002: yyerror("failed to allocate etypes");
! 5003: return -1;
! 5004: }
! 5005: new->type = (yyvsp[(2) - (2)].num);
! 5006: new->next = NULL;
! 5007: if (cur_rmconf->etypes == NULL)
! 5008: cur_rmconf->etypes = new;
! 5009: else {
! 5010: struct etypes *p;
! 5011: for (p = cur_rmconf->etypes;
! 5012: p->next != NULL;
! 5013: p = p->next)
! 5014: ;
! 5015: p->next = new;
! 5016: }
! 5017: }
! 5018: break;
! 5019:
! 5020: case 352:
! 5021:
! 5022: /* Line 1455 of yacc.c */
! 5023: #line 2163 "cfparse.y"
! 5024: {
! 5025: if (cur_rmconf->mycert != NULL) {
! 5026: yyerror("certificate_type already defined\n");
! 5027: return -1;
! 5028: }
! 5029:
! 5030: if (load_x509((yyvsp[(2) - (3)].val)->v, &cur_rmconf->mycertfile,
! 5031: &cur_rmconf->mycert)) {
! 5032: yyerror("failed to load certificate \"%s\"\n",
! 5033: (yyvsp[(2) - (3)].val)->v);
! 5034: return -1;
! 5035: }
! 5036:
! 5037: cur_rmconf->myprivfile = racoon_strdup((yyvsp[(3) - (3)].val)->v);
! 5038: STRDUP_FATAL(cur_rmconf->myprivfile);
! 5039:
! 5040: vfree((yyvsp[(2) - (3)].val));
! 5041: vfree((yyvsp[(3) - (3)].val));
! 5042: }
! 5043: break;
! 5044:
! 5045: case 354:
! 5046:
! 5047: /* Line 1455 of yacc.c */
! 5048: #line 2184 "cfparse.y"
! 5049: {
! 5050: char path[MAXPATHLEN];
! 5051: int ret = 0;
! 5052:
! 5053: if (cur_rmconf->mycert != NULL) {
! 5054: yyerror("certificate_type already defined\n");
! 5055: return -1;
! 5056: }
! 5057:
! 5058: cur_rmconf->mycert = vmalloc(1);
! 5059: if (cur_rmconf->mycert == NULL) {
! 5060: yyerror("failed to allocate mycert");
! 5061: return -1;
! 5062: }
! 5063: cur_rmconf->mycert->v[0] = ISAKMP_CERT_PLAINRSA;
! 5064:
! 5065: getpathname(path, sizeof(path),
! 5066: LC_PATHTYPE_CERT, (yyvsp[(2) - (2)].val)->v);
! 5067: cur_rmconf->send_cr = FALSE;
! 5068: cur_rmconf->send_cert = FALSE;
! 5069: cur_rmconf->verify_cert = FALSE;
! 5070: if (rsa_parse_file(cur_rmconf->rsa_private, path,
! 5071: RSA_TYPE_PRIVATE)) {
! 5072: yyerror("Couldn't parse keyfile.\n", path);
! 5073: return -1;
! 5074: }
! 5075: plog(LLV_DEBUG, LOCATION, NULL,
! 5076: "Private PlainRSA keyfile parsed: %s\n", path);
! 5077: vfree((yyvsp[(2) - (2)].val));
! 5078: }
! 5079: break;
! 5080:
! 5081: case 356:
! 5082:
! 5083: /* Line 1455 of yacc.c */
! 5084: #line 2218 "cfparse.y"
! 5085: {
! 5086: (yyval.num) = algtype2doi(algclass_isakmp_dh, (yyvsp[(1) - (1)].num));
! 5087: if ((yyval.num) == -1) {
! 5088: yyerror("must be DH group");
! 5089: return -1;
! 5090: }
! 5091: }
! 5092: break;
! 5093:
! 5094: case 357:
! 5095:
! 5096: /* Line 1455 of yacc.c */
! 5097: #line 2226 "cfparse.y"
! 5098: {
! 5099: if (ARRAYLEN(num2dhgroup) > (yyvsp[(1) - (1)].num) && num2dhgroup[(yyvsp[(1) - (1)].num)] != 0) {
! 5100: (yyval.num) = num2dhgroup[(yyvsp[(1) - (1)].num)];
! 5101: } else {
! 5102: yyerror("must be DH group");
! 5103: (yyval.num) = 0;
! 5104: return -1;
! 5105: }
! 5106: }
! 5107: break;
! 5108:
! 5109: case 358:
! 5110:
! 5111: /* Line 1455 of yacc.c */
! 5112: #line 2237 "cfparse.y"
! 5113: { (yyval.val) = NULL; }
! 5114: break;
! 5115:
! 5116: case 359:
! 5117:
! 5118: /* Line 1455 of yacc.c */
! 5119: #line 2238 "cfparse.y"
! 5120: { (yyval.val) = (yyvsp[(1) - (1)].val); }
! 5121: break;
! 5122:
! 5123: case 360:
! 5124:
! 5125: /* Line 1455 of yacc.c */
! 5126: #line 2239 "cfparse.y"
! 5127: { (yyval.val) = (yyvsp[(1) - (1)].val); }
! 5128: break;
! 5129:
! 5130: case 363:
! 5131:
! 5132: /* Line 1455 of yacc.c */
! 5133: #line 2247 "cfparse.y"
! 5134: {
! 5135: cur_rmconf->spspec->lifetime = (yyvsp[(3) - (4)].num) * (yyvsp[(4) - (4)].num);
! 5136: }
! 5137: break;
! 5138:
! 5139: case 365:
! 5140:
! 5141: /* Line 1455 of yacc.c */
! 5142: #line 2252 "cfparse.y"
! 5143: {
! 5144: #if 1
! 5145: yyerror("byte lifetime support is deprecated");
! 5146: return -1;
! 5147: #else
! 5148: cur_rmconf->spspec->lifebyte = fix_lifebyte((yyvsp[(3) - (4)].num) * (yyvsp[(4) - (4)].num));
! 5149: if (cur_rmconf->spspec->lifebyte == 0)
! 5150: return -1;
! 5151: #endif
! 5152: }
! 5153: break;
! 5154:
! 5155: case 367:
! 5156:
! 5157: /* Line 1455 of yacc.c */
! 5158: #line 2264 "cfparse.y"
! 5159: {
! 5160: cur_rmconf->spspec->algclass[algclass_isakmp_dh] = (yyvsp[(2) - (2)].num);
! 5161: }
! 5162: break;
! 5163:
! 5164: case 369:
! 5165:
! 5166: /* Line 1455 of yacc.c */
! 5167: #line 2269 "cfparse.y"
! 5168: {
! 5169: if (cur_rmconf->spspec->vendorid != VENDORID_GSSAPI) {
! 5170: yyerror("wrong Vendor ID for gssapi_id");
! 5171: return -1;
! 5172: }
! 5173: if (cur_rmconf->spspec->gssid != NULL)
! 5174: racoon_free(cur_rmconf->spspec->gssid);
! 5175: cur_rmconf->spspec->gssid =
! 5176: racoon_strdup((yyvsp[(2) - (2)].val)->v);
! 5177: STRDUP_FATAL(cur_rmconf->spspec->gssid);
! 5178: }
! 5179: break;
! 5180:
! 5181: case 371:
! 5182:
! 5183: /* Line 1455 of yacc.c */
! 5184: #line 2282 "cfparse.y"
! 5185: {
! 5186: int doi;
! 5187: int defklen;
! 5188:
! 5189: doi = algtype2doi((yyvsp[(1) - (3)].num), (yyvsp[(2) - (3)].num));
! 5190: if (doi == -1) {
! 5191: yyerror("algorithm mismatched 1");
! 5192: return -1;
! 5193: }
! 5194:
! 5195: switch ((yyvsp[(1) - (3)].num)) {
! 5196: case algclass_isakmp_enc:
! 5197: /* reject suppressed algorithms */
! 5198: #ifndef HAVE_OPENSSL_RC5_H
! 5199: if ((yyvsp[(2) - (3)].num) == algtype_rc5) {
! 5200: yyerror("algorithm %s not supported",
! 5201: s_attr_isakmp_enc(doi));
! 5202: return -1;
! 5203: }
! 5204: #endif
! 5205: #ifndef HAVE_OPENSSL_IDEA_H
! 5206: if ((yyvsp[(2) - (3)].num) == algtype_idea) {
! 5207: yyerror("algorithm %s not supported",
! 5208: s_attr_isakmp_enc(doi));
! 5209: return -1;
! 5210: }
! 5211: #endif
! 5212:
! 5213: cur_rmconf->spspec->algclass[algclass_isakmp_enc] = doi;
! 5214: defklen = default_keylen((yyvsp[(1) - (3)].num), (yyvsp[(2) - (3)].num));
! 5215: if (defklen == 0) {
! 5216: if ((yyvsp[(3) - (3)].num)) {
! 5217: yyerror("keylen not allowed");
! 5218: return -1;
! 5219: }
! 5220: } else {
! 5221: if ((yyvsp[(3) - (3)].num) && check_keylen((yyvsp[(1) - (3)].num), (yyvsp[(2) - (3)].num), (yyvsp[(3) - (3)].num)) < 0) {
! 5222: yyerror("invalid keylen %d", (yyvsp[(3) - (3)].num));
! 5223: return -1;
! 5224: }
! 5225: }
! 5226: if ((yyvsp[(3) - (3)].num))
! 5227: cur_rmconf->spspec->encklen = (yyvsp[(3) - (3)].num);
! 5228: else
! 5229: cur_rmconf->spspec->encklen = defklen;
! 5230: break;
! 5231: case algclass_isakmp_hash:
! 5232: cur_rmconf->spspec->algclass[algclass_isakmp_hash] = doi;
! 5233: break;
! 5234: case algclass_isakmp_ameth:
! 5235: cur_rmconf->spspec->algclass[algclass_isakmp_ameth] = doi;
! 5236: /*
! 5237: * We may have to set the Vendor ID for the
! 5238: * authentication method we're using.
! 5239: */
! 5240: switch ((yyvsp[(2) - (3)].num)) {
! 5241: case algtype_gssapikrb:
! 5242: if (cur_rmconf->spspec->vendorid !=
! 5243: VENDORID_UNKNOWN) {
! 5244: yyerror("Vendor ID mismatch "
! 5245: "for auth method");
! 5246: return -1;
! 5247: }
! 5248: /*
! 5249: * For interoperability with Win2k,
! 5250: * we set the Vendor ID to "GSSAPI".
! 5251: */
! 5252: cur_rmconf->spspec->vendorid =
! 5253: VENDORID_GSSAPI;
! 5254: break;
! 5255: case algtype_rsasig:
! 5256: if (oakley_get_certtype(cur_rmconf->peerscert) == ISAKMP_CERT_PLAINRSA) {
! 5257: if (rsa_list_count(cur_rmconf->rsa_private) == 0) {
! 5258: yyerror ("Private PlainRSA key not set. "
! 5259: "Use directive 'certificate_type plainrsa ...'\n");
! 5260: return -1;
! 5261: }
! 5262: if (rsa_list_count(cur_rmconf->rsa_public) == 0) {
! 5263: yyerror ("Public PlainRSA keys not set. "
! 5264: "Use directive 'peers_certfile plainrsa ...'\n");
! 5265: return -1;
! 5266: }
! 5267: }
! 5268: break;
! 5269: default:
! 5270: break;
! 5271: }
! 5272: break;
! 5273: default:
! 5274: yyerror("algorithm mismatched 2");
! 5275: return -1;
! 5276: }
! 5277: }
! 5278: break;
! 5279:
! 5280: case 373:
! 5281:
! 5282: /* Line 1455 of yacc.c */
! 5283: #line 2379 "cfparse.y"
! 5284: { (yyval.num) = 1; }
! 5285: break;
! 5286:
! 5287: case 374:
! 5288:
! 5289: /* Line 1455 of yacc.c */
! 5290: #line 2380 "cfparse.y"
! 5291: { (yyval.num) = 60; }
! 5292: break;
! 5293:
! 5294: case 375:
! 5295:
! 5296: /* Line 1455 of yacc.c */
! 5297: #line 2381 "cfparse.y"
! 5298: { (yyval.num) = (60 * 60); }
! 5299: break;
! 5300:
! 5301: case 376:
! 5302:
! 5303: /* Line 1455 of yacc.c */
! 5304: #line 2384 "cfparse.y"
! 5305: { (yyval.num) = 1; }
! 5306: break;
! 5307:
! 5308: case 377:
! 5309:
! 5310: /* Line 1455 of yacc.c */
! 5311: #line 2385 "cfparse.y"
! 5312: { (yyval.num) = 1024; }
! 5313: break;
! 5314:
! 5315: case 378:
! 5316:
! 5317: /* Line 1455 of yacc.c */
! 5318: #line 2386 "cfparse.y"
! 5319: { (yyval.num) = (1024 * 1024); }
! 5320: break;
! 5321:
! 5322: case 379:
! 5323:
! 5324: /* Line 1455 of yacc.c */
! 5325: #line 2387 "cfparse.y"
! 5326: { (yyval.num) = (1024 * 1024 * 1024); }
! 5327: break;
! 5328:
! 5329:
! 5330:
! 5331: /* Line 1455 of yacc.c */
! 5332: #line 5333 "cfparse.c"
! 5333: default: break;
! 5334: }
! 5335: YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
! 5336:
! 5337: YYPOPSTACK (yylen);
! 5338: yylen = 0;
! 5339: YY_STACK_PRINT (yyss, yyssp);
! 5340:
! 5341: *++yyvsp = yyval;
! 5342:
! 5343: /* Now `shift' the result of the reduction. Determine what state
! 5344: that goes to, based on the state we popped back to and the rule
! 5345: number reduced by. */
! 5346:
! 5347: yyn = yyr1[yyn];
! 5348:
! 5349: yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
! 5350: if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
! 5351: yystate = yytable[yystate];
! 5352: else
! 5353: yystate = yydefgoto[yyn - YYNTOKENS];
! 5354:
! 5355: goto yynewstate;
! 5356:
! 5357:
! 5358: /*------------------------------------.
! 5359: | yyerrlab -- here on detecting error |
! 5360: `------------------------------------*/
! 5361: yyerrlab:
! 5362: /* If not already recovering from an error, report this error. */
! 5363: if (!yyerrstatus)
! 5364: {
! 5365: ++yynerrs;
! 5366: #if ! YYERROR_VERBOSE
! 5367: yyerror (YY_("syntax error"));
! 5368: #else
! 5369: {
! 5370: YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
! 5371: if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
! 5372: {
! 5373: YYSIZE_T yyalloc = 2 * yysize;
! 5374: if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
! 5375: yyalloc = YYSTACK_ALLOC_MAXIMUM;
! 5376: if (yymsg != yymsgbuf)
! 5377: YYSTACK_FREE (yymsg);
! 5378: yymsg = (char *) YYSTACK_ALLOC (yyalloc);
! 5379: if (yymsg)
! 5380: yymsg_alloc = yyalloc;
! 5381: else
! 5382: {
! 5383: yymsg = yymsgbuf;
! 5384: yymsg_alloc = sizeof yymsgbuf;
! 5385: }
! 5386: }
! 5387:
! 5388: if (0 < yysize && yysize <= yymsg_alloc)
! 5389: {
! 5390: (void) yysyntax_error (yymsg, yystate, yychar);
! 5391: yyerror (yymsg);
! 5392: }
! 5393: else
! 5394: {
! 5395: yyerror (YY_("syntax error"));
! 5396: if (yysize != 0)
! 5397: goto yyexhaustedlab;
! 5398: }
! 5399: }
! 5400: #endif
! 5401: }
! 5402:
! 5403:
! 5404:
! 5405: if (yyerrstatus == 3)
! 5406: {
! 5407: /* If just tried and failed to reuse lookahead token after an
! 5408: error, discard it. */
! 5409:
! 5410: if (yychar <= YYEOF)
! 5411: {
! 5412: /* Return failure if at end of input. */
! 5413: if (yychar == YYEOF)
! 5414: YYABORT;
! 5415: }
! 5416: else
! 5417: {
! 5418: yydestruct ("Error: discarding",
! 5419: yytoken, &yylval);
! 5420: yychar = YYEMPTY;
! 5421: }
! 5422: }
! 5423:
! 5424: /* Else will try to reuse lookahead token after shifting the error
! 5425: token. */
! 5426: goto yyerrlab1;
! 5427:
! 5428:
! 5429: /*---------------------------------------------------.
! 5430: | yyerrorlab -- error raised explicitly by YYERROR. |
! 5431: `---------------------------------------------------*/
! 5432: yyerrorlab:
! 5433:
! 5434: /* Pacify compilers like GCC when the user code never invokes
! 5435: YYERROR and the label yyerrorlab therefore never appears in user
! 5436: code. */
! 5437: if (/*CONSTCOND*/ 0)
! 5438: goto yyerrorlab;
! 5439:
! 5440: /* Do not reclaim the symbols of the rule which action triggered
! 5441: this YYERROR. */
! 5442: YYPOPSTACK (yylen);
! 5443: yylen = 0;
! 5444: YY_STACK_PRINT (yyss, yyssp);
! 5445: yystate = *yyssp;
! 5446: goto yyerrlab1;
! 5447:
! 5448:
! 5449: /*-------------------------------------------------------------.
! 5450: | yyerrlab1 -- common code for both syntax error and YYERROR. |
! 5451: `-------------------------------------------------------------*/
! 5452: yyerrlab1:
! 5453: yyerrstatus = 3; /* Each real token shifted decrements this. */
! 5454:
! 5455: for (;;)
! 5456: {
! 5457: yyn = yypact[yystate];
! 5458: if (yyn != YYPACT_NINF)
! 5459: {
! 5460: yyn += YYTERROR;
! 5461: if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
! 5462: {
! 5463: yyn = yytable[yyn];
! 5464: if (0 < yyn)
! 5465: break;
! 5466: }
! 5467: }
! 5468:
! 5469: /* Pop the current state because it cannot handle the error token. */
! 5470: if (yyssp == yyss)
! 5471: YYABORT;
! 5472:
! 5473:
! 5474: yydestruct ("Error: popping",
! 5475: yystos[yystate], yyvsp);
! 5476: YYPOPSTACK (1);
! 5477: yystate = *yyssp;
! 5478: YY_STACK_PRINT (yyss, yyssp);
! 5479: }
! 5480:
! 5481: *++yyvsp = yylval;
! 5482:
! 5483:
! 5484: /* Shift the error token. */
! 5485: YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
! 5486:
! 5487: yystate = yyn;
! 5488: goto yynewstate;
! 5489:
! 5490:
! 5491: /*-------------------------------------.
! 5492: | yyacceptlab -- YYACCEPT comes here. |
! 5493: `-------------------------------------*/
! 5494: yyacceptlab:
! 5495: yyresult = 0;
! 5496: goto yyreturn;
! 5497:
! 5498: /*-----------------------------------.
! 5499: | yyabortlab -- YYABORT comes here. |
! 5500: `-----------------------------------*/
! 5501: yyabortlab:
! 5502: yyresult = 1;
! 5503: goto yyreturn;
! 5504:
! 5505: #if !defined(yyoverflow) || YYERROR_VERBOSE
! 5506: /*-------------------------------------------------.
! 5507: | yyexhaustedlab -- memory exhaustion comes here. |
! 5508: `-------------------------------------------------*/
! 5509: yyexhaustedlab:
! 5510: yyerror (YY_("memory exhausted"));
! 5511: yyresult = 2;
! 5512: /* Fall through. */
! 5513: #endif
! 5514:
! 5515: yyreturn:
! 5516: if (yychar != YYEMPTY)
! 5517: yydestruct ("Cleanup: discarding lookahead",
! 5518: yytoken, &yylval);
! 5519: /* Do not reclaim the symbols of the rule which action triggered
! 5520: this YYABORT or YYACCEPT. */
! 5521: YYPOPSTACK (yylen);
! 5522: YY_STACK_PRINT (yyss, yyssp);
! 5523: while (yyssp != yyss)
! 5524: {
! 5525: yydestruct ("Cleanup: popping",
! 5526: yystos[*yyssp], yyvsp);
! 5527: YYPOPSTACK (1);
! 5528: }
! 5529: #ifndef yyoverflow
! 5530: if (yyss != yyssa)
! 5531: YYSTACK_FREE (yyss);
! 5532: #endif
! 5533: #if YYERROR_VERBOSE
! 5534: if (yymsg != yymsgbuf)
! 5535: YYSTACK_FREE (yymsg);
! 5536: #endif
! 5537: /* Make sure YYID is used. */
! 5538: return YYID (yyresult);
! 5539: }
! 5540:
! 5541:
! 5542:
! 5543: /* Line 1675 of yacc.c */
! 5544: #line 2389 "cfparse.y"
! 5545:
! 5546:
! 5547: static struct secprotospec *
! 5548: newspspec()
! 5549: {
! 5550: struct secprotospec *new;
! 5551:
! 5552: new = racoon_calloc(1, sizeof(*new));
! 5553: if (new == NULL) {
! 5554: yyerror("failed to allocate spproto");
! 5555: return NULL;
! 5556: }
! 5557:
! 5558: new->encklen = 0; /*XXX*/
! 5559:
! 5560: /*
! 5561: * Default to "uknown" vendor -- we will override this
! 5562: * as necessary. When we send a Vendor ID payload, an
! 5563: * "unknown" will be translated to a KAME/racoon ID.
! 5564: */
! 5565: new->vendorid = VENDORID_UNKNOWN;
! 5566:
! 5567: return new;
! 5568: }
! 5569:
! 5570: /*
! 5571: * insert into head of list.
! 5572: */
! 5573: static void
! 5574: insspspec(rmconf, spspec)
! 5575: struct remoteconf *rmconf;
! 5576: struct secprotospec *spspec;
! 5577: {
! 5578: if (rmconf->spspec != NULL)
! 5579: rmconf->spspec->prev = spspec;
! 5580: spspec->next = rmconf->spspec;
! 5581: rmconf->spspec = spspec;
! 5582: }
! 5583:
! 5584: static struct secprotospec *
! 5585: dupspspec(spspec)
! 5586: struct secprotospec *spspec;
! 5587: {
! 5588: struct secprotospec *new;
! 5589:
! 5590: new = newspspec();
! 5591: if (new == NULL) {
! 5592: plog(LLV_ERROR, LOCATION, NULL,
! 5593: "dupspspec: malloc failed\n");
! 5594: return NULL;
! 5595: }
! 5596: memcpy(new, spspec, sizeof(*new));
! 5597:
! 5598: if (spspec->gssid) {
! 5599: new->gssid = racoon_strdup(spspec->gssid);
! 5600: STRDUP_FATAL(new->gssid);
! 5601: }
! 5602: if (spspec->remote) {
! 5603: new->remote = racoon_malloc(sizeof(*new->remote));
! 5604: if (new->remote == NULL) {
! 5605: plog(LLV_ERROR, LOCATION, NULL,
! 5606: "dupspspec: malloc failed (remote)\n");
! 5607: return NULL;
! 5608: }
! 5609: memcpy(new->remote, spspec->remote, sizeof(*new->remote));
! 5610: }
! 5611:
! 5612: return new;
! 5613: }
! 5614:
! 5615: /*
! 5616: * copy the whole list
! 5617: */
! 5618: void
! 5619: dupspspec_list(dst, src)
! 5620: struct remoteconf *dst, *src;
! 5621: {
! 5622: struct secprotospec *p, *new, *last;
! 5623:
! 5624: for(p = src->spspec, last = NULL; p; p = p->next, last = new) {
! 5625: new = dupspspec(p);
! 5626: if (new == NULL)
! 5627: exit(1);
! 5628:
! 5629: new->prev = last;
! 5630: new->next = NULL; /* not necessary but clean */
! 5631:
! 5632: if (last)
! 5633: last->next = new;
! 5634: else /* first element */
! 5635: dst->spspec = new;
! 5636:
! 5637: }
! 5638: }
! 5639:
! 5640: /*
! 5641: * delete the whole list
! 5642: */
! 5643: void
! 5644: flushspspec(rmconf)
! 5645: struct remoteconf *rmconf;
! 5646: {
! 5647: struct secprotospec *p;
! 5648:
! 5649: while(rmconf->spspec != NULL) {
! 5650: p = rmconf->spspec;
! 5651: rmconf->spspec = p->next;
! 5652: if (p->next != NULL)
! 5653: p->next->prev = NULL; /* not necessary but clean */
! 5654:
! 5655: if (p->gssid)
! 5656: racoon_free(p->gssid);
! 5657: if (p->remote)
! 5658: racoon_free(p->remote);
! 5659: racoon_free(p);
! 5660: }
! 5661: rmconf->spspec = NULL;
! 5662: }
! 5663:
! 5664: /* set final acceptable proposal */
! 5665: static int
! 5666: set_isakmp_proposal(rmconf)
! 5667: struct remoteconf *rmconf;
! 5668: {
! 5669: struct secprotospec *s;
! 5670: int prop_no = 1;
! 5671: int trns_no = 1;
! 5672: int32_t types[MAXALGCLASS];
! 5673:
! 5674: /* mandatory check */
! 5675: if (rmconf->spspec == NULL) {
! 5676: yyerror("no remote specification found: %s.\n",
! 5677: saddr2str(rmconf->remote));
! 5678: return -1;
! 5679: }
! 5680: for (s = rmconf->spspec; s != NULL; s = s->next) {
! 5681: /* XXX need more to check */
! 5682: if (s->algclass[algclass_isakmp_enc] == 0) {
! 5683: yyerror("encryption algorithm required.");
! 5684: return -1;
! 5685: }
! 5686: if (s->algclass[algclass_isakmp_hash] == 0) {
! 5687: yyerror("hash algorithm required.");
! 5688: return -1;
! 5689: }
! 5690: if (s->algclass[algclass_isakmp_dh] == 0) {
! 5691: yyerror("DH group required.");
! 5692: return -1;
! 5693: }
! 5694: if (s->algclass[algclass_isakmp_ameth] == 0) {
! 5695: yyerror("authentication method required.");
! 5696: return -1;
! 5697: }
! 5698: }
! 5699:
! 5700: /* skip to last part */
! 5701: for (s = rmconf->spspec; s->next != NULL; s = s->next)
! 5702: ;
! 5703:
! 5704: while (s != NULL) {
! 5705: plog(LLV_DEBUG2, LOCATION, NULL,
! 5706: "lifetime = %ld\n", (long)
! 5707: (s->lifetime ? s->lifetime : rmconf->lifetime));
! 5708: plog(LLV_DEBUG2, LOCATION, NULL,
! 5709: "lifebyte = %d\n",
! 5710: s->lifebyte ? s->lifebyte : rmconf->lifebyte);
! 5711: plog(LLV_DEBUG2, LOCATION, NULL,
! 5712: "encklen=%d\n", s->encklen);
! 5713:
! 5714: memset(types, 0, ARRAYLEN(types));
! 5715: types[algclass_isakmp_enc] = s->algclass[algclass_isakmp_enc];
! 5716: types[algclass_isakmp_hash] = s->algclass[algclass_isakmp_hash];
! 5717: types[algclass_isakmp_dh] = s->algclass[algclass_isakmp_dh];
! 5718: types[algclass_isakmp_ameth] =
! 5719: s->algclass[algclass_isakmp_ameth];
! 5720:
! 5721: /* expanding spspec */
! 5722: clean_tmpalgtype();
! 5723: trns_no = expand_isakmpspec(prop_no, trns_no, types,
! 5724: algclass_isakmp_enc, algclass_isakmp_ameth + 1,
! 5725: s->lifetime ? s->lifetime : rmconf->lifetime,
! 5726: s->lifebyte ? s->lifebyte : rmconf->lifebyte,
! 5727: s->encklen, s->vendorid, s->gssid,
! 5728: rmconf);
! 5729: if (trns_no == -1) {
! 5730: plog(LLV_ERROR, LOCATION, NULL,
! 5731: "failed to expand isakmp proposal.\n");
! 5732: return -1;
! 5733: }
! 5734:
! 5735: s = s->prev;
! 5736: }
! 5737:
! 5738: if (rmconf->proposal == NULL) {
! 5739: plog(LLV_ERROR, LOCATION, NULL,
! 5740: "no proposal found.\n");
! 5741: return -1;
! 5742: }
! 5743:
! 5744: return 0;
! 5745: }
! 5746:
! 5747: static void
! 5748: clean_tmpalgtype()
! 5749: {
! 5750: int i;
! 5751: for (i = 0; i < MAXALGCLASS; i++)
! 5752: tmpalgtype[i] = 0; /* means algorithm undefined. */
! 5753: }
! 5754:
! 5755: static int
! 5756: expand_isakmpspec(prop_no, trns_no, types,
! 5757: class, last, lifetime, lifebyte, encklen, vendorid, gssid,
! 5758: rmconf)
! 5759: int prop_no, trns_no;
! 5760: int *types, class, last;
! 5761: time_t lifetime;
! 5762: int lifebyte;
! 5763: int encklen;
! 5764: int vendorid;
! 5765: char *gssid;
! 5766: struct remoteconf *rmconf;
! 5767: {
! 5768: struct isakmpsa *new;
! 5769:
! 5770: /* debugging */
! 5771: {
! 5772: int j;
! 5773: char tb[10];
! 5774: plog(LLV_DEBUG2, LOCATION, NULL,
! 5775: "p:%d t:%d\n", prop_no, trns_no);
! 5776: for (j = class; j < MAXALGCLASS; j++) {
! 5777: snprintf(tb, sizeof(tb), "%d", types[j]);
! 5778: plog(LLV_DEBUG2, LOCATION, NULL,
! 5779: "%s%s%s%s\n",
! 5780: s_algtype(j, types[j]),
! 5781: types[j] ? "(" : "",
! 5782: tb[0] == '0' ? "" : tb,
! 5783: types[j] ? ")" : "");
! 5784: }
! 5785: plog(LLV_DEBUG2, LOCATION, NULL, "\n");
! 5786: }
! 5787:
! 5788: #define TMPALGTYPE2STR(n) \
! 5789: s_algtype(algclass_isakmp_##n, types[algclass_isakmp_##n])
! 5790: /* check mandatory values */
! 5791: if (types[algclass_isakmp_enc] == 0
! 5792: || types[algclass_isakmp_ameth] == 0
! 5793: || types[algclass_isakmp_hash] == 0
! 5794: || types[algclass_isakmp_dh] == 0) {
! 5795: yyerror("few definition of algorithm "
! 5796: "enc=%s ameth=%s hash=%s dhgroup=%s.\n",
! 5797: TMPALGTYPE2STR(enc),
! 5798: TMPALGTYPE2STR(ameth),
! 5799: TMPALGTYPE2STR(hash),
! 5800: TMPALGTYPE2STR(dh));
! 5801: return -1;
! 5802: }
! 5803: #undef TMPALGTYPE2STR
! 5804:
! 5805: /* set new sa */
! 5806: new = newisakmpsa();
! 5807: if (new == NULL) {
! 5808: yyerror("failed to allocate isakmp sa");
! 5809: return -1;
! 5810: }
! 5811: new->prop_no = prop_no;
! 5812: new->trns_no = trns_no++;
! 5813: new->lifetime = lifetime;
! 5814: new->lifebyte = lifebyte;
! 5815: new->enctype = types[algclass_isakmp_enc];
! 5816: new->encklen = encklen;
! 5817: new->authmethod = types[algclass_isakmp_ameth];
! 5818: new->hashtype = types[algclass_isakmp_hash];
! 5819: new->dh_group = types[algclass_isakmp_dh];
! 5820: new->vendorid = vendorid;
! 5821: #ifdef HAVE_GSSAPI
! 5822: if (new->authmethod == OAKLEY_ATTR_AUTH_METHOD_GSSAPI_KRB) {
! 5823: if (gssid != NULL) {
! 5824: if ((new->gssid = vmalloc(strlen(gssid))) == NULL) {
! 5825: racoon_free(new);
! 5826: yyerror("failed to allocate gssid");
! 5827: return -1;
! 5828: }
! 5829: memcpy(new->gssid->v, gssid, new->gssid->l);
! 5830: racoon_free(gssid);
! 5831: } else {
! 5832: /*
! 5833: * Allocate the default ID so that it gets put
! 5834: * into a GSS ID attribute during the Phase 1
! 5835: * exchange.
! 5836: */
! 5837: new->gssid = gssapi_get_default_gss_id();
! 5838: }
! 5839: }
! 5840: #endif
! 5841: insisakmpsa(new, rmconf);
! 5842:
! 5843: return trns_no;
! 5844: }
! 5845:
! 5846: #if 0
! 5847: /*
! 5848: * fix lifebyte.
! 5849: * Must be more than 1024B because its unit is kilobytes.
! 5850: * That is defined RFC2407.
! 5851: */
! 5852: static int
! 5853: fix_lifebyte(t)
! 5854: unsigned long t;
! 5855: {
! 5856: if (t < 1024) {
! 5857: yyerror("byte size should be more than 1024B.");
! 5858: return 0;
! 5859: }
! 5860:
! 5861: return(t / 1024);
! 5862: }
! 5863: #endif
! 5864:
! 5865: int
! 5866: cfparse()
! 5867: {
! 5868: int error;
! 5869:
! 5870: yyerrorcount = 0;
! 5871: yycf_init_buffer();
! 5872:
! 5873: if (yycf_switch_buffer(lcconf->racoon_conf) != 0) {
! 5874: plog(LLV_ERROR, LOCATION, NULL,
! 5875: "could not read configuration file \"%s\"\n",
! 5876: lcconf->racoon_conf);
! 5877: return -1;
! 5878: }
! 5879:
! 5880: error = yyparse();
! 5881: if (error != 0) {
! 5882: if (yyerrorcount) {
! 5883: plog(LLV_ERROR, LOCATION, NULL,
! 5884: "fatal parse failure (%d errors)\n",
! 5885: yyerrorcount);
! 5886: } else {
! 5887: plog(LLV_ERROR, LOCATION, NULL,
! 5888: "fatal parse failure.\n");
! 5889: }
! 5890: return -1;
! 5891: }
! 5892:
! 5893: if (error == 0 && yyerrorcount) {
! 5894: plog(LLV_ERROR, LOCATION, NULL,
! 5895: "parse error is nothing, but yyerrorcount is %d.\n",
! 5896: yyerrorcount);
! 5897: exit(1);
! 5898: }
! 5899:
! 5900: yycf_clean_buffer();
! 5901:
! 5902: plog(LLV_DEBUG2, LOCATION, NULL, "parse successed.\n");
! 5903:
! 5904: return 0;
! 5905: }
! 5906:
! 5907: int
! 5908: cfreparse()
! 5909: {
! 5910: flushph2();
! 5911: flushph1();
! 5912: flushrmconf();
! 5913: flushsainfo();
! 5914: clean_tmpalgtype();
! 5915: return(cfparse());
! 5916: }
! 5917:
! 5918: #ifdef ENABLE_ADMINPORT
! 5919: static void
! 5920: adminsock_conf(path, owner, group, mode_dec)
! 5921: vchar_t *path;
! 5922: vchar_t *owner;
! 5923: vchar_t *group;
! 5924: int mode_dec;
! 5925: {
! 5926: struct passwd *pw = NULL;
! 5927: struct group *gr = NULL;
! 5928: mode_t mode = 0;
! 5929: uid_t uid;
! 5930: gid_t gid;
! 5931: int isnum;
! 5932:
! 5933: adminsock_path = path->v;
! 5934:
! 5935: if (owner == NULL)
! 5936: return;
! 5937:
! 5938: errno = 0;
! 5939: uid = atoi(owner->v);
! 5940: isnum = !errno;
! 5941: if (((pw = getpwnam(owner->v)) == NULL) && !isnum)
! 5942: yyerror("User \"%s\" does not exist", owner->v);
! 5943:
! 5944: if (pw)
! 5945: adminsock_owner = pw->pw_uid;
! 5946: else
! 5947: adminsock_owner = uid;
! 5948:
! 5949: if (group == NULL)
! 5950: return;
! 5951:
! 5952: errno = 0;
! 5953: gid = atoi(group->v);
! 5954: isnum = !errno;
! 5955: if (((gr = getgrnam(group->v)) == NULL) && !isnum)
! 5956: yyerror("Group \"%s\" does not exist", group->v);
! 5957:
! 5958: if (gr)
! 5959: adminsock_group = gr->gr_gid;
! 5960: else
! 5961: adminsock_group = gid;
! 5962:
! 5963: if (mode_dec == -1)
! 5964: return;
! 5965:
! 5966: if (mode_dec > 777)
! 5967: yyerror("Mode 0%03o is invalid", mode_dec);
! 5968: if (mode_dec >= 400) { mode += 0400; mode_dec -= 400; }
! 5969: if (mode_dec >= 200) { mode += 0200; mode_dec -= 200; }
! 5970: if (mode_dec >= 100) { mode += 0200; mode_dec -= 100; }
! 5971:
! 5972: if (mode_dec > 77)
! 5973: yyerror("Mode 0%03o is invalid", mode_dec);
! 5974: if (mode_dec >= 40) { mode += 040; mode_dec -= 40; }
! 5975: if (mode_dec >= 20) { mode += 020; mode_dec -= 20; }
! 5976: if (mode_dec >= 10) { mode += 020; mode_dec -= 10; }
! 5977:
! 5978: if (mode_dec > 7)
! 5979: yyerror("Mode 0%03o is invalid", mode_dec);
! 5980: if (mode_dec >= 4) { mode += 04; mode_dec -= 4; }
! 5981: if (mode_dec >= 2) { mode += 02; mode_dec -= 2; }
! 5982: if (mode_dec >= 1) { mode += 02; mode_dec -= 1; }
! 5983:
! 5984: adminsock_mode = mode;
! 5985:
! 5986: return;
! 5987: }
! 5988: #endif
! 5989:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cfparse.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