1: /* $NetBSD: token.l,v 1.15 2010/06/04 13:06:03 vanhu Exp $ */
2:
3: /* $KAME: token.l,v 1.44 2003/10/21 07:20:58 itojun Exp $ */
4:
5: /*
6: * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. Neither the name of the project nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: */
33:
34: %{
35:
36: #ifdef HAVE_CONFIG_H
37: #include "config.h"
38: #endif
39:
40: #include <sys/types.h>
41: #include <sys/param.h>
42: #include <sys/socket.h>
43: #include <net/pfkeyv2.h>
44: #include <netinet/in.h>
45: #include PATH_IPSEC_H
46:
47: #include <stdlib.h>
48: #include <limits.h>
49: #include <string.h>
50: #include <unistd.h>
51: #include <errno.h>
52: #include <netdb.h>
53:
54: #include "vchar.h"
55: #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__linux__) || \
56: (defined(__APPLE__) && defined(__MACH__))
57: #include "parse.h"
58: #else
59: #include "y.tab.h"
60: #endif
61:
62: #include "extern.h"
63:
64: /* make the code compile on *BSD-current */
65: #ifndef SADB_X_AALG_SHA2_256
66: #define SADB_X_AALG_SHA2_256 (-1)
67: #endif
68: #ifndef SADB_X_AALG_SHA2_384
69: #define SADB_X_AALG_SHA2_384 (-1)
70: #endif
71: #ifndef SADB_X_AALG_SHA2_512
72: #define SADB_X_AALG_SHA2_512 (-1)
73: #endif
74: #ifndef SADB_X_AALG_RIPEMD160HMAC
75: #define SADB_X_AALG_RIPEMD160HMAC (-1)
76: #endif
77: #ifndef SADB_X_AALG_AES_XCBC_MAC
78: #define SADB_X_AALG_AES_XCBC_MAC (-1)
79: #endif
80: #ifndef SADB_X_EALG_TWOFISHCBC
81: #define SADB_X_EALG_TWOFISHCBC (-1)
82: #endif
83: #ifndef SADB_X_EALG_AESCTR
84: #define SADB_X_EALG_AESCTR (-1)
85: #endif
86: #if defined(SADB_X_EALG_AES) && ! defined(SADB_X_EALG_AESCBC)
87: #define SADB_X_EALG_AESCBC SADB_X_EALG_AES
88: #endif
89: %}
90:
91: /* common section */
92: nl \n
93: ws [ \t]+
94: digit [0-9]
95: letter [0-9A-Za-z]
96: hexdigit [0-9A-Fa-f]
97: dot \.
98: hyphen \-
99: slash \/
100: blcl \[
101: elcl \]
102: semi \;
103: comment \#.*
104: quotedstring \"[^"]*\"
105: decstring {digit}+
106: hexstring 0[xX]{hexdigit}+
107: ipaddress [a-fA-F0-9:]([a-fA-F0-9:\.]*|[a-fA-F0-9:\.]*%[a-zA-Z0-9]*)
108: ipaddrmask {slash}{digit}{1,3}
109: name {letter}(({letter}|{digit}|{hyphen})*({letter}|{digit}))*
110: hostname {name}(({dot}{name})+{dot}?)?
111:
112: %s S_PL S_AUTHALG S_ENCALG
113:
114: %option noinput nounput
115: %%
116:
117:
118: add { return(ADD); }
119: delete { return(DELETE); }
120: deleteall { return(DELETEALL); }
121: get { return(GET); }
122: flush { return(FLUSH); }
123: dump { return(DUMP); }
124: exit { return(EXIT); }
125: quit { return(EXIT); }
126: bye { return(EXIT); }
127:
128: /* for management SPD */
129: spdadd { return(SPDADD); }
130: spdupdate { return(SPDUPDATE); }
131: spddelete { return(SPDDELETE); }
132: spddump { return(SPDDUMP); }
133: spdflush { return(SPDFLUSH); }
134: tagged { return(TAGGED); }
135: {hyphen}P { BEGIN S_PL; return(F_POLICY); }
136: <S_PL>[a-zA-Z0-9:\.\-_/ \n\t][a-zA-Z0-9:\.%\-+_/ \n\t\]\[]* {
137: yymore();
138:
139: /* count up for nl */
140: {
141: char *p;
142: for (p = yytext; *p != '\0'; p++)
143: if (*p == '\n')
144: lineno++;
145: }
146:
147: yylval.val.len = strlen(yytext);
148: yylval.val.buf = strdup(yytext);
149: if (!yylval.val.buf)
150: yyfatal("insufficient memory");
151:
152: return(PL_REQUESTS);
153: }
154: <S_PL>{semi} { BEGIN INITIAL; return(EOT); }
155:
156: /* address resolution flags */
157: {hyphen}[n46][n46]* {
158: yylval.val.len = strlen(yytext);
159: yylval.val.buf = strdup(yytext);
160: if (!yylval.val.buf)
161: yyfatal("insufficient memory");
162: return(F_AIFLAGS);
163: }
164:
165: /* security protocols */
166: ah { yylval.num = 0; return(PR_AH); }
167: esp { yylval.num = 0; return(PR_ESP); }
168: ah-old { yylval.num = 1; return(PR_AH); }
169: esp-old { yylval.num = 1; return(PR_ESP); }
170: esp-udp { yylval.num = 0; return(PR_ESPUDP); }
171: ipcomp { yylval.num = 0; return(PR_IPCOMP); }
172: tcp {
173: yylval.num = 0; return(PR_TCP);
174: }
175:
176: /* authentication alogorithm */
177: {hyphen}A { BEGIN S_AUTHALG; return(F_AUTH); }
178: <S_AUTHALG>hmac-md5 { yylval.num = SADB_AALG_MD5HMAC; BEGIN INITIAL; return(ALG_AUTH); }
179: <S_AUTHALG>hmac-sha1 { yylval.num = SADB_AALG_SHA1HMAC; BEGIN INITIAL; return(ALG_AUTH); }
180: <S_AUTHALG>keyed-md5 { yylval.num = SADB_X_AALG_MD5; BEGIN INITIAL; return(ALG_AUTH); }
181: <S_AUTHALG>keyed-sha1 { yylval.num = SADB_X_AALG_SHA; BEGIN INITIAL; return(ALG_AUTH); }
182: <S_AUTHALG>hmac-sha2-256 { yylval.num = SADB_X_AALG_SHA2_256; BEGIN INITIAL; return(ALG_AUTH); }
183: <S_AUTHALG>hmac-sha256 { yylval.num = SADB_X_AALG_SHA2_256; BEGIN INITIAL; return(ALG_AUTH); }
184: <S_AUTHALG>hmac-sha2-384 { yylval.num = SADB_X_AALG_SHA2_384; BEGIN INITIAL; return(ALG_AUTH); }
185: <S_AUTHALG>hmac-sha384 { yylval.num = SADB_X_AALG_SHA2_384; BEGIN INITIAL; return(ALG_AUTH); }
186: <S_AUTHALG>hmac-sha2-512 { yylval.num = SADB_X_AALG_SHA2_512; BEGIN INITIAL; return(ALG_AUTH); }
187: <S_AUTHALG>hmac-sha512 { yylval.num = SADB_X_AALG_SHA2_512; BEGIN INITIAL; return(ALG_AUTH); }
188: <S_AUTHALG>hmac-ripemd160 { yylval.num = SADB_X_AALG_RIPEMD160HMAC; BEGIN INITIAL; return(ALG_AUTH); }
189: <S_AUTHALG>aes-xcbc-mac { yylval.num = SADB_X_AALG_AES_XCBC_MAC; BEGIN INITIAL; return(ALG_AUTH); }
190: <S_AUTHALG>tcp-md5 {
191: #ifdef SADB_X_AALG_TCP_MD5
192: yylval.num = SADB_X_AALG_TCP_MD5;
193: BEGIN INITIAL;
194: return(ALG_AUTH);
195: #endif
196: }
197: <S_AUTHALG>null { yylval.num = SADB_X_AALG_NULL; BEGIN INITIAL; return(ALG_AUTH_NOKEY); }
198:
199: /* encryption alogorithm */
200: {hyphen}E { BEGIN S_ENCALG; return(F_ENC); }
201: <S_ENCALG>des-cbc { yylval.num = SADB_EALG_DESCBC; BEGIN INITIAL; return(ALG_ENC); }
202: <S_ENCALG>3des-cbc { yylval.num = SADB_EALG_3DESCBC; BEGIN INITIAL; return(ALG_ENC); }
203: <S_ENCALG>null { yylval.num = SADB_EALG_NULL; BEGIN INITIAL; return(ALG_ENC_NOKEY); }
204: <S_ENCALG>simple { yylval.num = SADB_EALG_NULL; BEGIN INITIAL; return(ALG_ENC_OLD); }
205: <S_ENCALG>blowfish-cbc { yylval.num = SADB_X_EALG_BLOWFISHCBC; BEGIN INITIAL; return(ALG_ENC); }
206: <S_ENCALG>cast128-cbc { yylval.num = SADB_X_EALG_CAST128CBC; BEGIN INITIAL; return(ALG_ENC); }
207: <S_ENCALG>des-deriv { yylval.num = SADB_EALG_DESCBC; BEGIN INITIAL; return(ALG_ENC_DESDERIV); }
208: <S_ENCALG>des-32iv { yylval.num = SADB_EALG_DESCBC; BEGIN INITIAL; return(ALG_ENC_DES32IV); }
209: <S_ENCALG>twofish-cbc { yylval.num = SADB_X_EALG_TWOFISHCBC; BEGIN INITIAL; return(ALG_ENC); }
210: <S_ENCALG>aes-cbc {
211: #ifdef SADB_X_EALG_AESCBC
212: yylval.num = SADB_X_EALG_AESCBC; BEGIN INITIAL; return(ALG_ENC);
213: #endif
214: }
215: <S_ENCALG>rijndael-cbc {
216: #ifdef SADB_X_EALG_AESCBC
217: yylval.num = SADB_X_EALG_AESCBC; BEGIN INITIAL; return(ALG_ENC);
218: #endif
219: }
220: <S_ENCALG>aes-ctr { yylval.num = SADB_X_EALG_AESCTR; BEGIN INITIAL; return(ALG_ENC); }
221: <S_ENCALG>camellia-cbc {
222: #ifdef SADB_X_EALG_CAMELLIACBC
223: yylval.num = SADB_X_EALG_CAMELLIACBC; BEGIN INITIAL; return(ALG_ENC);
224: #endif
225: }
226:
227: /* compression algorithms */
228: {hyphen}C { return(F_COMP); }
229: oui { yylval.num = SADB_X_CALG_OUI; return(ALG_COMP); }
230: deflate { yylval.num = SADB_X_CALG_DEFLATE; return(ALG_COMP); }
231: lzs { yylval.num = SADB_X_CALG_LZS; return(ALG_COMP); }
232: {hyphen}R { return(F_RAWCPI); }
233:
234: /* extension */
235: {hyphen}m { return(F_MODE); }
236: transport { yylval.num = IPSEC_MODE_TRANSPORT; return(MODE); }
237: tunnel { yylval.num = IPSEC_MODE_TUNNEL; return(MODE); }
238: {hyphen}u { return(F_REQID); }
239: {hyphen}f { return(F_EXT); }
240: random-pad { yylval.num = SADB_X_EXT_PRAND; return(EXTENSION); }
241: seq-pad { yylval.num = SADB_X_EXT_PSEQ; return(EXTENSION); }
242: zero-pad { yylval.num = SADB_X_EXT_PZERO; return(EXTENSION); }
243: nocyclic-seq { return(NOCYCLICSEQ); }
244: {hyphen}r { return(F_REPLAY); }
245: {hyphen}lh { return(F_LIFETIME_HARD); }
246: {hyphen}ls { return(F_LIFETIME_SOFT); }
247: {hyphen}bh { return(F_LIFEBYTE_HARD); }
248: {hyphen}bs { return(F_LIFEBYTE_SOFT); }
249: {hyphen}ctx { return(SECURITY_CTX); }
250:
251: /* ... */
252: any { return(ANY); }
253: {ws} { }
254: {nl} { lineno++; }
255: {comment}
256: {semi} { return(EOT); }
257:
258: /* for address parameters: /prefix, [port] */
259: {slash} { return SLASH; }
260: {blcl} { return BLCL; }
261: {elcl} { return ELCL; }
262:
263: /* parameter */
264: {decstring} {
265: char *bp;
266:
267: yylval.ulnum = strtoul(yytext, &bp, 10);
268: return(DECSTRING);
269: }
270:
271: {hexstring} {
272: yylval.val.buf = strdup(yytext + 2);
273: if (!yylval.val.buf)
274: yyfatal("insufficient memory");
275: yylval.val.len = strlen(yylval.val.buf);
276:
277: return(HEXSTRING);
278: }
279:
280: {quotedstring} {
281: char *p = yytext;
282: while (*++p != '"') ;
283: *p = '\0';
284: yytext++;
285: yylval.val.len = yyleng - 2;
286: yylval.val.buf = strdup(yytext);
287: if (!yylval.val.buf)
288: yyfatal("insufficient memory");
289:
290: return(QUOTEDSTRING);
291: }
292:
293: [A-Za-z0-9:][A-Za-z0-9:%\.-]* {
294: yylval.val.len = yyleng;
295: yylval.val.buf = strdup(yytext);
296: if (!yylval.val.buf)
297: yyfatal("insufficient memory");
298: return(STRING);
299: }
300:
301: [0-9,]+ {
302: yylval.val.len = yyleng;
303: yylval.val.buf = strdup(yytext);
304: if (!yylval.val.buf)
305: yyfatal("insufficient memory");
306: return(STRING);
307: }
308:
309: . {
310: yyfatal("Syntax error");
311: /*NOTREACHED*/
312: }
313:
314: %%
315:
316: void
317: yyfatal(s)
318: const char *s;
319: {
320: yyerror(s);
321: exit(1);
322: }
323:
324: void
325: yyerror(s)
326: const char *s;
327: {
328: printf("line %d: %s at [%s]\n", lineno, s, yytext);
329: }
330:
331: int
332: parse(fp)
333: FILE **fp;
334: {
335: yyin = *fp;
336:
337: lineno = 1;
338: parse_init();
339:
340: if (yyparse()) {
341: printf("parse failed, line %d.\n", lineno);
342: return(-1);
343: }
344:
345: return(0);
346: }
347:
348: int
349: parse_string (char *src)
350: {
351: int result;
352: YY_BUFFER_STATE buf_state;
353:
354: buf_state = yy_scan_string(src);
355: result = yyparse();
356: yy_delete_buffer(buf_state);
357: return result;
358: }
359:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to token.l CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ipsec-tools / src / setkey