1/* $NetBSD: cftoken.l,v 1.25 2011/11/15 13:51:23 tteras Exp $ */ 2 3/* Id: cftoken.l,v 1.53 2006/08/22 18:17:17 manubsd Exp */ 4 5%{ 6/* 7 * Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 and 2003 WIDE Project. 8 * All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. Neither the name of the project nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35#include "config.h" 36 37#include <sys/types.h> 38#include <sys/param.h> 39#include <sys/socket.h> 40 41#include <netinet/in.h> 42#include PATH_IPSEC_H 43 44#include <stdlib.h> 45#include <stdio.h> 46#include <string.h> 47#include <errno.h> 48#include <limits.h> 49#include <ctype.h> 50#include <glob.h> 51#ifdef HAVE_STDARG_H 52#include <stdarg.h> 53#else 54#include <varargs.h> 55#endif 56 57#include "var.h" 58#include "misc.h" 59#include "vmbuf.h" 60#include "plog.h" 61#include "debug.h" 62 63#include "algorithm.h" 64#include "cfparse_proto.h" 65#include "cftoken_proto.h" 66#include "localconf.h" 67#include "oakley.h" 68#include "isakmp_var.h" 69#include "isakmp.h" 70#include "ipsec_doi.h" 71#include "policy.h" 72#include "proposal.h" 73#include "remoteconf.h" 74#ifdef GC 75#include "gcmalloc.h" 76#endif 77 78#include "cfparse.h" 79 80int yyerrorcount = 0; 81 82#if defined(YIPS_DEBUG) 83# define YYDB plog(LLV_DEBUG2, LOCATION, NULL, \ 84 "begin <%d>%s\n", yy_start, yytext); 85# define YYD { \ 86 plog(LLV_DEBUG2, LOCATION, NULL, "<%d>%s", \ 87 yy_start, loglevel >= LLV_DEBUG2 ? "\n" : ""); \ 88} 89#else 90# define YYDB 91# define YYD 92#endif /* defined(YIPS_DEBUG) */ 93 94#define MAX_INCLUDE_DEPTH 10 95 96static struct include_stack { 97 char *path; 98 FILE *fp; 99 YY_BUFFER_STATE prevstate; 100 int lineno; 101 glob_t matches; 102 int matchon; 103} incstack[MAX_INCLUDE_DEPTH]; 104static int incstackp = 0; 105 106static int yy_first_time = 1; 107%} 108 109/* common section */ 110nl \n 111ws [ \t]+ 112digit [0-9] 113letter [A-Za-z] 114hexdigit [0-9A-Fa-f] 115/*octet (([01]?{digit}?{digit})|((2([0-4]{digit}))|(25[0-5]))) */ 116special [()+\|\?\*] 117comma \, 118dot \. 119slash \/ 120bcl \{ 121ecl \} 122blcl \[ 123elcl \] 124hyphen \- 125percent \% 126semi \; 127comment \#.* 128ccomment "/*" 129bracketstring \<[^>]*\> 130quotedstring \"[^"]*\" 131addrstring [a-fA-F0-9:]([a-fA-F0-9:\.]*|[a-fA-F0-9:\.]*%[a-zA-Z0-9]*) 132decstring {digit}+ 133hexstring 0x{hexdigit}+ 134 135%s S_INI S_PRIV S_PTH S_LOG S_PAD S_LST S_RTRY S_CFG S_LDAP S_RAD 136%s S_ALGST S_ALGCL 137%s S_SAINF S_SAINFS 138%s S_RMT S_RMTS S_RMTP 139%s S_SA 140%s S_GSSENC 141 142%% 143%{ 144 if (yy_first_time) { 145 BEGIN S_INI; 146 yy_first_time = 0; 147 } 148%} 149 150 /* privsep */ 151<S_INI>privsep { BEGIN S_PRIV; YYDB; return(PRIVSEP); } 152<S_PRIV>{bcl} { return(BOC); } 153<S_PRIV>user { YYD; return(USER); } 154<S_PRIV>group { YYD; return(GROUP); } 155<S_PRIV>chroot { YYD; return(CHROOT); } 156<S_PRIV>{ecl} { BEGIN S_INI; return(EOC); } 157 158 /* path */ 159<S_INI>path { BEGIN S_PTH; YYDB; return(PATH); } 160<S_PTH>include { YYD; yylval.num = LC_PATHTYPE_INCLUDE; 161 return(PATHTYPE); } 162<S_PTH>pre_shared_key { YYD; yylval.num = LC_PATHTYPE_PSK; 163 return(PATHTYPE); } 164<S_PTH>certificate { YYD; yylval.num = LC_PATHTYPE_CERT; 165 return(PATHTYPE); } 166<S_PTH>script { YYD; yylval.num = LC_PATHTYPE_SCRIPT; 167 return(PATHTYPE); } 168<S_PTH>backupsa { YYD; yylval.num = LC_PATHTYPE_BACKUPSA; 169 return(PATHTYPE); } 170<S_PTH>pidfile { YYD; yylval.num = LC_PATHTYPE_PIDFILE; 171 return(PATHTYPE); } 172<S_PTH>{semi} { BEGIN S_INI; YYDB; return(EOS); } 173 174 /* include */ 175<S_INI>include { YYDB; return(INCLUDE); } 176 177 /* pfkey_buffer */ 178<S_INI>pfkey_buffer { YYDB; return(PFKEY_BUFFER); } 179 180 /* special */ 181<S_INI>complex_bundle { YYDB; return(COMPLEX_BUNDLE); } 182 183 /* logging */ 184<S_INI>log { BEGIN S_LOG; YYDB; return(LOGGING); } 185<S_LOG>error { YYD; yylval.num = LLV_ERROR; return(LOGLEV); } 186<S_LOG>warning { YYD; yylval.num = LLV_WARNING; return(LOGLEV); } 187<S_LOG>notify { YYD; yylval.num = LLV_NOTIFY; return(LOGLEV); } 188<S_LOG>info { YYD; yylval.num = LLV_INFO; return(LOGLEV); } 189<S_LOG>debug { YYD; yylval.num = LLV_DEBUG; return(LOGLEV); } 190<S_LOG>debug2 { YYD; yylval.num = LLV_DEBUG2; return(LOGLEV); } 191<S_LOG>{semi} { BEGIN S_INI; return(EOS); } 192 193 /* padding */ 194<S_INI>padding { BEGIN S_PAD; YYDB; return(PADDING); } 195<S_PAD>{bcl} { return(BOC); } 196<S_PAD>randomize { YYD; return(PAD_RANDOMIZE); } 197<S_PAD>randomize_length { YYD; return(PAD_RANDOMIZELEN); } 198<S_PAD>maximum_length { YYD; return(PAD_MAXLEN); } 199<S_PAD>strict_check { YYD; return(PAD_STRICT); } 200<S_PAD>exclusive_tail { YYD; return(PAD_EXCLTAIL); } 201<S_PAD>{ecl} { BEGIN S_INI; return(EOC); } 202 203 /* listen */ 204<S_INI>listen { BEGIN S_LST; YYDB; return(LISTEN); } 205<S_LST>{bcl} { return(BOC); } 206<S_LST>isakmp { YYD; return(X_ISAKMP); } 207<S_LST>isakmp_natt { YYD; return(X_ISAKMP_NATT); } 208<S_LST>admin { YYD; return(X_ADMIN); } 209<S_LST>adminsock { YYD; return(ADMINSOCK); } 210<S_LST>disabled { YYD; return(DISABLED); } 211<S_LST>strict_address { YYD; return(STRICT_ADDRESS); } 212<S_LST>{ecl} { BEGIN S_INI; return(EOC); } 213 214 /* radius config */ 215<S_INI>radiuscfg { BEGIN S_RAD; YYDB; return(RADCFG); } 216<S_RAD>{bcl} { return(BOC); } 217<S_RAD>auth { YYD; return(RAD_AUTH); } 218<S_RAD>acct { YYD; return(RAD_ACCT); } 219<S_RAD>timeout { YYD; return(RAD_TIMEOUT); } 220<S_RAD>retries { YYD; return(RAD_RETRIES); } 221<S_RAD>{ecl} { BEGIN S_INI; return(EOC); } 222 223 /* ldap config */ 224<S_INI>ldapcfg { BEGIN S_LDAP; YYDB; return(LDAPCFG); } 225<S_LDAP>{bcl} { return(BOC); } 226<S_LDAP>version { YYD; return(LDAP_PVER); } 227<S_LDAP>host { YYD; return(LDAP_HOST); } 228<S_LDAP>port { YYD; return(LDAP_PORT); } 229<S_LDAP>tls { YYD; return(LDAP_TLS); } 230<S_LDAP>base { YYD; return(LDAP_BASE); } 231<S_LDAP>subtree { YYD; return(LDAP_SUBTREE); } 232<S_LDAP>bind_dn { YYD; return(LDAP_BIND_DN); } 233<S_LDAP>bind_pw { YYD; return(LDAP_BIND_PW); } 234<S_LDAP>attr_user { YYD; return(LDAP_ATTR_USER); } 235<S_LDAP>attr_addr { YYD; return(LDAP_ATTR_ADDR); } 236<S_LDAP>attr_mask { YYD; return(LDAP_ATTR_MASK); } 237<S_LDAP>attr_group { YYD; return(LDAP_ATTR_GROUP); } 238<S_LDAP>attr_member { YYD; return(LDAP_ATTR_MEMBER); } 239<S_LDAP>{ecl} { BEGIN S_INI; return(EOC); } 240 241 /* mode_cfg */ 242<S_INI>mode_cfg { BEGIN S_CFG; YYDB; return(MODECFG); } 243<S_CFG>{bcl} { return(BOC); } 244<S_CFG>network4 { YYD; return(CFG_NET4); } 245<S_CFG>netmask4 { YYD; return(CFG_MASK4); } 246<S_CFG>dns4 { YYD; return(CFG_DNS4); } 247<S_CFG>nbns4 { YYD; return(CFG_NBNS4); } 248<S_CFG>wins4 { YYD; return(CFG_NBNS4); } 249<S_CFG>default_domain { YYD; return(CFG_DEFAULT_DOMAIN); } 250<S_CFG>auth_source { YYD; return(CFG_AUTH_SOURCE); } 251<S_CFG>auth_groups { YYD; return(CFG_AUTH_GROUPS); } 252<S_CFG>group_source { YYD; return(CFG_GROUP_SOURCE); } 253<S_CFG>conf_source { YYD; return(CFG_CONF_SOURCE); } 254<S_CFG>accounting { YYD; return(CFG_ACCOUNTING); } 255<S_CFG>system { YYD; return(CFG_SYSTEM); } 256<S_CFG>local { YYD; return(CFG_LOCAL); } 257<S_CFG>none { YYD; return(CFG_NONE); } 258<S_CFG>radius { YYD; return(CFG_RADIUS); } 259<S_CFG>pam { YYD; return(CFG_PAM); } 260<S_CFG>ldap { YYD; return(CFG_LDAP); } 261<S_CFG>pool_size { YYD; return(CFG_POOL_SIZE); } 262<S_CFG>banner { YYD; return(CFG_MOTD); } 263<S_CFG>auth_throttle { YYD; return(CFG_AUTH_THROTTLE); } 264<S_CFG>split_network { YYD; return(CFG_SPLIT_NETWORK); } 265<S_CFG>local_lan { YYD; return(CFG_SPLIT_LOCAL); } 266<S_CFG>include { YYD; return(CFG_SPLIT_INCLUDE); } 267<S_CFG>split_dns { YYD; return(CFG_SPLIT_DNS); } 268<S_CFG>pfs_group { YYD; return(CFG_PFS_GROUP); } 269<S_CFG>save_passwd { YYD; return(CFG_SAVE_PASSWD); } 270<S_CFG>{comma} { YYD; return(COMMA); } 271<S_CFG>{ecl} { BEGIN S_INI; return(EOC); } 272 273 /* timer */ 274<S_INI>timer { BEGIN S_RTRY; YYDB; return(RETRY); } 275<S_RTRY>{bcl} { return(BOC); } 276<S_RTRY>counter { YYD; return(RETRY_COUNTER); } 277<S_RTRY>interval { YYD; return(RETRY_INTERVAL); } 278<S_RTRY>persend { YYD; return(RETRY_PERSEND); } 279<S_RTRY>phase1 { YYD; return(RETRY_PHASE1); } 280<S_RTRY>phase2 { YYD; return(RETRY_PHASE2); } 281<S_RTRY>natt_keepalive { YYD; return(NATT_KA); } 282<S_RTRY>{ecl} { BEGIN S_INI; return(EOC); } 283 284 /* sainfo */ 285<S_INI>sainfo { BEGIN S_SAINF; YYDB; return(SAINFO); } 286<S_SAINF>anonymous { YYD; return(ANONYMOUS); } 287<S_SAINF>clientaddr { YYD; return(CLIENTADDR); } 288<S_SAINF>{blcl}any{elcl} { YYD; return(PORTANY); } 289<S_SAINF>any { YYD; return(ANY); } 290<S_SAINF>from { YYD; return(FROM); } 291<S_SAINF>group { YYD; return(GROUP); } 292 /* sainfo spec */ 293<S_SAINF>{bcl} { BEGIN S_SAINFS; return(BOC); } 294<S_SAINF>{semi} { BEGIN S_INI; return(EOS); } 295<S_SAINFS>{ecl} { BEGIN S_INI; return(EOC); } 296<S_SAINFS>pfs_group { YYD; return(PFS_GROUP); } 297<S_SAINFS>remoteid { YYD; return(REMOTEID); } 298<S_SAINFS>my_identifier { YYD; return(MY_IDENTIFIER); } 299<S_SAINFS>lifetime { YYD; return(LIFETIME); } 300<S_SAINFS>time { YYD; return(LIFETYPE_TIME); } 301<S_SAINFS>byte { YYD; return(LIFETYPE_BYTE); } 302<S_SAINFS>encryption_algorithm { YYD; yylval.num = algclass_ipsec_enc; return(ALGORITHM_CLASS); } 303<S_SAINFS>authentication_algorithm { YYD; yylval.num = algclass_ipsec_auth; return(ALGORITHM_CLASS); } 304<S_SAINFS>compression_algorithm { YYD; yylval.num = algclass_ipsec_comp; return(ALGORITHM_CLASS); } 305<S_SAINFS>{comma} { YYD; return(COMMA); } 306 307 /* remote */ 308<S_INI>remote { BEGIN S_RMT; YYDB; return(REMOTE); } 309<S_RMT>anonymous { YYD; return(ANONYMOUS); } 310<S_RMT>inherit { YYD; return(INHERIT); } 311<S_RMT>{semi} { BEGIN S_INI; YYDB; return(EOS); } 312 /* remote spec */ 313<S_RMT>{bcl} { BEGIN S_RMTS; return(BOC); } 314<S_RMTS>{ecl} { BEGIN S_INI; return(EOC); } 315<S_RMTS>remote_address { YYD; return(REMOTE_ADDRESS); } 316<S_RMTS>exchange_mode { YYD; return(EXCHANGE_MODE); } 317<S_RMTS>{comma} { YYD; /* XXX ignored, but to be handled. */ ; } 318<S_RMTS>base { YYD; yylval.num = ISAKMP_ETYPE_BASE; return(EXCHANGETYPE); } 319<S_RMTS>main { YYD; yylval.num = ISAKMP_ETYPE_IDENT; return(EXCHANGETYPE); } 320<S_RMTS>aggressive { YYD; yylval.num = ISAKMP_ETYPE_AGG; return(EXCHANGETYPE); } 321<S_RMTS>doi { YYD; return(DOI); } 322<S_RMTS>ipsec_doi { YYD; yylval.num = IPSEC_DOI; return(DOITYPE); } 323<S_RMTS>situation { YYD; return(SITUATION); } 324<S_RMTS>identity_only { YYD; yylval.num = IPSECDOI_SIT_IDENTITY_ONLY; return(SITUATIONTYPE); } 325<S_RMTS>secrecy { YYD; yylval.num = IPSECDOI_SIT_SECRECY; return(SITUATIONTYPE); } 326<S_RMTS>integrity { YYD; yylval.num = IPSECDOI_SIT_INTEGRITY; return(SITUATIONTYPE); } 327<S_RMTS>my_identifier { YYD; return(MY_IDENTIFIER); } 328<S_RMTS>xauth_login { YYD; return(XAUTH_LOGIN); /* formerly identifier type login */ } 329<S_RMTS>peers_identifier { YYD; return(PEERS_IDENTIFIER); } 330<S_RMTS>verify_identifier { YYD; return(VERIFY_IDENTIFIER); } 331<S_RMTS>certificate_type { YYD; return(CERTIFICATE_TYPE); } 332<S_RMTS>ca_type { YYD; return(CA_TYPE); } 333<S_RMTS>x509 { YYD; yylval.num = ISAKMP_CERT_X509SIGN; return(CERT_X509); } 334<S_RMTS>plain_rsa { YYD; yylval.num = ISAKMP_CERT_PLAINRSA; return(CERT_PLAINRSA); } 335<S_RMTS>peers_certfile { YYD; return(PEERS_CERTFILE); } 336<S_RMTS>dnssec { YYD; return(DNSSEC); } 337<S_RMTS>verify_cert { YYD; return(VERIFY_CERT); } 338<S_RMTS>send_cert { YYD; return(SEND_CERT); } 339<S_RMTS>send_cr { YYD; return(SEND_CR); } 340<S_RMTS>match_empty_cr { YYD; return(MATCH_EMPTY_CR); } 341<S_RMTS>dh_group { YYD; return(DH_GROUP); } 342<S_RMTS>nonce_size { YYD; return(NONCE_SIZE); } 343<S_RMTS>generate_policy { YYD; return(GENERATE_POLICY); } 344<S_RMTS>unique { YYD; yylval.num = GENERATE_POLICY_UNIQUE; return(GENERATE_LEVEL); } 345<S_RMTS>require { YYD; yylval.num = GENERATE_POLICY_REQUIRE; return(GENERATE_LEVEL); } 346<S_RMTS>support_proxy { YYD; return(SUPPORT_PROXY); } 347<S_RMTS>initial_contact { YYD; return(INITIAL_CONTACT); } 348<S_RMTS>nat_traversal { YYD; return(NAT_TRAVERSAL); } 349<S_RMTS>force { YYD; return(REMOTE_FORCE_LEVEL); } 350<S_RMTS>proposal_check { YYD; return(PROPOSAL_CHECK); } 351<S_RMTS>obey { YYD; yylval.num = PROP_CHECK_OBEY; return(PROPOSAL_CHECK_LEVEL); } 352<S_RMTS>strict { YYD; yylval.num = PROP_CHECK_STRICT; return(PROPOSAL_CHECK_LEVEL); } 353<S_RMTS>exact { YYD; yylval.num = PROP_CHECK_EXACT; return(PROPOSAL_CHECK_LEVEL); } 354<S_RMTS>claim { YYD; yylval.num = PROP_CHECK_CLAIM; return(PROPOSAL_CHECK_LEVEL); } 355<S_RMTS>keepalive { YYD; return(KEEPALIVE); } 356<S_RMTS>passive { YYD; return(PASSIVE); } 357<S_RMTS>lifetime { YYD; return(LIFETIME); } 358<S_RMTS>time { YYD; return(LIFETYPE_TIME); } 359<S_RMTS>byte { YYD; return(LIFETYPE_BYTE); } 360<S_RMTS>dpd { YYD; return(DPD); } 361<S_RMTS>dpd_delay { YYD; return(DPD_DELAY); } 362<S_RMTS>dpd_retry { YYD; return(DPD_RETRY); } 363<S_RMTS>dpd_maxfail { YYD; return(DPD_MAXFAIL); } 364<S_RMTS>ph1id { YYD; return(PH1ID); } 365<S_RMTS>ike_frag { YYD; return(IKE_FRAG); } 366<S_RMTS>esp_frag { YYD; return(ESP_FRAG); } 367<S_RMTS>script { YYD; return(SCRIPT); } 368<S_RMTS>phase1_up { YYD; return(PHASE1_UP); } 369<S_RMTS>phase1_down { YYD; return(PHASE1_DOWN); } 370<S_RMTS>phase1_dead { YYD; return(PHASE1_DEAD); } 371<S_RMTS>mode_cfg { YYD; return(MODE_CFG); } 372<S_RMTS>weak_phase1_check { YYD; return(WEAK_PHASE1_CHECK); } 373<S_RMTS>rekey { YYD; return(REKEY); } 374 /* remote proposal */ 375<S_RMTS>proposal { BEGIN S_RMTP; YYDB; return(PROPOSAL); } 376<S_RMTP>{bcl} { return(BOC); } 377<S_RMTP>{ecl} { BEGIN S_RMTS; return(EOC); } 378<S_RMTP>lifetime { YYD; return(LIFETIME); } 379<S_RMTP>time { YYD; return(LIFETYPE_TIME); } 380<S_RMTP>byte { YYD; return(LIFETYPE_BYTE); } 381<S_RMTP>encryption_algorithm { YYD; yylval.num = algclass_isakmp_enc; return(ALGORITHM_CLASS); } 382<S_RMTP>authentication_method { YYD; yylval.num = algclass_isakmp_ameth; return(ALGORITHM_CLASS); } 383<S_RMTP>hash_algorithm { YYD; yylval.num = algclass_isakmp_hash; return(ALGORITHM_CLASS); } 384<S_RMTP>dh_group { YYD; return(DH_GROUP); } 385<S_RMTP>gss_id { YYD; return(GSS_ID); } 386<S_RMTP>gssapi_id { YYD; return(GSS_ID); } /* for back compatibility */ 387 388 /* GSS ID encoding type (global) */ 389<S_INI>gss_id_enc { BEGIN S_GSSENC; YYDB; return(GSS_ID_ENC); } 390<S_GSSENC>latin1 { YYD; yylval.num = LC_GSSENC_LATIN1; 391 return(GSS_ID_ENCTYPE); } 392<S_GSSENC>utf-16le { YYD; yylval.num = LC_GSSENC_UTF16LE; 393 return(GSS_ID_ENCTYPE); } 394<S_GSSENC>{semi} { BEGIN S_INI; YYDB; return(EOS); } 395 396 /* parameter */ 397on { YYD; yylval.num = TRUE; return(SWITCH); } 398off { YYD; yylval.num = FALSE; return(SWITCH); } 399 400 /* prefix */ 401{slash}{digit}{1,3} { 402 YYD; 403 yytext++; 404 yylval.num = atoi(yytext); 405 return(PREFIX); 406 } 407 408 /* port number */ 409{blcl}{decstring}{elcl} { 410 char *p = yytext; 411 YYD; 412 while (*++p != ']') ; 413 *p = 0; 414 yytext++; 415 yylval.num = atoi(yytext); 416 return(PORT); 417 } 418 419 /* address range */ 420{hyphen}{addrstring} { 421 YYD; 422 yytext++; 423 yylval.val = vmalloc(yyleng + 1); 424 if (yylval.val == NULL) { 425 yyerror("vmalloc failed"); 426 return -1; 427 } 428 memcpy(yylval.val->v, yytext, yylval.val->l); 429 return(ADDRRANGE); 430 } 431 432 /* upper protocol */ 433esp { YYD; yylval.num = IPPROTO_ESP; return(UL_PROTO); } 434ah { YYD; yylval.num = IPPROTO_AH; return(UL_PROTO); } 435ipcomp { YYD; yylval.num = IPPROTO_IPCOMP; return(UL_PROTO); } 436icmp { YYD; yylval.num = IPPROTO_ICMP; return(UL_PROTO); } 437icmp6 { YYD; yylval.num = IPPROTO_ICMPV6; return(UL_PROTO); } 438tcp { YYD; yylval.num = IPPROTO_TCP; return(UL_PROTO); } 439udp { YYD; yylval.num = IPPROTO_UDP; return(UL_PROTO); } 440gre { YYD; yylval.num = IPPROTO_GRE; return(UL_PROTO); } 441 442 /* algorithm type */ 443des_iv64 { YYD; yylval.num = algtype_des_iv64; return(ALGORITHMTYPE); } 444des { YYD; yylval.num = algtype_des; return(ALGORITHMTYPE); } 4453des { YYD; yylval.num = algtype_3des; return(ALGORITHMTYPE); } 446rc5 { YYD; yylval.num = algtype_rc5; return(ALGORITHMTYPE); } 447idea { YYD; yylval.num = algtype_idea; return(ALGORITHMTYPE); } 448cast128 { YYD; yylval.num = algtype_cast128; return(ALGORITHMTYPE); } 449blowfish { YYD; yylval.num = algtype_blowfish; return(ALGORITHMTYPE); } 4503idea { YYD; yylval.num = algtype_3idea; return(ALGORITHMTYPE); } 451des_iv32 { YYD; yylval.num = algtype_des_iv32; return(ALGORITHMTYPE); } 452rc4 { YYD; yylval.num = algtype_rc4; return(ALGORITHMTYPE); } 453null_enc { YYD; yylval.num = algtype_null_enc; return(ALGORITHMTYPE); } 454null { YYD; yylval.num = algtype_null_enc; return(ALGORITHMTYPE); } 455aes { YYD; yylval.num = algtype_aes; return(ALGORITHMTYPE); } 456rijndael { YYD; yylval.num = algtype_aes; return(ALGORITHMTYPE); } 457twofish { YYD; yylval.num = algtype_twofish; return(ALGORITHMTYPE); } 458camellia { YYD; yylval.num = algtype_camellia; return(ALGORITHMTYPE); } 459non_auth { YYD; yylval.num = algtype_non_auth; return(ALGORITHMTYPE); } 460hmac_md5 { YYD; yylval.num = algtype_hmac_md5; return(ALGORITHMTYPE); } 461hmac_sha1 { YYD; yylval.num = algtype_hmac_sha1; return(ALGORITHMTYPE); } 462hmac_sha2_256 { YYD; yylval.num = algtype_hmac_sha2_256; return(ALGORITHMTYPE); } 463hmac_sha256 { YYD; yylval.num = algtype_hmac_sha2_256; return(ALGORITHMTYPE); } 464hmac_sha2_384 { YYD; yylval.num = algtype_hmac_sha2_384; return(ALGORITHMTYPE); } 465hmac_sha384 { YYD; yylval.num = algtype_hmac_sha2_384; return(ALGORITHMTYPE); } 466hmac_sha2_512 { YYD; yylval.num = algtype_hmac_sha2_512; return(ALGORITHMTYPE); } 467hmac_sha512 { YYD; yylval.num = algtype_hmac_sha2_512; return(ALGORITHMTYPE); } 468des_mac { YYD; yylval.num = algtype_des_mac; return(ALGORITHMTYPE); } 469kpdk { YYD; yylval.num = algtype_kpdk; return(ALGORITHMTYPE); } 470md5 { YYD; yylval.num = algtype_md5; return(ALGORITHMTYPE); } 471sha1 { YYD; yylval.num = algtype_sha1; return(ALGORITHMTYPE); } 472tiger { YYD; yylval.num = algtype_tiger; return(ALGORITHMTYPE); } 473sha2_256 { YYD; yylval.num = algtype_sha2_256; return(ALGORITHMTYPE); } 474sha256 { YYD; yylval.num = algtype_sha2_256; return(ALGORITHMTYPE); } 475sha2_384 { YYD; yylval.num = algtype_sha2_384; return(ALGORITHMTYPE); } 476sha384 { YYD; yylval.num = algtype_sha2_384; return(ALGORITHMTYPE); } 477sha2_512 { YYD; yylval.num = algtype_sha2_512; return(ALGORITHMTYPE); } 478sha512 { YYD; yylval.num = algtype_sha2_512; return(ALGORITHMTYPE); } 479oui { YYD; yylval.num = algtype_oui; return(ALGORITHMTYPE); } 480deflate { YYD; yylval.num = algtype_deflate; return(ALGORITHMTYPE); } 481lzs { YYD; yylval.num = algtype_lzs; return(ALGORITHMTYPE); } 482modp768 { YYD; yylval.num = algtype_modp768; return(ALGORITHMTYPE); } 483modp1024 { YYD; yylval.num = algtype_modp1024; return(ALGORITHMTYPE); } 484modp1536 { YYD; yylval.num = algtype_modp1536; return(ALGORITHMTYPE); } 485ec2n155 { YYD; yylval.num = algtype_ec2n155; return(ALGORITHMTYPE); } 486ec2n185 { YYD; yylval.num = algtype_ec2n185; return(ALGORITHMTYPE); } 487modp2048 { YYD; yylval.num = algtype_modp2048; return(ALGORITHMTYPE); } 488modp3072 { YYD; yylval.num = algtype_modp3072; return(ALGORITHMTYPE); } 489modp4096 { YYD; yylval.num = algtype_modp4096; return(ALGORITHMTYPE); } 490modp6144 { YYD; yylval.num = algtype_modp6144; return(ALGORITHMTYPE); } 491modp8192 { YYD; yylval.num = algtype_modp8192; return(ALGORITHMTYPE); } 492pre_shared_key { YYD; yylval.num = algtype_psk; return(ALGORITHMTYPE); } 493rsasig { YYD; yylval.num = algtype_rsasig; return(ALGORITHMTYPE); } 494dsssig { YYD; yylval.num = algtype_dsssig; return(ALGORITHMTYPE); } 495rsaenc { YYD; yylval.num = algtype_rsaenc; return(ALGORITHMTYPE); } 496rsarev { YYD; yylval.num = algtype_rsarev; return(ALGORITHMTYPE); } 497gssapi_krb { YYD; yylval.num = algtype_gssapikrb; return(ALGORITHMTYPE); } 498hybrid_rsa_server { 499#ifdef ENABLE_HYBRID 500 YYD; yylval.num = algtype_hybrid_rsa_s; return(ALGORITHMTYPE); 501#else 502 yyerror("racoon not configured with --enable-hybrid"); 503#endif 504} 505hybrid_dss_server { 506#ifdef ENABLE_HYBRID 507 YYD; yylval.num = algtype_hybrid_dss_s; return(ALGORITHMTYPE); 508#else 509 yyerror("racoon not configured with --enable-hybrid"); 510#endif 511} 512hybrid_rsa_client { 513#ifdef ENABLE_HYBRID 514 YYD; yylval.num = algtype_hybrid_rsa_c; return(ALGORITHMTYPE); 515#else 516 yyerror("racoon not configured with --enable-hybrid"); 517#endif 518} 519hybrid_dss_client { 520#ifdef ENABLE_HYBRID 521 YYD; yylval.num = algtype_hybrid_dss_c; return(ALGORITHMTYPE); 522#else 523 yyerror("racoon not configured with --enable-hybrid"); 524#endif 525} 526xauth_psk_server { 527#ifdef ENABLE_HYBRID 528 YYD; yylval.num = algtype_xauth_psk_s; return(ALGORITHMTYPE); 529#else 530 yyerror("racoon not configured with --enable-hybrid"); 531#endif 532} 533xauth_psk_client { 534#ifdef ENABLE_HYBRID 535 YYD; yylval.num = algtype_xauth_psk_c; return(ALGORITHMTYPE); 536#else 537 yyerror("racoon not configured with --enable-hybrid"); 538#endif 539} 540xauth_rsa_server { 541#ifdef ENABLE_HYBRID 542 YYD; yylval.num = algtype_xauth_rsa_s; return(ALGORITHMTYPE); 543#else 544 yyerror("racoon not configured with --enable-hybrid"); 545#endif 546} 547xauth_rsa_client { 548#ifdef ENABLE_HYBRID 549 YYD; yylval.num = algtype_xauth_rsa_c; return(ALGORITHMTYPE); 550#else 551 yyerror("racoon not configured with --enable-hybrid"); 552#endif 553} 554 555 556 /* identifier type */ 557user_fqdn { YYD; yylval.num = IDTYPE_USERFQDN; return(IDENTIFIERTYPE); } 558fqdn { YYD; yylval.num = IDTYPE_FQDN; return(IDENTIFIERTYPE); } 559keyid { YYD; yylval.num = IDTYPE_KEYID; return(IDENTIFIERTYPE); } 560address { YYD; yylval.num = IDTYPE_ADDRESS; return(IDENTIFIERTYPE); } 561subnet { YYD; yylval.num = IDTYPE_SUBNET; return(IDENTIFIERTYPE); } 562asn1dn { YYD; yylval.num = IDTYPE_ASN1DN; return(IDENTIFIERTYPE); } 563 564 /* identifier qualifier */ 565tag { YYD; yylval.num = IDQUAL_TAG; return(IDENTIFIERQUAL); } 566file { YYD; yylval.num = IDQUAL_FILE; return(IDENTIFIERQUAL); } 567 568 /* units */ 569B|byte|bytes { YYD; return(UNITTYPE_BYTE); } 570KB { YYD; return(UNITTYPE_KBYTES); } 571MB { YYD; return(UNITTYPE_MBYTES); } 572TB { YYD; return(UNITTYPE_TBYTES); } 573sec|secs|second|seconds { YYD; return(UNITTYPE_SEC); } 574min|mins|minute|minutes { YYD; return(UNITTYPE_MIN); } 575hour|hours { YYD; return(UNITTYPE_HOUR); } 576 577 /* boolean */ 578yes { YYD; yylval.num = TRUE; return(BOOLEAN); } 579no { YYD; yylval.num = FALSE; return(BOOLEAN); } 580 581{decstring} { 582 char *bp; 583 584 YYD; 585 yylval.num = strtoul(yytext, &bp, 10); 586 return(NUMBER); 587 } 588 589{hexstring} { 590 char *p; 591 592 YYD; 593 yylval.val = vmalloc(yyleng + (yyleng & 1) + 1); 594 if (yylval.val == NULL) { 595 yyerror("vmalloc failed"); 596 return -1; 597 } 598 599 p = yylval.val->v; 600 *p++ = '0'; 601 *p++ = 'x'; 602 603 /* fixed string if length is odd. */ 604 if (yyleng & 1) 605 *p++ = '0'; 606 memcpy(p, &yytext[2], yyleng - 1); 607 608 return(HEXSTRING); 609 } 610 611{quotedstring} { 612 char *p = yytext; 613 614 YYD; 615 while (*++p != '"') ; 616 *p = '\0'; 617 618 yylval.val = vmalloc(yyleng - 1); 619 if (yylval.val == NULL) { 620 yyerror("vmalloc failed"); 621 return -1; 622 } 623 memcpy(yylval.val->v, &yytext[1], yylval.val->l); 624 625 return(QUOTEDSTRING); 626 } 627 628{addrstring} { 629 YYD; 630 631 yylval.val = vmalloc(yyleng + 1); 632 if (yylval.val == NULL) { 633 yyerror("vmalloc failed"); 634 return -1; 635 } 636 memcpy(yylval.val->v, yytext, yylval.val->l); 637 638 return(ADDRSTRING); 639 } 640 641<<EOF>> { 642 yy_delete_buffer(YY_CURRENT_BUFFER); 643 fclose (incstack[incstackp].fp); 644 incstack[incstackp].fp = NULL; 645 racoon_free(incstack[incstackp].path); 646 incstack[incstackp].path = NULL; 647 incstackp--; 648 nextfile: 649 if (incstack[incstackp].matchon < 650 incstack[incstackp].matches.gl_pathc) { 651 char* filepath = incstack[incstackp].matches.gl_pathv[incstack[incstackp].matchon]; 652 incstack[incstackp].matchon++; 653 incstackp++; 654 if (yycf_set_buffer(filepath) != 0) { 655 incstackp--; 656 goto nextfile; 657 } 658 yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE)); 659 BEGIN(S_INI); 660 } else { 661 globfree(&incstack[incstackp].matches); 662 if (incstackp == 0) 663 yyterminate(); 664 else 665 yy_switch_to_buffer(incstack[incstackp].prevstate); 666 } 667 } 668 669 /* ... */ 670{ws} { ; } 671{nl} { incstack[incstackp].lineno++; } 672{comment} { YYD; } 673{semi} { return(EOS); } 674. { yymore(); } 675 676%% 677 678void 679yyerror(const char *s, ...) 680{ 681 char fmt[512]; 682 683 va_list ap; 684#ifdef HAVE_STDARG_H 685 va_start(ap, s); 686#else 687 va_start(ap); 688#endif 689 snprintf(fmt, sizeof(fmt), "%s:%d: \"%s\" %s\n", 690 incstack[incstackp].path, incstack[incstackp].lineno, 691 yytext, s); 692 plogv(LLV_ERROR, LOCATION, NULL, fmt, ap); 693 va_end(ap); 694 695 yyerrorcount++; 696} 697 698void 699yywarn(const char *s, ...) 700{ 701 char fmt[512]; 702 703 va_list ap; 704#ifdef HAVE_STDARG_H 705 va_start(ap, s); 706#else 707 va_start(ap); 708#endif 709 snprintf(fmt, sizeof(fmt), "%s:%d: \"%s\" %s\n", 710 incstack[incstackp].path, incstack[incstackp].lineno, 711 yytext, s); 712 plogv(LLV_WARNING, LOCATION, NULL, fmt, ap); 713 va_end(ap); 714} 715 716int 717yycf_switch_buffer(path) 718 char *path; 719{ 720 char *filepath = NULL; 721 722 /* got the include file name */ 723 if (incstackp >= MAX_INCLUDE_DEPTH) { 724 plog(LLV_ERROR, LOCATION, NULL, 725 "Includes nested too deeply"); 726 return -1; 727 } 728 729 if (glob(path, GLOB_TILDE, NULL, &incstack[incstackp].matches) != 0 || 730 incstack[incstackp].matches.gl_pathc == 0) { 731 plog(LLV_ERROR, LOCATION, NULL, 732 "glob found no matches for path \"%s\"\n", path); 733 return -1; 734 } 735 incstack[incstackp].matchon = 0; 736 incstack[incstackp].prevstate = YY_CURRENT_BUFFER; 737 738 nextmatch: 739 if (incstack[incstackp].matchon >= incstack[incstackp].matches.gl_pathc) 740 return -1; 741 filepath = 742 incstack[incstackp].matches.gl_pathv[incstack[incstackp].matchon]; 743 incstack[incstackp].matchon++; 744 incstackp++; 745 746 if (yycf_set_buffer(filepath) != 0) { 747 incstackp--; 748 goto nextmatch; 749 } 750 751 yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE)); 752 753 BEGIN(S_INI); 754 755 return 0; 756} 757 758int 759yycf_set_buffer(path) 760 char *path; 761{ 762 yyin = fopen(path, "r"); 763 if (yyin == NULL) { 764 fprintf(stderr, "failed to open file %s (%s)\n", 765 path, strerror(errno)); 766 plog(LLV_ERROR, LOCATION, NULL, 767 "failed to open file %s (%s)\n", 768 path, strerror(errno)); 769 return -1; 770 } 771 772 /* initialize */ 773 incstack[incstackp].fp = yyin; 774 if (incstack[incstackp].path != NULL) 775 racoon_free(incstack[incstackp].path); 776 incstack[incstackp].path = racoon_strdup(path); 777 STRDUP_FATAL(incstack[incstackp].path); 778 incstack[incstackp].lineno = 1; 779 plog(LLV_DEBUG, LOCATION, NULL, 780 "reading config file %s\n", path); 781 782 return 0; 783} 784 785void 786yycf_init_buffer() 787{ 788 int i; 789 790 for (i = 0; i < MAX_INCLUDE_DEPTH; i++) 791 memset(&incstack[i], 0, sizeof(incstack[i])); 792 incstackp = 0; 793} 794 795void 796yycf_clean_buffer() 797{ 798 int i; 799 800 for (i = 0; i < MAX_INCLUDE_DEPTH; i++) { 801 if (incstack[i].path != NULL) { 802 fclose(incstack[i].fp); 803 racoon_free(incstack[i].path); 804 incstack[i].path = NULL; 805 } 806 } 807} 808 809