embedaddon/ipsec-tools/src/racoon/cfparse.c - view

File: [ELWIX - Embedded LightWeight unIX -] / embedaddon / ipsec-tools / src / racoon / cfparse.c
Revision 1.1.1.1 (vendor branch): download - view: text, annotated - select for diffs - revision graph
Tue Feb 21 22:39:10 2012 UTC (12 years, 4 months ago) by misho
Branches: ipsec-tools, MAIN
CVS tags: v0_8_0p0, v0_8_0, HEAD

ipsec-tools

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: