Deleted Added
sdiff udiff text old ( 121071 ) new ( 122108 )
full compact
token.l (121071) token.l (122108)
1/* $FreeBSD: head/sbin/setkey/token.l 121071 2003-10-13 14:57:41Z ume $ */
2/* $KAME: token.l,v 1.21 2001/05/18 05:35:01 sakane Exp $ */
1/* $FreeBSD: head/sbin/setkey/token.l 122108 2003-11-05 09:47:54Z ume $ */
2/* $KAME: token.l,v 1.43 2003/07/25 09:35:28 itojun Exp $ */
3
4/*
5 * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:

--- 30 unchanged lines hidden (view full) ---

41#include <netinet/in.h>
42#include <netinet6/ipsec.h>
43
44#include <stdlib.h>
45#include <limits.h>
46#include <string.h>
47#include <unistd.h>
48#include <errno.h>
3
4/*
5 * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:

--- 30 unchanged lines hidden (view full) ---

41#include <netinet/in.h>
42#include <netinet6/ipsec.h>
43
44#include <stdlib.h>
45#include <limits.h>
46#include <string.h>
47#include <unistd.h>
48#include <errno.h>
49#include <netdb.h>
50
49#include "vchar.h"
51#include "vchar.h"
50#ifdef __NetBSD__
51#include "parse.h"
52#else
53#include "y.tab.h"
52#include "y.tab.h"
54#endif
55
53
56#define DECHO \
57 if (f_debug) {printf("<%d>", yy_start); ECHO ; printf("\n"); }
58
59#define CMDARG \
60{ \
61 char *__buf__ = strdup(yytext), *__p__; \
62 for (__p__ = __buf__; *__p__ != NULL; __p__++) \
63 if (*__p__ == '\n' || *__p__ == '\t') \
64 *__p__ = ' '; \
65 strcat(cmdarg, __buf__); \
66 free(__buf__); \
67}
68
69#define PREPROC DECHO CMDARG
70
71int lineno = 1;
54int lineno = 1;
72char cmdarg[8192]; /* XXX: BUFSIZ is the better ? */
73
74extern u_char m_buf[BUFSIZ];
75extern u_int m_len;
76extern int f_debug;
77
78int yylex __P((void));
79void yyfatal __P((const char *s));
80void yyerror __P((const char *s));
81extern void parse_init __P((void));
82int parse __P((FILE **));
83int yyparse __P((void));
55
56extern u_char m_buf[BUFSIZ];
57extern u_int m_len;
58extern int f_debug;
59
60int yylex __P((void));
61void yyfatal __P((const char *s));
62void yyerror __P((const char *s));
63extern void parse_init __P((void));
64int parse __P((FILE **));
65int yyparse __P((void));
84
85%}
86
87/* common section */
88nl \n
89ws [ \t]+
90digit [0-9]
91letter [0-9A-Za-z]
92hexdigit [0-9A-Fa-f]
66%}
67
68/* common section */
69nl \n
70ws [ \t]+
71digit [0-9]
72letter [0-9A-Za-z]
73hexdigit [0-9A-Fa-f]
93/*octet (([01]?{digit}?{digit})|((2([0-4]{digit}))|(25[0-5])))*/
94special [()+\|\?\*,]
95dot \.
74dot \.
96comma \,
97hyphen \-
75hyphen \-
98colon \:
99slash \/
76slash \/
100bcl \{
101ecl \}
102blcl \[
103elcl \]
77blcl \[
78elcl \]
104percent \%
105semi \;
79semi \;
106usec {dot}{digit}{1,6}
107comment \#.*
80comment \#.*
108ccomment "/*"
109bracketstring \<[^>]*\>
110quotedstring \"[^"]*\"
111decstring {digit}+
81quotedstring \"[^"]*\"
82decstring {digit}+
112hexpair {hexdigit}{hexdigit}
113hexstring 0[xX]{hexdigit}+
83hexstring 0[xX]{hexdigit}+
114octetstring {octet}({dot}{octet})+
115ipaddress [a-fA-F0-9:]([a-fA-F0-9:\.]*|[a-fA-F0-9:\.]*%[a-zA-Z0-9]*)
116ipaddrmask {slash}{digit}{1,3}
84ipaddress [a-fA-F0-9:]([a-fA-F0-9:\.]*|[a-fA-F0-9:\.]*%[a-zA-Z0-9]*)
85ipaddrmask {slash}{digit}{1,3}
117ipaddrport {blcl}{decstring}{elcl}
118keyword {letter}{letter}+
119name {letter}(({letter}|{digit}|{hyphen})*({letter}|{digit}))*
120hostname {name}(({dot}{name})+{dot}?)?
121
86name {letter}(({letter}|{digit}|{hyphen})*({letter}|{digit}))*
87hostname {name}(({dot}{name})+{dot}?)?
88
122%s S_PL
89%s S_PL S_AUTHALG S_ENCALG
123
124%%
125
90
91%%
92
126add { PREPROC; return(ADD); }
127delete { PREPROC; return(DELETE); }
128deleteall { PREPROC; return(DELETEALL); }
129get { PREPROC; return(GET); }
130flush { PREPROC; return(FLUSH); }
131dump { PREPROC; return(DUMP); }
93add { return(ADD); }
94delete { return(DELETE); }
95deleteall { return(DELETEALL); }
96get { return(GET); }
97flush { return(FLUSH); }
98dump { return(DUMP); }
132
133 /* for management SPD */
99
100 /* for management SPD */
134spdadd { PREPROC; return(SPDADD); }
135spddelete { PREPROC; return(SPDDELETE); }
136spddump { PREPROC; return(SPDDUMP); }
137spdflush { PREPROC; return(SPDFLUSH); }
138{hyphen}P { BEGIN S_PL; PREPROC; return(F_POLICY); }
139<S_PL>[a-zA-Z0-9:\.\-_/ \n\t][a-zA-Z0-9:\.\-_/ \n\t]* {
140 yymore();
101spdadd { return(SPDADD); }
102spddelete { return(SPDDELETE); }
103spddump { return(SPDDUMP); }
104spdflush { return(SPDFLUSH); }
105tagged { return(TAGGED); }
106{hyphen}P { BEGIN S_PL; return(F_POLICY); }
107<S_PL>[a-zA-Z0-9:\.\-_/ \n\t][a-zA-Z0-9:\.%\-_/ \n\t]* {
108 yymore();
141
109
142 /* count up for nl */
143 {
144 char *p;
145 for (p = yytext; *p != NULL; p++)
146 if (*p == '\n')
147 lineno++;
148 }
110 /* count up for nl */
111 {
112 char *p;
113 for (p = yytext; *p != NULL; p++)
114 if (*p == '\n')
115 lineno++;
116 }
149
117
150 yylval.val.len = strlen(yytext);
151 yylval.val.buf = strdup(yytext);
118 yylval.val.len = strlen(yytext);
119 yylval.val.buf = strdup(yytext);
120 if (!yylval.val.buf)
121 yyfatal("insufficient memory");
152
122
153 return(PL_REQUESTS);
154}
155<S_PL>{semi} { PREPROC; BEGIN INITIAL; return(EOT); }
123 return(PL_REQUESTS);
124 }
125{semi} { BEGIN INITIAL; return(EOT); }
156
126
127 /* address resolution flags */
128{hyphen}[n46][n46]* {
129 yylval.val.len = strlen(yytext);
130 yylval.val.buf = strdup(yytext);
131 if (!yylval.val.buf)
132 yyfatal("insufficient memory");
133 return(F_AIFLAGS);
134 }
135
157 /* security protocols */
136 /* security protocols */
158ah { PREPROC; yylval.num = 0; return(PR_AH); }
159esp { PREPROC; yylval.num = 0; return(PR_ESP); }
160ah-old { PREPROC; yylval.num = 1; return(PR_AH); }
161esp-old { PREPROC; yylval.num = 1; return(PR_ESP); }
162ipcomp { PREPROC; yylval.num = 0; return(PR_IPCOMP); }
137ah { yylval.num = 0; return(PR_AH); }
138esp { yylval.num = 0; return(PR_ESP); }
139ah-old { yylval.num = 1; return(PR_AH); }
140esp-old { yylval.num = 1; return(PR_ESP); }
141ipcomp { yylval.num = 0; return(PR_IPCOMP); }
163
164 /* authentication alogorithm */
142
143 /* authentication alogorithm */
165{hyphen}A { PREPROC; return(F_AUTH); }
166hmac-md5 { PREPROC; yylval.num = SADB_AALG_MD5HMAC; return(ALG_AUTH); }
167hmac-sha1 { PREPROC; yylval.num = SADB_AALG_SHA1HMAC; return(ALG_AUTH); }
168keyed-md5 { PREPROC; yylval.num = SADB_X_AALG_MD5; return(ALG_AUTH); }
169keyed-sha1 { PREPROC; yylval.num = SADB_X_AALG_SHA; return(ALG_AUTH); }
170hmac-sha2-256 { PREPROC; yylval.num = SADB_X_AALG_SHA2_256; return(ALG_AUTH); }
171hmac-sha2-384 { PREPROC; yylval.num = SADB_X_AALG_SHA2_384; return(ALG_AUTH); }
172hmac-sha2-512 { PREPROC; yylval.num = SADB_X_AALG_SHA2_512; return(ALG_AUTH); }
173hmac-ripemd160 { PREPROC; yylval.num = SADB_X_AALG_RIPEMD160HMAC; return(ALG_AUTH); }
174aes-xcbc-mac { PREPROC; yylval.num = SADB_X_AALG_AES_XCBC_MAC; return(ALG_AUTH); }
175null { PREPROC; yylval.num = SADB_X_AALG_NULL; return(ALG_AUTH); }
144{hyphen}A { BEGIN S_AUTHALG; return(F_AUTH); }
145<S_AUTHALG>hmac-md5 { yylval.num = SADB_AALG_MD5HMAC; BEGIN INITIAL; return(ALG_AUTH); }
146<S_AUTHALG>hmac-sha1 { yylval.num = SADB_AALG_SHA1HMAC; BEGIN INITIAL; return(ALG_AUTH); }
147<S_AUTHALG>keyed-md5 { yylval.num = SADB_X_AALG_MD5; BEGIN INITIAL; return(ALG_AUTH); }
148<S_AUTHALG>keyed-sha1 { yylval.num = SADB_X_AALG_SHA; BEGIN INITIAL; return(ALG_AUTH); }
149<S_AUTHALG>hmac-sha2-256 { yylval.num = SADB_X_AALG_SHA2_256; BEGIN INITIAL; return(ALG_AUTH); }
150<S_AUTHALG>hmac-sha2-384 { yylval.num = SADB_X_AALG_SHA2_384; BEGIN INITIAL; return(ALG_AUTH); }
151<S_AUTHALG>hmac-sha2-512 { yylval.num = SADB_X_AALG_SHA2_512; BEGIN INITIAL; return(ALG_AUTH); }
152<S_AUTHALG>hmac-ripemd160 { yylval.num = SADB_X_AALG_RIPEMD160HMAC; BEGIN INITIAL; return(ALG_AUTH); }
153<S_AUTHALG>aes-xcbc-mac { yylval.num = SADB_X_AALG_AES_XCBC_MAC; BEGIN INITIAL; return(ALG_AUTH); }
154<S_AUTHALG>null { yylval.num = SADB_X_AALG_NULL; BEGIN INITIAL; return(ALG_AUTH_NOKEY); }
176
177 /* encryption alogorithm */
155
156 /* encryption alogorithm */
178{hyphen}E { PREPROC; return(F_ENC); }
179des-cbc { PREPROC; yylval.num = SADB_EALG_DESCBC; return(ALG_ENC); }
1803des-cbc { PREPROC; yylval.num = SADB_EALG_3DESCBC; return(ALG_ENC); }
181simple { PREPROC; yylval.num = SADB_EALG_NULL; return(ALG_ENC); }
182blowfish-cbc { PREPROC; yylval.num = SADB_X_EALG_BLOWFISHCBC; return(ALG_ENC); }
183cast128-cbc { PREPROC; yylval.num = SADB_X_EALG_CAST128CBC; return(ALG_ENC); }
184des-deriv { PREPROC; yylval.num = SADB_EALG_DESCBC; return(ALG_ENC_DESDERIV); }
185des-32iv { PREPROC; yylval.num = SADB_EALG_DESCBC; return(ALG_ENC_DES32IV); }
186rijndael-cbc { PREPROC; yylval.num = SADB_X_EALG_RIJNDAELCBC; return(ALG_ENC); }
187aes-ctr { PREPROC; yylval.num = SADB_X_EALG_AESCTR; return(ALG_ENC); }
157{hyphen}E { BEGIN S_ENCALG; return(F_ENC); }
158<S_ENCALG>des-cbc { yylval.num = SADB_EALG_DESCBC; BEGIN INITIAL; return(ALG_ENC); }
159<S_ENCALG>3des-cbc { yylval.num = SADB_EALG_3DESCBC; BEGIN INITIAL; return(ALG_ENC); }
160<S_ENCALG>null { yylval.num = SADB_EALG_NULL; BEGIN INITIAL; return(ALG_ENC_NOKEY); }
161<S_ENCALG>simple { yylval.num = SADB_EALG_NULL; BEGIN INITIAL; return(ALG_ENC_OLD); }
162<S_ENCALG>blowfish-cbc { yylval.num = SADB_X_EALG_BLOWFISHCBC; BEGIN INITIAL; return(ALG_ENC); }
163<S_ENCALG>cast128-cbc { yylval.num = SADB_X_EALG_CAST128CBC; BEGIN INITIAL; return(ALG_ENC); }
164<S_ENCALG>des-deriv { yylval.num = SADB_EALG_DESCBC; BEGIN INITIAL; return(ALG_ENC_DESDERIV); }
165<S_ENCALG>des-32iv { yylval.num = SADB_EALG_DESCBC; BEGIN INITIAL; return(ALG_ENC_DES32IV); }
166<S_ENCALG>rijndael-cbc { yylval.num = SADB_X_EALG_RIJNDAELCBC; BEGIN INITIAL; return(ALG_ENC); }
167<S_ENCALG>aes-ctr { yylval.num = SADB_X_EALG_AESCTR; BEGIN INITIAL; return(ALG_ENC); }
188
189 /* compression algorithms */
168
169 /* compression algorithms */
190{hyphen}C { PREPROC; return(F_COMP); }
191oui { PREPROC; yylval.num = SADB_X_CALG_OUI; return(ALG_COMP); }
192deflate { PREPROC; yylval.num = SADB_X_CALG_DEFLATE; return(ALG_COMP); }
193lzs { PREPROC; yylval.num = SADB_X_CALG_LZS; return(ALG_COMP); }
194{hyphen}R { PREPROC; return(F_RAWCPI); }
170{hyphen}C { return(F_COMP); }
171oui { yylval.num = SADB_X_CALG_OUI; return(ALG_COMP); }
172deflate { yylval.num = SADB_X_CALG_DEFLATE; return(ALG_COMP); }
173lzs { yylval.num = SADB_X_CALG_LZS; return(ALG_COMP); }
174{hyphen}R { return(F_RAWCPI); }
195
196 /* extension */
175
176 /* extension */
197{hyphen}m { PREPROC; return(F_MODE); }
198transport { PREPROC; yylval.num = IPSEC_MODE_TRANSPORT; return(MODE); }
199tunnel { PREPROC; yylval.num = IPSEC_MODE_TUNNEL; return(MODE); }
200{hyphen}u { PREPROC; return(F_REQID); }
201{hyphen}f { PREPROC; return(F_EXT); }
202random-pad { PREPROC; yylval.num = SADB_X_EXT_PRAND; return(EXTENSION); }
203seq-pad { PREPROC; yylval.num = SADB_X_EXT_PSEQ; return(EXTENSION); }
204zero-pad { PREPROC; yylval.num = SADB_X_EXT_PZERO; return(EXTENSION); }
205nocyclic-seq { PREPROC; return(NOCYCLICSEQ); }
206{hyphen}r { PREPROC; return(F_REPLAY); }
207{hyphen}lh { PREPROC; return(F_LIFETIME_HARD); }
208{hyphen}ls { PREPROC; return(F_LIFETIME_SOFT); }
177{hyphen}m { return(F_MODE); }
178transport { yylval.num = IPSEC_MODE_TRANSPORT; return(MODE); }
179tunnel { yylval.num = IPSEC_MODE_TUNNEL; return(MODE); }
180{hyphen}u { return(F_REQID); }
181{hyphen}f { return(F_EXT); }
182random-pad { yylval.num = SADB_X_EXT_PRAND; return(EXTENSION); }
183seq-pad { yylval.num = SADB_X_EXT_PSEQ; return(EXTENSION); }
184zero-pad { yylval.num = SADB_X_EXT_PZERO; return(EXTENSION); }
185nocyclic-seq { return(NOCYCLICSEQ); }
186{hyphen}r { return(F_REPLAY); }
187{hyphen}lh { return(F_LIFETIME_HARD); }
188{hyphen}ls { return(F_LIFETIME_SOFT); }
209
210 /* ... */
189
190 /* ... */
211any { PREPROC; return(ANY); }
212{ws} { PREPROC; }
191any { return(ANY); }
192{ws} { }
213{nl} { lineno++; }
214{comment}
193{nl} { lineno++; }
194{comment}
215{semi} { PREPROC; return(EOT); }
195{semi} { return(EOT); }
216
196
197 /* for address parameters: /prefix, [port] */
198{slash} { return SLASH; }
199{blcl} { return BLCL; }
200{elcl} { return ELCL; }
201
217 /* parameter */
218{decstring} {
219 char *bp;
220
202 /* parameter */
203{decstring} {
204 char *bp;
205
221 PREPROC;
222 yylval.num = strtoul(yytext, &bp, 10);
206 yylval.ulnum = strtoul(yytext, &bp, 10);
223 return(DECSTRING);
224 }
225
207 return(DECSTRING);
208 }
209
226{ipaddress} {
227 PREPROC;
228
229 yylval.val.len = yyleng;
230 yylval.val.buf = strdup(yytext);
231
232 return(ADDRESS);
233 }
234
235{ipaddrmask} {
236 PREPROC;
237 yytext++;
238 yylval.num = atoi(yytext);
239 return(PREFIX);
240 }
241
242{ipaddrport} {
243 char *p = yytext;
244 PREPROC;
245 while (*++p != ']') ;
246 *p = NULL;
247 yytext++;
248 yylval.num = atoi(yytext);
249 return(PORT);
250 }
251
252{blcl}any{elcl} {
253 PREPROC;
254 return(PORTANY);
255 }
256
257{hexstring} {
210{hexstring} {
258 int len = yyleng - 2; /* (str - "0x") */
259 PREPROC;
260 yylval.val.len = (len & 1) + (len / 2);
261 /* fixed string if length is odd. */
262 if (len & 1) {
263 yytext[1] = '0';
264 yylval.val.buf = strdup(yytext + 1);
265 } else
266 yylval.val.buf = strdup(yytext + 2);
211 yylval.val.buf = strdup(yytext + 2);
212 if (!yylval.val.buf)
213 yyfatal("insufficient memory");
214 yylval.val.len = strlen(yylval.val.buf);
267
268 return(HEXSTRING);
269 }
270
271{quotedstring} {
272 char *p = yytext;
215
216 return(HEXSTRING);
217 }
218
219{quotedstring} {
220 char *p = yytext;
273 PREPROC;
274 while (*++p != '"') ;
275 *p = NULL;
276 yytext++;
277 yylval.val.len = yyleng - 2;
278 yylval.val.buf = strdup(yytext);
221 while (*++p != '"') ;
222 *p = NULL;
223 yytext++;
224 yylval.val.len = yyleng - 2;
225 yylval.val.buf = strdup(yytext);
226 if (!yylval.val.buf)
227 yyfatal("insufficient memory");
279
280 return(QUOTEDSTRING);
281 }
282
228
229 return(QUOTEDSTRING);
230 }
231
283[a-z0-9.\-]* {
232[A-Za-z0-9:][A-Za-z0-9:%\.-]* {
284 yylval.val.len = yyleng;
285 yylval.val.buf = strdup(yytext);
233 yylval.val.len = yyleng;
234 yylval.val.buf = strdup(yytext);
235 if (!yylval.val.buf)
236 yyfatal("insufficient memory");
286 return(STRING);
287 }
288
237 return(STRING);
238 }
239
240[0-9,]+ {
241 yylval.val.len = yyleng;
242 yylval.val.buf = strdup(yytext);
243 if (!yylval.val.buf)
244 yyfatal("insufficient memory");
245 return(STRING);
246 }
247
289. {
290 yyfatal("Syntax error");
291 /*NOTREACHED*/
292 }
293
294%%
295
296void

--- 29 unchanged lines hidden --- 		248. {
249 yyfatal("Syntax error");
250 /*NOTREACHED*/
251 }
252
253%%
254
255void

--- 29 unchanged lines hidden ---