source: rtems-libbsd/ipsec-tools/src/setkey/token.l @ ff36f5e

5-freebsd-12
Last change on this file since ff36f5e was ff36f5e, checked in by Christian Mauderer <christian.mauderer@…>, on May 30, 2018 at 12:27:35 PM

Import ipsec-tools 0.8.2.

Import unchanged ipsec-tools sources in the release version 0.8.2. The
homepage of ipsec-tools is http://ipsec-tools.sourceforge.net/. The
sources can be obtained from there.

  • Property mode set to 100644
File size: 10.1 KB
Line 
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 */
92nl              \n
93ws              [ \t]+
94digit           [0-9]
95letter          [0-9A-Za-z]
96hexdigit        [0-9A-Fa-f]
97dot             \.
98hyphen          \-
99slash           \/
100blcl            \[
101elcl            \]
102semi            \;
103comment         \#.*
104quotedstring    \"[^"]*\"
105decstring       {digit}+
106hexstring       0[xX]{hexdigit}+
107ipaddress       [a-fA-F0-9:]([a-fA-F0-9:\.]*|[a-fA-F0-9:\.]*%[a-zA-Z0-9]*)
108ipaddrmask      {slash}{digit}{1,3}
109name            {letter}(({letter}|{digit}|{hyphen})*({letter}|{digit}))*
110hostname        {name}(({dot}{name})+{dot}?)?
111
112%s S_PL S_AUTHALG S_ENCALG
113
114%option noinput nounput
115%%
116
117
118add             { return(ADD); }
119delete          { return(DELETE); }
120deleteall       { return(DELETEALL); }
121get             { return(GET); }
122flush           { return(FLUSH); }
123dump            { return(DUMP); }
124exit            { return(EXIT); }
125quit            { return(EXIT); }
126bye             { return(EXIT); }
127
128        /* for management SPD */
129spdadd          { return(SPDADD); }
130spdupdate       { return(SPDUPDATE); }
131spddelete       { return(SPDDELETE); }
132spddump         { return(SPDDUMP); }
133spdflush        { return(SPDFLUSH); }
134tagged          { 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 */
166ah              { yylval.num = 0; return(PR_AH); }
167esp             { yylval.num = 0; return(PR_ESP); }
168ah-old          { yylval.num = 1; return(PR_AH); }
169esp-old         { yylval.num = 1; return(PR_ESP); }
170esp-udp         { yylval.num = 0; return(PR_ESPUDP); }
171ipcomp          { yylval.num = 0; return(PR_IPCOMP); }
172tcp             {
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); }
229oui             { yylval.num = SADB_X_CALG_OUI; return(ALG_COMP); }
230deflate         { yylval.num = SADB_X_CALG_DEFLATE; return(ALG_COMP); }
231lzs             { yylval.num = SADB_X_CALG_LZS; return(ALG_COMP); }
232{hyphen}R       { return(F_RAWCPI); }
233
234        /* extension */
235{hyphen}m       { return(F_MODE); }
236transport       { yylval.num = IPSEC_MODE_TRANSPORT; return(MODE); }
237tunnel          { yylval.num = IPSEC_MODE_TUNNEL; return(MODE); }
238{hyphen}u       { return(F_REQID); }
239{hyphen}f       { return(F_EXT); }
240random-pad      { yylval.num = SADB_X_EXT_PRAND; return(EXTENSION); }
241seq-pad         { yylval.num = SADB_X_EXT_PSEQ; return(EXTENSION); }
242zero-pad        { yylval.num = SADB_X_EXT_PZERO; return(EXTENSION); }
243nocyclic-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        /* ... */
252any             { 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
316void
317yyfatal(s)
318        const char *s;
319{
320        yyerror(s);
321        exit(1);
322}
323
324void
325yyerror(s)
326        const char *s;
327{
328        printf("line %d: %s at [%s]\n", lineno, s, yytext);
329}
330
331int
332parse(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
348int
349parse_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
Note: See TracBrowser for help on using the repository browser.