Context Navigation

policy_token.c

6-freebsd-12

Last change on this file was b376ae1, checked in by Christian Mauderer <christian.mauderer@…>, on 05/03/18 at 12:15:11

ipsec-tools: Port libipsec, setkey and racoon.

Note that this replaces the libipsec from FreeBSD with the one provided
by ipsec-tools.

Property mode set to 100644

File size: 57.3 KB

Line
1
2	#line 3 "<stdout>"
3
4	#define YY_INT_ALIGNED short int
5
6	/* A lexical scanner generated by flex */
7
8	#define yy_create_buffer __libipsec_create_buffer
9	#define yy_delete_buffer __libipsec_delete_buffer
10	#define yy_flex_debug __libipsec_flex_debug
11	#define yy_init_buffer __libipsec_init_buffer
12	#define yy_flush_buffer __libipsec_flush_buffer
13	#define yy_load_buffer_state __libipsec_load_buffer_state
14	#define yy_switch_to_buffer __libipsec_switch_to_buffer
15	#define yyin __libipsecin
16	#define yyleng __libipsecleng
17	#define yylex __libipseclex
18	#define yylineno __libipseclineno
19	#define yyout __libipsecout
20	#define yyrestart __libipsecrestart
21	#define yytext __libipsectext
22	#define yywrap __libipsecwrap
23	#define yyalloc __libipsecalloc
24	#define yyrealloc __libipsecrealloc
25	#define yyfree __libipsecfree
26
27	#define FLEX_SCANNER
28	#define YY_FLEX_MAJOR_VERSION 2
29	#define YY_FLEX_MINOR_VERSION 5
30	#define YY_FLEX_SUBMINOR_VERSION 37
31	#if YY_FLEX_SUBMINOR_VERSION > 0
32	#define FLEX_BETA
33	#endif
34
35	/* First, we deal with platform-specific or compiler-specific issues. */
36
37	#if defined(__FreeBSD__)
38	#ifndef __STDC_LIMIT_MACROS
39	#define __STDC_LIMIT_MACROS
40	#endif
41	#include <sys/cdefs.h>
42	#include <stdint.h>
43	#else
44	#define __dead2
45	#endif
46
47	/* begin standard C headers. */
48	#include <stdio.h>
49	#include <string.h>
50	#include <errno.h>
51	#include <stdlib.h>
52
53	/* end standard C headers. */
54
55	/* flex integer type definitions */
56
57	#ifndef FLEXINT_H
58	#define FLEXINT_H
59
60	/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
61
62	#if defined(__FreeBSD__) \|\| \
63	(defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
64
65	/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
66	* if you want the limit (max/min) macros for int types.
67	*/
68	#ifndef __STDC_LIMIT_MACROS
69	#define __STDC_LIMIT_MACROS 1
70	#endif
71
72	#include <inttypes.h>
73	typedef int8_t flex_int8_t;
74	typedef uint8_t flex_uint8_t;
75	typedef int16_t flex_int16_t;
76	typedef uint16_t flex_uint16_t;
77	typedef int32_t flex_int32_t;
78	typedef uint32_t flex_uint32_t;
79	#else
80	typedef signed char flex_int8_t;
81	typedef short int flex_int16_t;
82	typedef int flex_int32_t;
83	typedef unsigned char flex_uint8_t;
84	typedef unsigned short int flex_uint16_t;
85	typedef unsigned int flex_uint32_t;
86
87	/* Limits of integral types. */
88	#ifndef INT8_MIN
89	#define INT8_MIN (-128)
90	#endif
91	#ifndef INT16_MIN
92	#define INT16_MIN (-32767-1)
93	#endif
94	#ifndef INT32_MIN
95	#define INT32_MIN (-2147483647-1)
96	#endif
97	#ifndef INT8_MAX
98	#define INT8_MAX (127)
99	#endif
100	#ifndef INT16_MAX
101	#define INT16_MAX (32767)
102	#endif
103	#ifndef INT32_MAX
104	#define INT32_MAX (2147483647)
105	#endif
106	#ifndef UINT8_MAX
107	#define UINT8_MAX (255U)
108	#endif
109	#ifndef UINT16_MAX
110	#define UINT16_MAX (65535U)
111	#endif
112	#ifndef UINT32_MAX
113	#define UINT32_MAX (4294967295U)
114	#endif
115
116	#endif /* ! C99 */
117
118	#endif /* ! FLEXINT_H */
119
120	#ifdef __cplusplus
121
122	/* The "const" storage-class-modifier is valid. */
123	#define YY_USE_CONST
124
125	#else /* ! __cplusplus */
126
127	/* C99 requires __STDC__ to be defined as 1. */
128	#if defined (__STDC__)
129
130	#define YY_USE_CONST
131
132	#endif /* defined (__STDC__) */
133	#endif /* ! __cplusplus */
134
135	#ifdef YY_USE_CONST
136	#define yyconst const
137	#else
138	#define yyconst
139	#endif
140
141	/* Returned upon end-of-file. */
142	#define YY_NULL 0
143
144	/* Promotes a possibly negative, possibly signed char to an unsigned
145	* integer for use as an array index. If the signed char is negative,
146	* we want to instead treat it as an 8-bit unsigned char, hence the
147	* double cast.
148	*/
149	#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
150
151	/* Enter a start condition. This macro really ought to take a parameter,
152	* but we do it the disgusting crufty way forced on us by the ()-less
153	* definition of BEGIN.
154	*/
155	#define BEGIN (yy_start) = 1 + 2 *
156
157	/* Translate the current start state into a value that can be later handed
158	* to BEGIN to return to the state. The YYSTATE alias is for lex
159	* compatibility.
160	*/
161	#define YY_START (((yy_start) - 1) / 2)
162	#define YYSTATE YY_START
163
164	/* Action number for EOF rule of a given start state. */
165	#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
166
167	/* Special action meaning "start processing a new file". */
168	#define YY_NEW_FILE __libipsecrestart(__libipsecin )
169
170	#define YY_END_OF_BUFFER_CHAR 0
171
172	/* Size of default input buffer. */
173	#ifndef YY_BUF_SIZE
174	#define YY_BUF_SIZE 1024
175	#endif
176
177	/* The state buf must be large enough to hold one state per character in the main buffer.
178	*/
179	#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
180
181	#ifndef YY_TYPEDEF_YY_BUFFER_STATE
182	#define YY_TYPEDEF_YY_BUFFER_STATE
183	typedef struct yy_buffer_state *YY_BUFFER_STATE;
184	#endif
185
186	#ifndef YY_TYPEDEF_YY_SIZE_T
187	#define YY_TYPEDEF_YY_SIZE_T
188	typedef size_t yy_size_t;
189	#endif
190
191	extern yy_size_t __libipsecleng;
192
193	extern FILE __libipsecin, __libipsecout;
194
195	#define EOB_ACT_CONTINUE_SCAN 0
196	#define EOB_ACT_END_OF_FILE 1
197	#define EOB_ACT_LAST_MATCH 2
198
199	#define YY_LESS_LINENO(n)
200
201	/* Return all but the first "n" matched characters back to the input stream. */
202	#define yyless(n) \
203	do \
204	{ \
205	/* Undo effects of setting up __libipsectext. */ \
206	int yyless_macro_arg = (n); \
207	YY_LESS_LINENO(yyless_macro_arg);\
208	*yy_cp = (yy_hold_char); \
209	YY_RESTORE_YY_MORE_OFFSET \
210	(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
211	YY_DO_BEFORE_ACTION; /* set up __libipsectext again */ \
212	} \
213	while ( 0 )
214
215	#define unput(c) yyunput( c, (yytext_ptr) )
216
217	#ifndef YY_STRUCT_YY_BUFFER_STATE
218	#define YY_STRUCT_YY_BUFFER_STATE
219	struct yy_buffer_state
220	{
221	FILE *yy_input_file;
222
223	char yy_ch_buf; / input buffer */
224	char yy_buf_pos; / current position in input buffer */
225
226	/* Size of input buffer in bytes, not including room for EOB
227	* characters.
228	*/
229	yy_size_t yy_buf_size;
230
231	/* Number of characters read into yy_ch_buf, not including EOB
232	* characters.
233	*/
234	yy_size_t yy_n_chars;
235
236	/* Whether we "own" the buffer - i.e., we know we created it,
237	* and can realloc() it to grow it, and should free() it to
238	* delete it.
239	*/
240	int yy_is_our_buffer;
241
242	/* Whether this is an "interactive" input source; if so, and
243	* if we're using stdio for input, then we want to use getc()
244	* instead of fread(), to make sure we stop fetching input after
245	* each newline.
246	*/
247	int yy_is_interactive;
248
249	/* Whether we're considered to be at the beginning of a line.
250	* If so, '^' rules will be active on the next match, otherwise
251	* not.
252	*/
253	int yy_at_bol;
254
255	int yy_bs_lineno; /*< The line count. /
256	int yy_bs_column; /*< The column count. /
257
258	/* Whether to try to fill the input buffer when we reach the
259	* end of it.
260	*/
261	int yy_fill_buffer;
262
263	int yy_buffer_status;
264
265	#define YY_BUFFER_NEW 0
266	#define YY_BUFFER_NORMAL 1
267	/* When an EOF's been seen but there's still some text to process
268	* then we mark the buffer as YY_EOF_PENDING, to indicate that we
269	* shouldn't try reading from the input source any more. We might
270	* still have a bunch of tokens to match, though, because of
271	* possible backing-up.
272	*
273	* When we actually see the EOF, we change the status to "new"
274	* (via __libipsecrestart()), so that the user can continue scanning by
275	* just pointing __libipsecin at a new input file.
276	*/
277	#define YY_BUFFER_EOF_PENDING 2
278
279	};
280	#endif /* !YY_STRUCT_YY_BUFFER_STATE */
281
282	/* Stack of input buffers. */
283	static size_t yy_buffer_stack_top = 0; /*< index of top of stack. /
284	static size_t yy_buffer_stack_max = 0; /*< capacity of stack. /
285	static YY_BUFFER_STATE * yy_buffer_stack = 0; /*< Stack as an array. /
286
287	/* We provide macros for accessing buffer states in case in the
288	* future we want to put the buffer states in a more general
289	* "scanner state".
290	*
291	* Returns the top of the stack, or NULL.
292	*/
293	#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
294	? (yy_buffer_stack)[(yy_buffer_stack_top)] \
295	: NULL)
296	#define yy_current_buffer YY_CURRENT_BUFFER
297
298	/* Same as previous macro, but useful when we know that the buffer stack is not
299	* NULL or when we need an lvalue. For internal use only.
300	*/
301	#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
302
303	/* yy_hold_char holds the character lost when __libipsectext is formed. */
304	static char yy_hold_char;
305	static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
306	yy_size_t __libipsecleng;
307
308	/* Points to current character in buffer. */
309	static char yy_c_buf_p = (char ) 0;
310	static int yy_init = 0; /* whether we need to initialize */
311	static int yy_start = 0; /* start state number */
312
313	/* Flag which is used to allow __libipsecwrap()'s to do buffer switches
314	* instead of setting up a fresh __libipsecin. A bit of a hack ...
315	*/
316	static int yy_did_buffer_switch_on_eof;
317
318	void __libipsecrestart (FILE *input_file );
319	void __libipsec_switch_to_buffer (YY_BUFFER_STATE new_buffer );
320	YY_BUFFER_STATE __libipsec_create_buffer (FILE *file,int size );
321	void __libipsec_delete_buffer (YY_BUFFER_STATE b );
322	void __libipsec_flush_buffer (YY_BUFFER_STATE b );
323	void __libipsecpush_buffer_state (YY_BUFFER_STATE new_buffer );
324	void __libipsecpop_buffer_state (void );
325
326	static void __libipsecensure_buffer_stack (void );
327	static void __libipsec_load_buffer_state (void );
328	static void __libipsec_init_buffer (YY_BUFFER_STATE b,FILE *file );
329
330	#define YY_FLUSH_BUFFER __libipsec_flush_buffer(YY_CURRENT_BUFFER )
331
332	YY_BUFFER_STATE __libipsec_scan_buffer (char *base,yy_size_t size );
333	YY_BUFFER_STATE __libipsec_scan_string (yyconst char *yy_str );
334	YY_BUFFER_STATE __libipsec_scan_bytes (yyconst char *bytes,yy_size_t len );
335
336	void *__libipsecalloc (yy_size_t );
337	void __libipsecrealloc (void ,yy_size_t );
338	void __libipsecfree (void * );
339
340	#define yy_new_buffer __libipsec_create_buffer
341
342	#define yy_set_interactive(is_interactive) \
343	{ \
344	if ( ! YY_CURRENT_BUFFER ){ \
345	__libipsecensure_buffer_stack (); \
346	YY_CURRENT_BUFFER_LVALUE = \
347	__libipsec_create_buffer(__libipsecin,YY_BUF_SIZE ); \
348	} \
349	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
350	}
351
352	#define yy_set_bol(at_bol) \
353	{ \
354	if ( ! YY_CURRENT_BUFFER ){\
355	__libipsecensure_buffer_stack (); \
356	YY_CURRENT_BUFFER_LVALUE = \
357	__libipsec_create_buffer(__libipsecin,YY_BUF_SIZE ); \
358	} \
359	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
360	}
361
362	#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
363
364	/* Begin user sect3 */
365
366	#define __libipsecwrap() 1
367	#define YY_SKIP_YYWRAP
368
369	typedef unsigned char YY_CHAR;
370
371	FILE __libipsecin = (FILE ) 0, __libipsecout = (FILE ) 0;
372
373	typedef int yy_state_type;
374
375	extern int __libipseclineno;
376
377	int __libipseclineno = 1;
378
379	extern char *__libipsectext;
380	#define yytext_ptr __libipsectext
381
382	static yy_state_type yy_get_previous_state (void );
383	static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
384	static int yy_get_next_buffer (void );
385	static void yy_fatal_error (yyconst char msg[] ) __dead2;
386
387	/* Done after the current pattern has been matched and before the
388	* corresponding action - sets up __libipsectext.
389	*/
390	#define YY_DO_BEFORE_ACTION \
391	(yytext_ptr) = yy_bp; \
392	__libipsecleng = (size_t) (yy_cp - yy_bp); \
393	(yy_hold_char) = *yy_cp; \
394	*yy_cp = '\0'; \
395	(yy_c_buf_p) = yy_cp;
396
397	#define YY_NUM_RULES 34
398	#define YY_END_OF_BUFFER 35
399	/* This struct is not used in this scanner,
400	but its presence is necessary. */
401	struct yy_trans_info
402	{
403	flex_int32_t yy_verify;
404	flex_int32_t yy_nxt;
405	};
406	static yyconst flex_int16_t yy_accept[121] =
407	{ 0,
408	0, 0, 35, 34, 32, 33, 9, 30, 29, 28,
409	10, 34, 29, 29, 29, 29, 29, 29, 29, 29,
410	29, 29, 29, 29, 29, 29, 29, 32, 0, 29,
411	10, 0, 17, 29, 29, 29, 29, 29, 29, 29,
412	29, 1, 29, 29, 21, 29, 29, 29, 29, 29,
413	29, 29, 29, 29, 31, 22, 29, 7, 29, 29,
414	16, 3, 29, 29, 29, 6, 29, 2, 29, 29,
415	29, 29, 29, 24, 29, 29, 29, 29, 8, 29,
416	29, 12, 5, 29, 29, 29, 29, 29, 29, 29,
417	29, 29, 13, 29, 29, 29, 29, 29, 14, 29,
418
419	29, 29, 18, 29, 29, 29, 20, 27, 23, 11,
420	15, 29, 25, 29, 29, 4, 29, 26, 19, 0
421	} ;
422
423	static yyconst flex_int32_t yy_ec[256] =
424	{ 0,
425	1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
426	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
427	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
428	1, 2, 1, 1, 1, 1, 4, 1, 1, 1,
429	1, 1, 5, 1, 6, 7, 8, 9, 9, 9,
430	9, 9, 9, 9, 9, 9, 9, 10, 1, 1,
431	1, 1, 1, 1, 11, 11, 11, 11, 11, 11,
432	11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
433	11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
434	12, 1, 13, 1, 7, 1, 14, 15, 16, 17,
435
436	18, 19, 20, 21, 22, 11, 11, 23, 24, 25,
437	26, 27, 28, 29, 30, 31, 32, 11, 33, 11,
438	34, 11, 1, 1, 1, 1, 1, 1, 1, 1,
439	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
440	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
441	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
442	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
443	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
444	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
445	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
446
447	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
448	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
449	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
450	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
451	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
452	1, 1, 1, 1, 1
453	} ;
454
455	static yyconst flex_int32_t yy_meta[35] =
456	{ 0,
457	1, 1, 1, 2, 1, 1, 2, 1, 3, 2,
458	3, 1, 1, 3, 3, 3, 3, 3, 3, 3,
459	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
460	3, 3, 3, 3
461	} ;
462
463	static yyconst flex_int16_t yy_base[123] =
464	{ 0,
465	0, 0, 235, 236, 232, 236, 236, 236, 229, 236,
466	31, 223, 32, 33, 34, 35, 37, 39, 41, 38,
467	40, 43, 42, 44, 45, 46, 47, 229, 0, 226,
468	50, 67, 225, 51, 67, 77, 58, 75, 78, 80,
469	79, 224, 82, 83, 223, 85, 86, 87, 91, 88,
470	89, 96, 97, 0, 236, 222, 99, 107, 104, 100,
471	221, 220, 103, 118, 119, 219, 121, 218, 122, 123,
472	124, 126, 128, 217, 127, 129, 131, 130, 216, 134,
473	136, 215, 137, 132, 138, 142, 139, 143, 146, 149,
474	155, 159, 214, 160, 161, 166, 168, 163, 213, 170,
475
476	171, 172, 212, 173, 176, 179, 211, 185, 206, 204,
477	202, 175, 196, 183, 188, 195, 180, 198, 194, 236,
478	211, 193
479	} ;
480
481	static yyconst flex_int16_t yy_def[123] =
482	{ 0,
483	120, 1, 120, 120, 120, 120, 120, 120, 121, 120,
484	121, 120, 121, 121, 121, 121, 121, 121, 121, 121,
485	121, 121, 121, 121, 121, 121, 121, 120, 122, 121,
486	121, 120, 121, 121, 121, 121, 121, 121, 121, 121,
487	121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
488	121, 121, 121, 122, 120, 121, 121, 121, 121, 121,
489	121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
490	121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
491	121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
492	121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
493
494	121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
495	121, 121, 121, 121, 121, 121, 121, 121, 121, 0,
496	120, 120
497	} ;
498
499	static yyconst flex_int16_t yy_nxt[271] =
500	{ 0,
501	4, 5, 6, 4, 7, 8, 9, 10, 11, 9,
502	9, 12, 4, 13, 14, 9, 15, 16, 17, 9,
503	18, 19, 20, 21, 22, 23, 24, 9, 25, 9,
504	26, 27, 9, 9, 29, 29, 29, 29, 29, 31,
505	29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
506	29, 36, 33, 29, 29, 37, 34, 45, 31, 38,
507	41, 29, 49, 44, 39, 42, 35, 43, 46, 40,
508	29, 52, 48, 47, 50, 32, 53, 51, 29, 55,
509	29, 29, 29, 29, 56, 29, 29, 59, 29, 29,
510	29, 29, 29, 57, 29, 58, 62, 64, 63, 29,
511
512	29, 71, 29, 29, 61, 60, 29, 29, 69, 67,
513	29, 65, 75, 72, 74, 66, 68, 73, 70, 77,
514	76, 29, 29, 79, 29, 29, 29, 29, 78, 29,
515	29, 29, 29, 29, 29, 29, 81, 29, 82, 29,
516	29, 29, 29, 80, 90, 29, 29, 83, 85, 29,
517	86, 93, 29, 95, 84, 87, 88, 92, 29, 97,
518	89, 91, 29, 29, 29, 94, 29, 96, 100, 29,
519	98, 29, 99, 29, 29, 29, 29, 101, 29, 29,
520	108, 104, 29, 29, 102, 103, 29, 110, 29, 105,
521	107, 29, 106, 113, 115, 54, 118, 29, 29, 29,
522
523	109, 29, 111, 112, 114, 29, 118, 29, 116, 29,
524	119, 117, 30, 30, 29, 29, 29, 29, 29, 29,
525	29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
526	28, 32, 29, 28, 120, 3, 120, 120, 120, 120,
527	120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
528	120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
529	120, 120, 120, 120, 120, 120, 120, 120, 120, 120
530	} ;
531
532	static yyconst flex_int16_t yy_chk[271] =
533	{ 0,
534	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
535	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
536	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
537	1, 1, 1, 1, 11, 13, 14, 15, 16, 11,
538	17, 20, 18, 21, 19, 23, 22, 24, 25, 26,
539	27, 15, 13, 31, 34, 15, 13, 21, 31, 16,
540	18, 37, 25, 20, 16, 19, 14, 19, 22, 17,
541	35, 27, 24, 23, 26, 32, 27, 26, 38, 32,
542	36, 39, 41, 40, 34, 43, 44, 37, 46, 47,
543	48, 50, 51, 35, 49, 36, 40, 43, 41, 52,
544
545	53, 50, 57, 60, 39, 38, 63, 59, 48, 46,
546	58, 43, 57, 51, 53, 44, 47, 52, 49, 59,
547	58, 64, 65, 63, 67, 69, 70, 71, 60, 72,
548	75, 73, 76, 78, 77, 84, 65, 80, 67, 81,
549	83, 85, 87, 64, 77, 86, 88, 69, 71, 89,
550	72, 81, 90, 84, 70, 73, 75, 80, 91, 86,
551	76, 78, 92, 94, 95, 83, 98, 85, 89, 96,
552	87, 97, 88, 100, 101, 102, 104, 90, 112, 105,
553	98, 94, 106, 117, 91, 92, 114, 101, 108, 95,
554	97, 115, 96, 105, 108, 122, 115, 119, 116, 113,
555
556	100, 118, 102, 104, 106, 111, 118, 110, 112, 109,
557	117, 114, 121, 121, 107, 103, 99, 93, 82, 79,
558	74, 68, 66, 62, 61, 56, 45, 42, 33, 30,
559	28, 12, 9, 5, 3, 120, 120, 120, 120, 120,
560	120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
561	120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
562	120, 120, 120, 120, 120, 120, 120, 120, 120, 120
563	} ;
564
565	static yy_state_type yy_last_accepting_state;
566	static char *yy_last_accepting_cpos;
567
568	extern int __libipsec_flex_debug;
569	int __libipsec_flex_debug = 0;
570
571	/* The intent behind this definition is that it'll catch
572	* any uses of REJECT which flex missed.
573	*/
574	#define REJECT reject_used_but_not_detected
575	#define yymore() yymore_used_but_not_detected
576	#define YY_MORE_ADJ 0
577	#define YY_RESTORE_YY_MORE_OFFSET
578	char *__libipsectext;
579	#line 1 "../../ipsec-tools/src/libipsec/policy_token.l"
580	/* $NetBSD: policy_token.l,v 1.7 2007/07/18 12:07:50 vanhu Exp $ */
581	/* Id: policy_token.l,v 1.12 2005/05/05 12:32:18 manubsd Exp */
582	/*
583	* Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
584	* All rights reserved.
585	*
586	* Redistribution and use in source and binary forms, with or without
587	* modification, are permitted provided that the following conditions
588	* are met:
589	* 1. Redistributions of source code must retain the above copyright
590	* notice, this list of conditions and the following disclaimer.
591	* 2. Redistributions in binary form must reproduce the above copyright
592	* notice, this list of conditions and the following disclaimer in the
593	* documentation and/or other materials provided with the distribution.
594	* 3. Neither the name of the project nor the names of its contributors
595	* may be used to endorse or promote products derived from this software
596	* without specific prior written permission.
597	*
598	* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
599	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
600	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
601	* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
602	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
603	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
604	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
605	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
606	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
607	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
608	* SUCH DAMAGE.
609	*/
610	#line 35 "../../ipsec-tools/src/libipsec/policy_token.l"
611	#ifdef __rtems__
612	#include <machine/rtems-bsd-user-space.h>
613	#endif /* __rtems__ */
614	#ifdef HAVE_CONFIG_H
615	#include "config.h"
616	#endif
617
618	#include <sys/types.h>
619	#include <sys/param.h>
620	#include <sys/socket.h>
621	#include <net/pfkeyv2.h>
622	#include <netinet/in.h>
623	#include PATH_IPSEC_H
624
625	#include <stdlib.h>
626	#include <limits.h>
627	#include <string.h>
628	#include <unistd.h>
629	#include <errno.h>
630
631	#include "libpfkey.h"
632
633	#if !defined(__NetBSD__) && !defined(__FreeBSD__) && !defined(__linux__) && \
634	!defined(__APPLE__) && !defined(__MACH__)
635	#include "y.tab.h"
636	#else
637	#include "policy_parse.h"
638	#endif
639	#define yylval __libipseclval /* XXX */
640
641	int __libipseclex __P((void));
642	/* common section */
643	#line 644 "<stdout>"
644
645	#define INITIAL 0
646
647	#ifndef YY_NO_UNISTD_H
648	/* Special case for "unistd.h", since it is non-ANSI. We include it way
649	* down here because we want the user's section 1 to have been scanned first.
650	* The user has a chance to override it with an option.
651	*/
652	#include <unistd.h>
653	#endif
654
655	#ifndef YY_EXTRA_TYPE
656	#define YY_EXTRA_TYPE void *
657	#endif
658
659	static int yy_init_globals (void );
660
661	/* Accessor methods to globals.
662	These are made visible to non-reentrant scanners for convenience. */
663
664	int __libipseclex_destroy (void );
665
666	int __libipsecget_debug (void );
667
668	void __libipsecset_debug (int debug_flag );
669
670	YY_EXTRA_TYPE __libipsecget_extra (void );
671
672	void __libipsecset_extra (YY_EXTRA_TYPE user_defined );
673
674	FILE *__libipsecget_in (void );
675
676	void __libipsecset_in (FILE * in_str );
677
678	FILE *__libipsecget_out (void );
679
680	void __libipsecset_out (FILE * out_str );
681
682	yy_size_t __libipsecget_leng (void );
683
684	char *__libipsecget_text (void );
685
686	int __libipsecget_lineno (void );
687
688	void __libipsecset_lineno (int line_number );
689
690	/* Macros after this point can all be overridden by user definitions in
691	* section 1.
692	*/
693
694	#ifndef YY_SKIP_YYWRAP
695	#ifdef __cplusplus
696	extern "C" int __libipsecwrap (void );
697	#else
698	extern int __libipsecwrap (void );
699	#endif
700	#endif
701
702	#ifndef yytext_ptr
703	static void yy_flex_strncpy (char ,yyconst char ,int );
704	#endif
705
706	#ifdef YY_NEED_STRLEN
707	static int yy_flex_strlen (yyconst char * );
708	#endif
709
710	#ifndef YY_NO_INPUT
711
712	#ifdef __cplusplus
713	static int yyinput (void );
714	#else
715	static int input (void );
716	#endif
717
718	#endif
719
720	/* Amount of stuff to slurp up with each read. */
721	#ifndef YY_READ_BUF_SIZE
722	#define YY_READ_BUF_SIZE 8192
723	#endif
724
725	/* Copy whatever the last rule matched to the standard output. */
726	#ifndef ECHO
727	/* This used to be an fputs(), but since the string might contain NUL's,
728	* we now use fwrite().
729	*/
730	#define ECHO do { if (fwrite( __libipsectext, __libipsecleng, 1, __libipsecout )) {} } while (0)
731	#endif
732
733	/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
734	* is returned in "result".
735	*/
736	#ifndef YY_INPUT
737	#define YY_INPUT(buf,result,max_size) \
738	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
739	{ \
740	int c = '*'; \
741	size_t n; \
742	for ( n = 0; n < max_size && \
743	(c = getc( __libipsecin )) != EOF && c != '\n'; ++n ) \
744	buf[n] = (char) c; \
745	if ( c == '\n' ) \
746	buf[n++] = (char) c; \
747	if ( c == EOF && ferror( __libipsecin ) ) \
748	YY_FATAL_ERROR( "input in flex scanner failed" ); \
749	result = n; \
750	} \
751	else \
752	{ \
753	errno=0; \
754	while ( (result = fread(buf, 1, max_size, __libipsecin))==0 && ferror(__libipsecin)) \
755	{ \
756	if( errno != EINTR) \
757	{ \
758	YY_FATAL_ERROR( "input in flex scanner failed" ); \
759	break; \
760	} \
761	errno=0; \
762	clearerr(__libipsecin); \
763	} \
764	}\
765	\
766
767	#endif
768
769	/* No semi-colon after return; correct usage is to write "yyterminate();" -
770	* we don't want an extra ';' after the "return" because that will cause
771	* some compilers to complain about unreachable statements.
772	*/
773	#ifndef yyterminate
774	#define yyterminate() return YY_NULL
775	#endif
776
777	/* Number of entries by which start-condition stack grows. */
778	#ifndef YY_START_STACK_INCR
779	#define YY_START_STACK_INCR 25
780	#endif
781
782	/* Report a fatal error. */
783	#ifndef YY_FATAL_ERROR
784	#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
785	#endif
786
787	/* end tables serialization structures and prototypes */
788
789	/* Default declaration of generated scanner - a define so the user can
790	* easily add parameters.
791	*/
792	#ifndef YY_DECL
793	#define YY_DECL_IS_OURS 1
794
795	extern int __libipseclex (void);
796
797	#define YY_DECL int __libipseclex (void)
798	#endif /* !YY_DECL */
799
800	/* Code executed at the beginning of each rule, after __libipsectext and __libipsecleng
801	* have been set up.
802	*/
803	#ifndef YY_USER_ACTION
804	#define YY_USER_ACTION
805	#endif
806
807	/* Code executed at the end of each rule. */
808	#ifndef YY_BREAK
809	#define YY_BREAK break;
810	#endif
811
812	#define YY_RULE_SETUP \
813	YY_USER_ACTION
814
815	/** The main scanner function which does all the work.
816	*/
817	YY_DECL
818	{
819	yy_state_type yy_current_state;
820	char yy_cp, yy_bp;
821	int yy_act;
822
823	#line 100 "../../ipsec-tools/src/libipsec/policy_token.l"
824
825
826	#line 827 "<stdout>"
827
828	if ( !(yy_init) )
829	{
830	(yy_init) = 1;
831
832	#ifdef YY_USER_INIT
833	YY_USER_INIT;
834	#endif
835
836	if ( ! (yy_start) )
837	(yy_start) = 1; /* first start state */
838
839	if ( ! __libipsecin )
840	__libipsecin = stdin;
841
842	if ( ! __libipsecout )
843	__libipsecout = stdout;
844
845	if ( ! YY_CURRENT_BUFFER ) {
846	__libipsecensure_buffer_stack ();
847	YY_CURRENT_BUFFER_LVALUE =
848	__libipsec_create_buffer(__libipsecin,YY_BUF_SIZE );
849	}
850
851	__libipsec_load_buffer_state( );
852	}
853
854	while ( 1 ) /* loops until end-of-file is reached */
855	{
856	yy_cp = (yy_c_buf_p);
857
858	/* Support of __libipsectext. */
859	*yy_cp = (yy_hold_char);
860
861	/* yy_bp points to the position in yy_ch_buf of the start of
862	* the current run.
863	*/
864	yy_bp = yy_cp;
865
866	yy_current_state = (yy_start);
867	yy_match:
868	do
869	{
870	YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
871	if ( yy_accept[yy_current_state] )
872	{
873	(yy_last_accepting_state) = yy_current_state;
874	(yy_last_accepting_cpos) = yy_cp;
875	}
876	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
877	{
878	yy_current_state = (int) yy_def[yy_current_state];
879	if ( yy_current_state >= 121 )
880	yy_c = yy_meta[(unsigned int) yy_c];
881	}
882	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
883	++yy_cp;
884	}
885	while ( yy_base[yy_current_state] != 236 );
886
887	yy_find_action:
888	yy_act = yy_accept[yy_current_state];
889	if ( yy_act == 0 )
890	{ /* have to back up */
891	yy_cp = (yy_last_accepting_cpos);
892	yy_current_state = (yy_last_accepting_state);
893	yy_act = yy_accept[yy_current_state];
894	}
895
896	YY_DO_BEFORE_ACTION;
897
898	do_action: /* This label is used only to access EOF actions. */
899
900	switch ( yy_act )
901	{ /* beginning of action switch */
902	case 0: /* must back up */
903	/* undo the effects of YY_DO_BEFORE_ACTION */
904	*yy_cp = (yy_hold_char);
905	yy_cp = (yy_last_accepting_cpos);
906	yy_current_state = (yy_last_accepting_state);
907	goto yy_find_action;
908
909	case 1:
910	YY_RULE_SETUP
911	#line 102 "../../ipsec-tools/src/libipsec/policy_token.l"
912	{ yylval.num = IPSEC_DIR_INBOUND; return(DIR); }
913	YY_BREAK
914	case 2:
915	YY_RULE_SETUP
916	#line 103 "../../ipsec-tools/src/libipsec/policy_token.l"
917	{ yylval.num = IPSEC_DIR_OUTBOUND; return(DIR); }
918	YY_BREAK
919	case 3:
920	YY_RULE_SETUP
921	#line 104 "../../ipsec-tools/src/libipsec/policy_token.l"
922	{
923	#ifdef HAVE_POLICY_FWD
924	yylval.num = IPSEC_DIR_FWD; return(DIR);
925	#else
926	yylval.num = IPSEC_DIR_INBOUND; return(DIR);
927	#endif
928	}
929	YY_BREAK
930	case 4:
931	YY_RULE_SETUP
932	#line 112 "../../ipsec-tools/src/libipsec/policy_token.l"
933	{ return(PRIORITY); }
934	YY_BREAK
935	case 5:
936	YY_RULE_SETUP
937	#line 113 "../../ipsec-tools/src/libipsec/policy_token.l"
938	{ return(PRIORITY); }
939	YY_BREAK
940	case 6:
941	YY_RULE_SETUP
942	#line 114 "../../ipsec-tools/src/libipsec/policy_token.l"
943	{ yylval.num32 = PRIORITY_LOW; return(PRIO_BASE); }
944	YY_BREAK
945	case 7:
946	YY_RULE_SETUP
947	#line 115 "../../ipsec-tools/src/libipsec/policy_token.l"
948	{ yylval.num32 = PRIORITY_DEFAULT; return(PRIO_BASE); }
949	YY_BREAK
950	case 8:
951	YY_RULE_SETUP
952	#line 116 "../../ipsec-tools/src/libipsec/policy_token.l"
953	{ yylval.num32 = PRIORITY_HIGH; return(PRIO_BASE); }
954	YY_BREAK
955	case 9:
956	YY_RULE_SETUP
957	#line 117 "../../ipsec-tools/src/libipsec/policy_token.l"
958	{ return(PLUS); }
959	YY_BREAK
960	case 10:
961	YY_RULE_SETUP
962	#line 118 "../../ipsec-tools/src/libipsec/policy_token.l"
963	{
964	yylval.val.len = strlen(__libipsectext);
965	yylval.val.buf = __libipsectext;
966	return(PRIO_OFFSET);
967	}
968	YY_BREAK
969	case 11:
970	YY_RULE_SETUP
971	#line 124 "../../ipsec-tools/src/libipsec/policy_token.l"
972	{ yylval.num = IPSEC_POLICY_DISCARD; return(ACTION); }
973	YY_BREAK
974	case 12:
975	YY_RULE_SETUP
976	#line 125 "../../ipsec-tools/src/libipsec/policy_token.l"
977	{ yylval.num = IPSEC_POLICY_NONE; return(ACTION); }
978	YY_BREAK
979	case 13:
980	YY_RULE_SETUP
981	#line 126 "../../ipsec-tools/src/libipsec/policy_token.l"
982	{ yylval.num = IPSEC_POLICY_IPSEC; return(ACTION); }
983	YY_BREAK
984	case 14:
985	YY_RULE_SETUP
986	#line 127 "../../ipsec-tools/src/libipsec/policy_token.l"
987	{ yylval.num = IPSEC_POLICY_BYPASS; return(ACTION); }
988	YY_BREAK
989	case 15:
990	YY_RULE_SETUP
991	#line 128 "../../ipsec-tools/src/libipsec/policy_token.l"
992	{ yylval.num = IPSEC_POLICY_ENTRUST; return(ACTION); }
993	YY_BREAK
994	case 16:
995	YY_RULE_SETUP
996	#line 130 "../../ipsec-tools/src/libipsec/policy_token.l"
997	{ yylval.num = IPPROTO_ESP; return(PROTOCOL); }
998	YY_BREAK
999	case 17:
1000	YY_RULE_SETUP
1001	#line 131 "../../ipsec-tools/src/libipsec/policy_token.l"
1002	{ yylval.num = IPPROTO_AH; return(PROTOCOL); }
1003	YY_BREAK
1004	case 18:
1005	YY_RULE_SETUP
1006	#line 132 "../../ipsec-tools/src/libipsec/policy_token.l"
1007	{ yylval.num = IPPROTO_IPCOMP; return(PROTOCOL); }
1008	YY_BREAK
1009	case 19:
1010	YY_RULE_SETUP
1011	#line 134 "../../ipsec-tools/src/libipsec/policy_token.l"
1012	{ yylval.num = IPSEC_MODE_TRANSPORT; return(MODE); }
1013	YY_BREAK
1014	case 20:
1015	YY_RULE_SETUP
1016	#line 135 "../../ipsec-tools/src/libipsec/policy_token.l"
1017	{ yylval.num = IPSEC_MODE_TUNNEL; return(MODE); }
1018	YY_BREAK
1019	case 21:
1020	YY_RULE_SETUP
1021	#line 137 "../../ipsec-tools/src/libipsec/policy_token.l"
1022	{ return(ME); }
1023	YY_BREAK
1024	case 22:
1025	YY_RULE_SETUP
1026	#line 138 "../../ipsec-tools/src/libipsec/policy_token.l"
1027	{ return(ANY); }
1028	YY_BREAK
1029	case 23:
1030	YY_RULE_SETUP
1031	#line 140 "../../ipsec-tools/src/libipsec/policy_token.l"
1032	{ yylval.num = IPSEC_LEVEL_DEFAULT; return(LEVEL); }
1033	YY_BREAK
1034	case 24:
1035	YY_RULE_SETUP
1036	#line 141 "../../ipsec-tools/src/libipsec/policy_token.l"
1037	{ yylval.num = IPSEC_LEVEL_USE; return(LEVEL); }
1038	YY_BREAK
1039	case 25:
1040	YY_RULE_SETUP
1041	#line 142 "../../ipsec-tools/src/libipsec/policy_token.l"
1042	{ yylval.num = IPSEC_LEVEL_REQUIRE; return(LEVEL); }
1043	YY_BREAK
1044	case 26:
1045	YY_RULE_SETUP
1046	#line 143 "../../ipsec-tools/src/libipsec/policy_token.l"
1047	{
1048	yylval.val.len = strlen(__libipsectext + 7);
1049	yylval.val.buf = __libipsectext + 7;
1050	return(LEVEL_SPECIFY);
1051	}
1052	YY_BREAK
1053	case 27:
1054	YY_RULE_SETUP
1055	#line 148 "../../ipsec-tools/src/libipsec/policy_token.l"
1056	{ yylval.num = IPSEC_LEVEL_UNIQUE; return(LEVEL); }
1057	YY_BREAK
1058	case 28:
1059	YY_RULE_SETUP
1060	#line 149 "../../ipsec-tools/src/libipsec/policy_token.l"
1061	{ return(SLASH); }
1062	YY_BREAK
1063	case 29:
1064	YY_RULE_SETUP
1065	#line 151 "../../ipsec-tools/src/libipsec/policy_token.l"
1066	{
1067	yylval.val.len = strlen(__libipsectext);
1068	yylval.val.buf = __libipsectext;
1069	return(IPADDRESS);
1070	}
1071	YY_BREAK
1072	case 30:
1073	YY_RULE_SETUP
1074	#line 157 "../../ipsec-tools/src/libipsec/policy_token.l"
1075	{ return(HYPHEN); }
1076	YY_BREAK
1077	case 31:
1078	YY_RULE_SETUP
1079	#line 159 "../../ipsec-tools/src/libipsec/policy_token.l"
1080	{
1081	/* Remove leading '[' and trailing ']' */
1082	yylval.val.buf = __libipsectext + 1;
1083	yylval.val.len = strlen(__libipsectext) - 2;
1084
1085	return(PORT);
1086	}
1087	YY_BREAK
1088	case 32:
1089	YY_RULE_SETUP
1090	#line 167 "../../ipsec-tools/src/libipsec/policy_token.l"
1091	{ ; }
1092	YY_BREAK
1093	case 33:
1094	/* rule 33 can match eol */
1095	YY_RULE_SETUP
1096	#line 168 "../../ipsec-tools/src/libipsec/policy_token.l"
1097	{ ; }
1098	YY_BREAK
1099	case 34:
1100	YY_RULE_SETUP
1101	#line 170 "../../ipsec-tools/src/libipsec/policy_token.l"
1102	ECHO;
1103	YY_BREAK
1104	#line 1105 "<stdout>"
1105	case YY_STATE_EOF(INITIAL):
1106	yyterminate();
1107
1108	case YY_END_OF_BUFFER:
1109	{
1110	/* Amount of text matched not including the EOB char. */
1111	int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1112
1113	/* Undo the effects of YY_DO_BEFORE_ACTION. */
1114	*yy_cp = (yy_hold_char);
1115	YY_RESTORE_YY_MORE_OFFSET
1116
1117	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1118	{
1119	/* We're scanning a new file or input source. It's
1120	* possible that this happened because the user
1121	* just pointed __libipsecin at a new source and called
1122	* __libipseclex(). If so, then we have to assure
1123	* consistency between YY_CURRENT_BUFFER and our
1124	* globals. Here is the right place to do so, because
1125	* this is the first action (other than possibly a
1126	* back-up) that will match for the new input source.
1127	*/
1128	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1129	YY_CURRENT_BUFFER_LVALUE->yy_input_file = __libipsecin;
1130	YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1131	}
1132
1133	/* Note that here we test for yy_c_buf_p "<=" to the position
1134	* of the first EOB in the buffer, since yy_c_buf_p will
1135	* already have been incremented past the NUL character
1136	* (since all states make transitions on EOB to the
1137	* end-of-buffer state). Contrast this with the test
1138	* in input().
1139	*/
1140	if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1141	{ /* This was really a NUL. */
1142	yy_state_type yy_next_state;
1143
1144	(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1145
1146	yy_current_state = yy_get_previous_state( );
1147
1148	/* Okay, we're now positioned to make the NUL
1149	* transition. We couldn't have
1150	* yy_get_previous_state() go ahead and do it
1151	* for us because it doesn't know how to deal
1152	* with the possibility of jamming (and we don't
1153	* want to build jamming into it because then it
1154	* will run more slowly).
1155	*/
1156
1157	yy_next_state = yy_try_NUL_trans( yy_current_state );
1158
1159	yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1160
1161	if ( yy_next_state )
1162	{
1163	/* Consume the NUL. */
1164	yy_cp = ++(yy_c_buf_p);
1165	yy_current_state = yy_next_state;
1166	goto yy_match;
1167	}
1168
1169	else
1170	{
1171	yy_cp = (yy_c_buf_p);
1172	goto yy_find_action;
1173	}
1174	}
1175
1176	else switch ( yy_get_next_buffer( ) )
1177	{
1178	case EOB_ACT_END_OF_FILE:
1179	{
1180	(yy_did_buffer_switch_on_eof) = 0;
1181
1182	if ( __libipsecwrap( ) )
1183	{
1184	/* Note: because we've taken care in
1185	* yy_get_next_buffer() to have set up
1186	* __libipsectext, we can now set up
1187	* yy_c_buf_p so that if some total
1188	* hoser (like flex itself) wants to
1189	* call the scanner after we return the
1190	* YY_NULL, it'll still work - another
1191	* YY_NULL will get returned.
1192	*/
1193	(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1194
1195	yy_act = YY_STATE_EOF(YY_START);
1196	goto do_action;
1197	}
1198
1199	else
1200	{
1201	if ( ! (yy_did_buffer_switch_on_eof) )
1202	YY_NEW_FILE;
1203	}
1204	break;
1205	}
1206
1207	case EOB_ACT_CONTINUE_SCAN:
1208	(yy_c_buf_p) =
1209	(yytext_ptr) + yy_amount_of_matched_text;
1210
1211	yy_current_state = yy_get_previous_state( );
1212
1213	yy_cp = (yy_c_buf_p);
1214	yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1215	goto yy_match;
1216
1217	case EOB_ACT_LAST_MATCH:
1218	(yy_c_buf_p) =
1219	&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1220
1221	yy_current_state = yy_get_previous_state( );
1222
1223	yy_cp = (yy_c_buf_p);
1224	yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1225	goto yy_find_action;
1226	}
1227	break;
1228	}
1229
1230	default:
1231	YY_FATAL_ERROR(
1232	"fatal flex scanner internal error--no action found" );
1233	} /* end of action switch */
1234	} /* end of scanning one token */
1235	} /* end of __libipseclex */
1236
1237	/* yy_get_next_buffer - try to read in a new buffer
1238	*
1239	* Returns a code representing an action:
1240	* EOB_ACT_LAST_MATCH -
1241	* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1242	* EOB_ACT_END_OF_FILE - end of file
1243	*/
1244	static int yy_get_next_buffer (void)
1245	{
1246	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1247	char *source = (yytext_ptr);
1248	int number_to_move, i;
1249	int ret_val;
1250
1251	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1252	YY_FATAL_ERROR(
1253	"fatal flex scanner internal error--end of buffer missed" );
1254
1255	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1256	{ /* Don't try to fill the buffer, so this is an EOF. */
1257	if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1258	{
1259	/* We matched a single character, the EOB, so
1260	* treat this as a final EOF.
1261	*/
1262	return EOB_ACT_END_OF_FILE;
1263	}
1264
1265	else
1266	{
1267	/* We matched some text prior to the EOB, first
1268	* process it.
1269	*/
1270	return EOB_ACT_LAST_MATCH;
1271	}
1272	}
1273
1274	/* Try to read more data. */
1275
1276	/* First move last chars to start of buffer. */
1277	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1278
1279	for ( i = 0; i < number_to_move; ++i )
1280	(dest++) = (source++);
1281
1282	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1283	/* don't do the read, it's not guaranteed to return an EOF,
1284	* just force an EOF
1285	*/
1286	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1287
1288	else
1289	{
1290	yy_size_t num_to_read =
1291	YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1292
1293	while ( num_to_read <= 0 )
1294	{ /* Not enough room in the buffer - grow it. */
1295
1296	/* just a shorter name for the current buffer */
1297	YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1298
1299	int yy_c_buf_p_offset =
1300	(int) ((yy_c_buf_p) - b->yy_ch_buf);
1301
1302	if ( b->yy_is_our_buffer )
1303	{
1304	yy_size_t new_size = b->yy_buf_size * 2;
1305
1306	if ( new_size <= 0 )
1307	b->yy_buf_size += b->yy_buf_size / 8;
1308	else
1309	b->yy_buf_size *= 2;
1310
1311	b->yy_ch_buf = (char *)
1312	/* Include room in for 2 EOB chars. */
1313	__libipsecrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1314	}
1315	else
1316	/* Can't grow it, we don't own it. */
1317	b->yy_ch_buf = 0;
1318
1319	if ( ! b->yy_ch_buf )
1320	YY_FATAL_ERROR(
1321	"fatal error - scanner input buffer overflow" );
1322
1323	(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1324
1325	num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1326	number_to_move - 1;
1327
1328	}
1329
1330	if ( num_to_read > YY_READ_BUF_SIZE )
1331	num_to_read = YY_READ_BUF_SIZE;
1332
1333	/* Read in more data. */
1334	YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1335	(yy_n_chars), num_to_read );
1336
1337	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1338	}
1339
1340	if ( (yy_n_chars) == 0 )
1341	{
1342	if ( number_to_move == YY_MORE_ADJ )
1343	{
1344	ret_val = EOB_ACT_END_OF_FILE;
1345	__libipsecrestart(__libipsecin );
1346	}
1347
1348	else
1349	{
1350	ret_val = EOB_ACT_LAST_MATCH;
1351	YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1352	YY_BUFFER_EOF_PENDING;
1353	}
1354	}
1355
1356	else
1357	ret_val = EOB_ACT_CONTINUE_SCAN;
1358
1359	if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1360	/* Extend the array by 50%, plus the number we really need. */
1361	yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1362	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char ) __libipsecrealloc((void ) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1363	if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1364	YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1365	}
1366
1367	(yy_n_chars) += number_to_move;
1368	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1369	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1370
1371	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1372
1373	return ret_val;
1374	}
1375
1376	/* yy_get_previous_state - get the state just before the EOB char was reached */
1377
1378	static yy_state_type yy_get_previous_state (void)
1379	{
1380	yy_state_type yy_current_state;
1381	char *yy_cp;
1382
1383	yy_current_state = (yy_start);
1384
1385	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1386	{
1387	YY_CHAR yy_c = (yy_cp ? yy_ec[YY_SC_TO_UI(yy_cp)] : 1);
1388	if ( yy_accept[yy_current_state] )
1389	{
1390	(yy_last_accepting_state) = yy_current_state;
1391	(yy_last_accepting_cpos) = yy_cp;
1392	}
1393	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1394	{
1395	yy_current_state = (int) yy_def[yy_current_state];
1396	if ( yy_current_state >= 121 )
1397	yy_c = yy_meta[(unsigned int) yy_c];
1398	}
1399	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1400	}
1401
1402	return yy_current_state;
1403	}
1404
1405	/* yy_try_NUL_trans - try to make a transition on the NUL character
1406	*
1407	* synopsis
1408	* next_state = yy_try_NUL_trans( current_state );
1409	*/
1410	static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1411	{
1412	int yy_is_jam;
1413	char *yy_cp = (yy_c_buf_p);
1414
1415	YY_CHAR yy_c = 1;
1416	if ( yy_accept[yy_current_state] )
1417	{
1418	(yy_last_accepting_state) = yy_current_state;
1419	(yy_last_accepting_cpos) = yy_cp;
1420	}
1421	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1422	{
1423	yy_current_state = (int) yy_def[yy_current_state];
1424	if ( yy_current_state >= 121 )
1425	yy_c = yy_meta[(unsigned int) yy_c];
1426	}
1427	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1428	yy_is_jam = (yy_current_state == 120);
1429
1430	return yy_is_jam ? 0 : yy_current_state;
1431	}
1432
1433	#ifndef YY_NO_INPUT
1434	#ifdef __cplusplus
1435	static int yyinput (void)
1436	#else
1437	static int input (void)
1438	#endif
1439
1440	{
1441	int c;
1442
1443	*(yy_c_buf_p) = (yy_hold_char);
1444
1445	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1446	{
1447	/* yy_c_buf_p now points to the character we want to return.
1448	* If this occurs before the EOB characters, then it's a
1449	* valid NUL; if not, then we've hit the end of the buffer.
1450	*/
1451	if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1452	/* This was really a NUL. */
1453	*(yy_c_buf_p) = '\0';
1454
1455	else
1456	{ /* need more input */
1457	yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1458	++(yy_c_buf_p);
1459
1460	switch ( yy_get_next_buffer( ) )
1461	{
1462	case EOB_ACT_LAST_MATCH:
1463	/* This happens because yy_g_n_b()
1464	* sees that we've accumulated a
1465	* token and flags that we need to
1466	* try matching the token before
1467	* proceeding. But for input(),
1468	* there's no matching to consider.
1469	* So convert the EOB_ACT_LAST_MATCH
1470	* to EOB_ACT_END_OF_FILE.
1471	*/
1472
1473	/* Reset buffer status. */
1474	__libipsecrestart(__libipsecin );
1475
1476	/FALLTHROUGH/
1477
1478	case EOB_ACT_END_OF_FILE:
1479	{
1480	if ( __libipsecwrap( ) )
1481	return EOF;
1482
1483	if ( ! (yy_did_buffer_switch_on_eof) )
1484	YY_NEW_FILE;
1485	#ifdef __cplusplus
1486	return yyinput();
1487	#else
1488	return input();
1489	#endif
1490	}
1491
1492	case EOB_ACT_CONTINUE_SCAN:
1493	(yy_c_buf_p) = (yytext_ptr) + offset;
1494	break;
1495	}
1496	}
1497	}
1498
1499	c = (unsigned char ) (yy_c_buf_p); /* cast for 8-bit char's */
1500	(yy_c_buf_p) = '\0'; / preserve __libipsectext */
1501	(yy_hold_char) = *++(yy_c_buf_p);
1502
1503	return c;
1504	}
1505	#endif /* ifndef YY_NO_INPUT */
1506
1507	/** Immediately switch to a different input stream.
1508	* @param input_file A readable stream.
1509	*
1510	* @note This function does not reset the start condition to @c INITIAL .
1511	*/
1512	void __libipsecrestart (FILE * input_file )
1513	{
1514
1515	if ( ! YY_CURRENT_BUFFER ){
1516	__libipsecensure_buffer_stack ();
1517	YY_CURRENT_BUFFER_LVALUE =
1518	__libipsec_create_buffer(__libipsecin,YY_BUF_SIZE );
1519	}
1520
1521	__libipsec_init_buffer(YY_CURRENT_BUFFER,input_file );
1522	__libipsec_load_buffer_state( );
1523	}
1524
1525	/** Switch to a different input buffer.
1526	* @param new_buffer The new input buffer.
1527	*
1528	*/
1529	void __libipsec_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1530	{
1531
1532	/* TODO. We should be able to replace this entire function body
1533	* with
1534	* __libipsecpop_buffer_state();
1535	* __libipsecpush_buffer_state(new_buffer);
1536	*/
1537	__libipsecensure_buffer_stack ();
1538	if ( YY_CURRENT_BUFFER == new_buffer )
1539	return;
1540
1541	if ( YY_CURRENT_BUFFER )
1542	{
1543	/* Flush out information for old buffer. */
1544	*(yy_c_buf_p) = (yy_hold_char);
1545	YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1546	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1547	}
1548
1549	YY_CURRENT_BUFFER_LVALUE = new_buffer;
1550	__libipsec_load_buffer_state( );
1551
1552	/* We don't actually know whether we did this switch during
1553	* EOF (__libipsecwrap()) processing, but the only time this flag
1554	* is looked at is after __libipsecwrap() is called, so it's safe
1555	* to go ahead and always set it.
1556	*/
1557	(yy_did_buffer_switch_on_eof) = 1;
1558	}
1559
1560	static void __libipsec_load_buffer_state (void)
1561	{
1562	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1563	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1564	__libipsecin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1565	(yy_hold_char) = *(yy_c_buf_p);
1566	}
1567
1568	/** Allocate and initialize an input buffer state.
1569	* @param file A readable stream.
1570	* @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1571	*
1572	* @return the allocated buffer state.
1573	*/
1574	YY_BUFFER_STATE __libipsec_create_buffer (FILE * file, int size )
1575	{
1576	YY_BUFFER_STATE b;
1577
1578	b = (YY_BUFFER_STATE) __libipsecalloc(sizeof( struct yy_buffer_state ) );
1579	if ( ! b )
1580	YY_FATAL_ERROR( "out of dynamic memory in __libipsec_create_buffer()" );
1581
1582	b->yy_buf_size = size;
1583
1584	/* yy_ch_buf has to be 2 characters longer than the size given because
1585	* we need to put in 2 end-of-buffer characters.
1586	*/
1587	b->yy_ch_buf = (char *) __libipsecalloc(b->yy_buf_size + 2 );
1588	if ( ! b->yy_ch_buf )
1589	YY_FATAL_ERROR( "out of dynamic memory in __libipsec_create_buffer()" );
1590
1591	b->yy_is_our_buffer = 1;
1592
1593	__libipsec_init_buffer(b,file );
1594
1595	return b;
1596	}
1597
1598	/** Destroy the buffer.
1599	* @param b a buffer created with __libipsec_create_buffer()
1600	*
1601	*/
1602	void __libipsec_delete_buffer (YY_BUFFER_STATE b )
1603	{
1604
1605	if ( ! b )
1606	return;
1607
1608	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1609	YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1610
1611	if ( b->yy_is_our_buffer )
1612	__libipsecfree((void *) b->yy_ch_buf );
1613
1614	__libipsecfree((void *) b );
1615	}
1616
1617	/* Initializes or reinitializes a buffer.
1618	* This function is sometimes called more than once on the same buffer,
1619	* such as during a __libipsecrestart() or at EOF.
1620	*/
1621	static void __libipsec_init_buffer (YY_BUFFER_STATE b, FILE * file )
1622
1623	{
1624	int oerrno = errno;
1625
1626	__libipsec_flush_buffer(b );
1627
1628	b->yy_input_file = file;
1629	b->yy_fill_buffer = 1;
1630
1631	/* If b is the current buffer, then __libipsec_init_buffer was _probably_
1632	* called from __libipsecrestart() or through yy_get_next_buffer.
1633	* In that case, we don't want to reset the lineno or column.
1634	*/
1635	if (b != YY_CURRENT_BUFFER){
1636	b->yy_bs_lineno = 1;
1637	b->yy_bs_column = 0;
1638	}
1639
1640	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1641
1642	errno = oerrno;
1643	}
1644
1645	/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1646	* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1647	*
1648	*/
1649	void __libipsec_flush_buffer (YY_BUFFER_STATE b )
1650	{
1651	if ( ! b )
1652	return;
1653
1654	b->yy_n_chars = 0;
1655
1656	/* We always need two end-of-buffer characters. The first causes
1657	* a transition to the end-of-buffer state. The second causes
1658	* a jam in that state.
1659	*/
1660	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1661	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1662
1663	b->yy_buf_pos = &b->yy_ch_buf[0];
1664
1665	b->yy_at_bol = 1;
1666	b->yy_buffer_status = YY_BUFFER_NEW;
1667
1668	if ( b == YY_CURRENT_BUFFER )
1669	__libipsec_load_buffer_state( );
1670	}
1671
1672	/** Pushes the new state onto the stack. The new state becomes
1673	* the current state. This function will allocate the stack
1674	* if necessary.
1675	* @param new_buffer The new state.
1676	*
1677	*/
1678	void __libipsecpush_buffer_state (YY_BUFFER_STATE new_buffer )
1679	{
1680	if (new_buffer == NULL)
1681	return;
1682
1683	__libipsecensure_buffer_stack();
1684
1685	/* This block is copied from __libipsec_switch_to_buffer. */
1686	if ( YY_CURRENT_BUFFER )
1687	{
1688	/* Flush out information for old buffer. */
1689	*(yy_c_buf_p) = (yy_hold_char);
1690	YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1691	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1692	}
1693
1694	/* Only push if top exists. Otherwise, replace top. */
1695	if (YY_CURRENT_BUFFER)
1696	(yy_buffer_stack_top)++;
1697	YY_CURRENT_BUFFER_LVALUE = new_buffer;
1698
1699	/* copied from __libipsec_switch_to_buffer. */
1700	__libipsec_load_buffer_state( );
1701	(yy_did_buffer_switch_on_eof) = 1;
1702	}
1703
1704	/** Removes and deletes the top of the stack, if present.
1705	* The next element becomes the new top.
1706	*
1707	*/
1708	void __libipsecpop_buffer_state (void)
1709	{
1710	if (!YY_CURRENT_BUFFER)
1711	return;
1712
1713	__libipsec_delete_buffer(YY_CURRENT_BUFFER );
1714	YY_CURRENT_BUFFER_LVALUE = NULL;
1715	if ((yy_buffer_stack_top) > 0)
1716	--(yy_buffer_stack_top);
1717
1718	if (YY_CURRENT_BUFFER) {
1719	__libipsec_load_buffer_state( );
1720	(yy_did_buffer_switch_on_eof) = 1;
1721	}
1722	}
1723
1724	/* Allocates the stack if it does not exist.
1725	* Guarantees space for at least one push.
1726	*/
1727	static void __libipsecensure_buffer_stack (void)
1728	{
1729	yy_size_t num_to_alloc;
1730
1731	if (!(yy_buffer_stack)) {
1732
1733	/* First allocation is just for 2 elements, since we don't know if this
1734	* scanner will even need a stack. We use 2 instead of 1 to avoid an
1735	* immediate realloc on the next call.
1736	*/
1737	num_to_alloc = 1;
1738	(yy_buffer_stack) = (struct yy_buffer_state**)__libipsecalloc
1739	(num_to_alloc * sizeof(struct yy_buffer_state*)
1740	);
1741	if ( ! (yy_buffer_stack) )
1742	YY_FATAL_ERROR( "out of dynamic memory in __libipsecensure_buffer_stack()" );
1743
1744	memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1745
1746	(yy_buffer_stack_max) = num_to_alloc;
1747	(yy_buffer_stack_top) = 0;
1748	return;
1749	}
1750
1751	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1752
1753	/* Increase the buffer to prepare for a possible push. */
1754	int grow_size = 8 /* arbitrary grow size */;
1755
1756	num_to_alloc = (yy_buffer_stack_max) + grow_size;
1757	(yy_buffer_stack) = (struct yy_buffer_state**)__libipsecrealloc
1758	((yy_buffer_stack),
1759	num_to_alloc * sizeof(struct yy_buffer_state*)
1760	);
1761	if ( ! (yy_buffer_stack) )
1762	YY_FATAL_ERROR( "out of dynamic memory in __libipsecensure_buffer_stack()" );
1763
1764	/* zero only the new slots.*/
1765	memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1766	(yy_buffer_stack_max) = num_to_alloc;
1767	}
1768	}
1769
1770	/** Setup the input buffer state to scan directly from a user-specified character buffer.
1771	* @param base the character buffer
1772	* @param size the size in bytes of the character buffer
1773	*
1774	* @return the newly allocated buffer state object.
1775	*/
1776	YY_BUFFER_STATE __libipsec_scan_buffer (char * base, yy_size_t size )
1777	{
1778	YY_BUFFER_STATE b;
1779
1780	if ( size < 2 \|\|
1781	base[size-2] != YY_END_OF_BUFFER_CHAR \|\|
1782	base[size-1] != YY_END_OF_BUFFER_CHAR )
1783	/* They forgot to leave room for the EOB's. */
1784	return 0;
1785
1786	b = (YY_BUFFER_STATE) __libipsecalloc(sizeof( struct yy_buffer_state ) );
1787	if ( ! b )
1788	YY_FATAL_ERROR( "out of dynamic memory in __libipsec_scan_buffer()" );
1789
1790	b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1791	b->yy_buf_pos = b->yy_ch_buf = base;
1792	b->yy_is_our_buffer = 0;
1793	b->yy_input_file = 0;
1794	b->yy_n_chars = b->yy_buf_size;
1795	b->yy_is_interactive = 0;
1796	b->yy_at_bol = 1;
1797	b->yy_fill_buffer = 0;
1798	b->yy_buffer_status = YY_BUFFER_NEW;
1799
1800	__libipsec_switch_to_buffer(b );
1801
1802	return b;
1803	}
1804
1805	/** Setup the input buffer state to scan a string. The next call to __libipseclex() will
1806	* scan from a @e copy of @a str.
1807	* @param yystr a NUL-terminated string to scan
1808	*
1809	* @return the newly allocated buffer state object.
1810	* @note If you want to scan bytes that may contain NUL values, then use
1811	* __libipsec_scan_bytes() instead.
1812	*/
1813	YY_BUFFER_STATE __libipsec_scan_string (yyconst char * yystr )
1814	{
1815
1816	return __libipsec_scan_bytes(yystr,strlen(yystr) );
1817	}
1818
1819	/** Setup the input buffer state to scan the given bytes. The next call to __libipseclex() will
1820	* scan from a @e copy of @a bytes.
1821	* @param yybytes the byte buffer to scan
1822	* @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1823	*
1824	* @return the newly allocated buffer state object.
1825	*/
1826	YY_BUFFER_STATE __libipsec_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
1827	{
1828	YY_BUFFER_STATE b;
1829	char *buf;
1830	yy_size_t n;
1831	yy_size_t i;
1832
1833	/* Get memory for full buffer, including space for trailing EOB's. */
1834	n = _yybytes_len + 2;
1835	buf = (char *) __libipsecalloc(n );
1836	if ( ! buf )
1837	YY_FATAL_ERROR( "out of dynamic memory in __libipsec_scan_bytes()" );
1838
1839	for ( i = 0; i < _yybytes_len; ++i )
1840	buf[i] = yybytes[i];
1841
1842	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1843
1844	b = __libipsec_scan_buffer(buf,n );
1845	if ( ! b )
1846	YY_FATAL_ERROR( "bad buffer in __libipsec_scan_bytes()" );
1847
1848	/* It's okay to grow etc. this buffer, and we should throw it
1849	* away when we're done.
1850	*/
1851	b->yy_is_our_buffer = 1;
1852
1853	return b;
1854	}
1855
1856	#ifndef YY_EXIT_FAILURE
1857	#define YY_EXIT_FAILURE 2
1858	#endif
1859
1860	static void yy_fatal_error (yyconst char* msg )
1861	{
1862	(void) fprintf( stderr, "%s\n", msg );
1863	exit( YY_EXIT_FAILURE );
1864	}
1865
1866	/* Redefine yyless() so it works in section 3 code. */
1867
1868	#undef yyless
1869	#define yyless(n) \
1870	do \
1871	{ \
1872	/* Undo effects of setting up __libipsectext. */ \
1873	int yyless_macro_arg = (n); \
1874	YY_LESS_LINENO(yyless_macro_arg);\
1875	__libipsectext[__libipsecleng] = (yy_hold_char); \
1876	(yy_c_buf_p) = __libipsectext + yyless_macro_arg; \
1877	(yy_hold_char) = *(yy_c_buf_p); \
1878	*(yy_c_buf_p) = '\0'; \
1879	__libipsecleng = yyless_macro_arg; \
1880	} \
1881	while ( 0 )
1882
1883	/* Accessor methods (get/set functions) to struct members. */
1884
1885	/** Get the current line number.
1886	*
1887	*/
1888	int __libipsecget_lineno (void)
1889	{
1890
1891	return __libipseclineno;
1892	}
1893
1894	/** Get the input stream.
1895	*
1896	*/
1897	FILE *__libipsecget_in (void)
1898	{
1899	return __libipsecin;
1900	}
1901
1902	/** Get the output stream.
1903	*
1904	*/
1905	FILE *__libipsecget_out (void)
1906	{
1907	return __libipsecout;
1908	}
1909
1910	/** Get the length of the current token.
1911	*
1912	*/
1913	yy_size_t __libipsecget_leng (void)
1914	{
1915	return __libipsecleng;
1916	}
1917
1918	/** Get the current token.
1919	*
1920	*/
1921
1922	char *__libipsecget_text (void)
1923	{
1924	return __libipsectext;
1925	}
1926
1927	/** Set the current line number.
1928	* @param line_number
1929	*
1930	*/
1931	void __libipsecset_lineno (int line_number )
1932	{
1933
1934	__libipseclineno = line_number;
1935	}
1936
1937	/** Set the input stream. This does not discard the current
1938	* input buffer.
1939	* @param in_str A readable stream.
1940	*
1941	* @see __libipsec_switch_to_buffer
1942	*/
1943	void __libipsecset_in (FILE * in_str )
1944	{
1945	__libipsecin = in_str ;
1946	}
1947
1948	void __libipsecset_out (FILE * out_str )
1949	{
1950	__libipsecout = out_str ;
1951	}
1952
1953	int __libipsecget_debug (void)
1954	{
1955	return __libipsec_flex_debug;
1956	}
1957
1958	void __libipsecset_debug (int bdebug )
1959	{
1960	__libipsec_flex_debug = bdebug ;
1961	}
1962
1963	static int yy_init_globals (void)
1964	{
1965	/* Initialization is the same as for the non-reentrant scanner.
1966	* This function is called from __libipseclex_destroy(), so don't allocate here.
1967	*/
1968
1969	(yy_buffer_stack) = 0;
1970	(yy_buffer_stack_top) = 0;
1971	(yy_buffer_stack_max) = 0;
1972	(yy_c_buf_p) = (char *) 0;
1973	(yy_init) = 0;
1974	(yy_start) = 0;
1975
1976	/* Defined in main.c */
1977	#ifdef YY_STDINIT
1978	__libipsecin = stdin;
1979	__libipsecout = stdout;
1980	#else
1981	__libipsecin = (FILE *) 0;
1982	__libipsecout = (FILE *) 0;
1983	#endif
1984
1985	/* For future reference: Set errno on error, since we are called by
1986	* __libipseclex_init()
1987	*/
1988	return 0;
1989	}
1990
1991	/* __libipseclex_destroy is for both reentrant and non-reentrant scanners. */
1992	int __libipseclex_destroy (void)
1993	{
1994
1995	/* Pop the buffer stack, destroying each element. */
1996	while(YY_CURRENT_BUFFER){
1997	__libipsec_delete_buffer(YY_CURRENT_BUFFER );
1998	YY_CURRENT_BUFFER_LVALUE = NULL;
1999	__libipsecpop_buffer_state();
2000	}
2001
2002	/* Destroy the stack itself. */
2003	__libipsecfree((yy_buffer_stack) );
2004	(yy_buffer_stack) = NULL;
2005
2006	/* Reset the globals. This is important in a non-reentrant scanner so the next time
2007	* __libipseclex() is called, initialization will occur. */
2008	yy_init_globals( );
2009
2010	return 0;
2011	}
2012
2013	/*
2014	* Internal utility routines.
2015	*/
2016
2017	#ifndef yytext_ptr
2018	static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2019	{
2020	int i;
2021	for ( i = 0; i < n; ++i )
2022	s1[i] = s2[i];
2023	}
2024	#endif
2025
2026	#ifdef YY_NEED_STRLEN
2027	static int yy_flex_strlen (yyconst char * s )
2028	{
2029	int n;
2030	for ( n = 0; s[n]; ++n )
2031	;
2032
2033	return n;
2034	}
2035	#endif
2036
2037	void *__libipsecalloc (yy_size_t size )
2038	{
2039	return (void *) malloc( size );
2040	}
2041
2042	void __libipsecrealloc (void ptr, yy_size_t size )
2043	{
2044	/* The cast to (char *) in the following accommodates both
2045	* implementations that use char* generic pointers, and those
2046	* that use void* generic pointers. It works with the latter
2047	* because both ANSI C and C++ allow castless assignment from
2048	* any pointer type to void*, and deal with argument conversions
2049	* as though doing an assignment.
2050	*/
2051	return (void ) realloc( (char ) ptr, size );
2052	}
2053
2054	void __libipsecfree (void * ptr )
2055	{
2056	free( (char ) ptr ); / see __libipsecrealloc() for (char ) cast /
2057	}
2058
2059	#define YYTABLES_NAME "yytables"
2060
2061	#line 170 "../../ipsec-tools/src/libipsec/policy_token.l"
2062
2063
2064
2065	void __policy__strbuffer__init__ __P((char *));
2066	void __policy__strbuffer__free__ __P((void));
2067
2068	static YY_BUFFER_STATE strbuffer;
2069
2070	void
2071	__policy__strbuffer__init__(msg)
2072	char *msg;
2073	{
2074	if (YY_CURRENT_BUFFER)
2075	__libipsec_delete_buffer(YY_CURRENT_BUFFER);
2076	strbuffer = (YY_BUFFER_STATE)__libipsec_scan_string(msg);
2077	__libipsec_switch_to_buffer(strbuffer);
2078
2079	return;
2080	}
2081
2082	void
2083	__policy__strbuffer__free__()
2084	{
2085	__libipsec_delete_buffer(strbuffer);
2086
2087	return;
2088	}
2089

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: rtems-libbsd/ipsec-tools/src/libipsec/policy_token.c

Download in other formats: