wireshark/plugins/mate/mate_parser.l

/*
 * We want a reentrant scanner.
 */
%option reentrant

/*
 * We don't use input, so don't generate code for it.
 */
%option noinput

/*
 * We don't use unput, so don't generate code for it.
 */
%option nounput

/*
 * We don't read interactively from the terminal.
 */
%option never-interactive

/*
 * We want to stop processing when we get to the end of the input.
 */
%option noyywrap

/*
 * The type for the state we keep for a scanner.
 */
%option extra-type="Mate_scanner_state_t *"

/*
 * We have to override the memory allocators so that we don't get
 * "unused argument" warnings from the yyscanner argument (which
 * we don't use, as we have a global memory allocator).
 *
 * We provide, as macros, our own versions of the routines generated by Flex,
 * which just call malloc()/realloc()/free() (as the Flex versions do),
 * discarding the extra argument.
 */
%option noyyalloc
%option noyyrealloc
%option noyyfree

/*
 * Prefix scanner routines with "Mate_" rather than "yy", so this scanner
 * can coexist with other scanners.
 */
%option prefix="Mate_"

%{

	/* mate_parser.l
	* lexical analyzer for MATE configuration files
	*
	* Copyright 2004, Luis E. Garcia Ontanon <luis@ontanon.org>
	*
	* Wireshark - Network traffic analyzer
	* By Gerald Combs <gerald@wireshark.org>
	* Copyright 1998 Gerald Combs
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
	*/

#include "mate.h"
#include "mate_grammar.h"

#include <wsutil/file_util.h>

#ifdef _WIN32
/* disable Windows VC compiler warning "signed/unsigned mismatch" associated  */
/* with YY_INPUT code generated by flex versions such as 2.5.35.              */
#pragma warning (disable:4018)
#endif

	void MateParser(void*,int, gchar*, mate_config* matecfg);
#if (GLIB_MAJOR_VERSION > 2 || (GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION >= 16))
	void *MateParserAlloc(void *(*)(gsize));
#else
	void *MateParserAlloc(void *(*)(gulong));
#endif
	void MateParserFree( void*, void(*)(void*) );
	void MateParseTrace(FILE*,char*);

#define MAX_INCLUDE_DEPTH 10
typedef struct {
	mate_config* mc;

	mate_config_frame* current_frame;

	void* pParser;

	YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
	int include_stack_ptr;
} Mate_scanner_state_t;

#define MATE_PARSE(token_type) MateParser(yyextra->pParser, (token_type), g_strdup(yytext), yyextra->mc);

/*
 * Flex (v 2.5.35) uses this symbol to "exclude" unistd.h
 */
#ifdef _WIN32
#define YY_NO_UNISTD_H
#endif

static void free_config_frame(mate_config_frame *frame) {
	g_free(frame->filename);
	g_free(frame);
}

#define YY_USER_INIT BEGIN OUTSIDE;

/*
 * Sleazy hack to suppress compiler warnings in yy_fatal_error().
 */
#define YY_EXIT_FAILURE ((void)yyscanner, 2)

/*
 * Macros for the allocators, to discard the extra argument.
 */
#define Mate_alloc(size, yyscanner)		(void *)malloc(size)
#define Mate_realloc(ptr, size, yyscanner)	(void *)realloc((char *)(ptr), (size))
#define Mate_free(ptr, yyscanner)		free((char *)ptr)

%}

pdu_kw				Pdu
gop_kw				Gop
gog_kw				Gog
transform_kw		Transform
match_kw			Match
always_kw			Always
strict_kw			Strict
every_kw			Every
loose_kw			Loose
replace_kw			Replace
insert_kw			Insert
gop_tree_kw			GopTree
member_kw			Member
on_kw				On
start_kw			Start
stop_kw				Stop
extra_kw			Extra
show_tree_kw		ShowTree
show_times_kw		ShowTimes
expiration_kw		Expiration
idle_timeout_kw		IdleTimeout
lifetime_kw			Lifetime
no_tree_kw			NoTree
pdu_tree_kw			PduTree
frame_tree_kw		FrameTree
basic_tree_kw		BasicTree
true_kw				[Tt][Rr][Uu][Ee]
false_kw			[Ff][Aa][Ll][Ss][Ee]
proto_kw			Proto
payload_kw			Payload
transport_kw		Transport
criteria_kw			Criteria
accept_kw			Accept
reject_kw			Reject
extract_kw			Extract
from_kw				From
drop_unassigned_kw  DropUnassigned
discard_pdu_data_kw DiscardPduData
last_pdu_kw			LastPdu
done_kw				Done
filename_kw			Filename
debug_kw			Debug
level_kw			Level
default_kw			Default


open_parens			"("
close_parens		")"
open_brace			"{"
close_brace			"}"
comma				","
semicolon			";"
slash				"/"
pipe				"|"

integer				[0-9]+
floating			([0-9]+\.[0-9]+)
doted_ip			[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?
colonized			[0-9A-Fa-f:]*[:][0-9A-Fa-f:]*

name				[a-z][-\.a-zA-Z0-9_]*
avp_operator		[$^~=<>!]
quote				["]
not_quoted			[^"]*

include			"#include"
filename		[-A-Za-z0-9_/.]+

whitespace		[[:blank:]\r]+
newline			\n

comment			"//"[^\n]*\n

blk_cmnt_start  "/*"
cmnt_char		.
blk_cmnt_stop  "*/"

%START OUTSIDE QUOTED INCLUDING COMMENT
%%

{newline}				yyextra->current_frame->linenum++;
{whitespace}				;

<OUTSIDE>{include}			BEGIN INCLUDING;

<INCLUDING>{filename}			{
	if ( yyextra->include_stack_ptr >= MAX_INCLUDE_DEPTH )
		g_error("dtd_preparse: include files nested too deeply");

	yyextra->include_stack[yyextra->include_stack_ptr++] = YY_CURRENT_BUFFER;
	yyin = ws_fopen( yytext, "r" );

	if (!yyin) {
		Mate__delete_buffer(YY_CURRENT_BUFFER, yyscanner);

		/* coverity[negative_sink] */
		Mate__switch_to_buffer(yyextra->include_stack[--yyextra->include_stack_ptr], yyscanner);

		if (errno)
			g_string_append_printf(yyextra->mc->config_error, "Mate parser: Could not open file: '%s': %s", yytext, g_strerror(errno) );

	} else {

		yyextra->current_frame = (mate_config_frame *)g_malloc(sizeof(mate_config_frame));
		yyextra->current_frame->filename = g_strdup(yytext);
		yyextra->current_frame->linenum = 1;

		g_ptr_array_add(yyextra->mc->config_stack,yyextra->current_frame);

		Mate__switch_to_buffer(Mate__create_buffer(yyin, YY_BUF_SIZE, yyscanner), yyscanner);
	}

	BEGIN OUTSIDE;
}

<<EOF>>	{
	/* coverity[check_after_sink] */
	if ( --yyextra->include_stack_ptr < 0 ) {
		yyterminate();
	} else {
		Mate__delete_buffer(YY_CURRENT_BUFFER, yyscanner);
		Mate__switch_to_buffer(yyextra->include_stack[yyextra->include_stack_ptr], yyscanner);

		free_config_frame(yyextra->current_frame);
		yyextra->current_frame = (mate_config_frame *)g_ptr_array_remove_index(yyextra->mc->config_stack,yyextra->mc->config_stack->len-1);
	}
}

<OUTSIDE>{comment}			;

<OUTSIDE>{blk_cmnt_start}		BEGIN COMMENT;
<COMMENT>{cmnt_char}			;
<COMMENT>{blk_cmnt_stop}		BEGIN OUTSIDE;

<OUTSIDE>{pdu_kw}			MATE_PARSE(TOKEN_PDU_KW);
<OUTSIDE>{gop_kw}			MATE_PARSE(TOKEN_GOP_KW);
<OUTSIDE>{gog_kw}			MATE_PARSE(TOKEN_GOG_KW);
<OUTSIDE>{transform_kw}			MATE_PARSE(TOKEN_TRANSFORM_KW);
<OUTSIDE>{match_kw}			MATE_PARSE(TOKEN_MATCH_KW);
<OUTSIDE>{strict_kw}			MATE_PARSE(TOKEN_STRICT_KW);
<OUTSIDE>{every_kw}			MATE_PARSE(TOKEN_EVERY_KW);
<OUTSIDE>{loose_kw}			MATE_PARSE(TOKEN_LOOSE_KW);
<OUTSIDE>{replace_kw}			MATE_PARSE(TOKEN_REPLACE_KW);
<OUTSIDE>{insert_kw}			MATE_PARSE(TOKEN_INSERT_KW);
<OUTSIDE>{gop_tree_kw}			MATE_PARSE(TOKEN_GOP_TREE_KW);
<OUTSIDE>{member_kw}			MATE_PARSE(TOKEN_MEMBER_KW);
<OUTSIDE>{on_kw}			MATE_PARSE(TOKEN_ON_KW);
<OUTSIDE>{start_kw}			MATE_PARSE(TOKEN_START_KW);
<OUTSIDE>{stop_kw}			MATE_PARSE(TOKEN_STOP_KW);
<OUTSIDE>{extra_kw}			MATE_PARSE(TOKEN_EXTRA_KW);
<OUTSIDE>{show_tree_kw}			MATE_PARSE(TOKEN_SHOW_TREE_KW);
<OUTSIDE>{show_times_kw}		MATE_PARSE(TOKEN_SHOW_TIMES_KW);
<OUTSIDE>{expiration_kw}		MATE_PARSE(TOKEN_EXPIRATION_KW);
<OUTSIDE>{idle_timeout_kw}		MATE_PARSE(TOKEN_IDLE_TIMEOUT_KW);
<OUTSIDE>{lifetime_kw}			MATE_PARSE(TOKEN_LIFETIME_KW);
<OUTSIDE>{no_tree_kw}			MATE_PARSE(TOKEN_NO_TREE_KW);
<OUTSIDE>{pdu_tree_kw}			MATE_PARSE(TOKEN_PDU_TREE_KW);
<OUTSIDE>{frame_tree_kw}		MATE_PARSE(TOKEN_FRAME_TREE_KW);
<OUTSIDE>{basic_tree_kw}		MATE_PARSE(TOKEN_BASIC_TREE_KW);
<OUTSIDE>{true_kw}			MATE_PARSE(TOKEN_TRUE_KW);
<OUTSIDE>{false_kw}			MATE_PARSE(TOKEN_FALSE_KW);
<OUTSIDE>{proto_kw}			MATE_PARSE(TOKEN_PROTO_KW);
<OUTSIDE>{payload_kw}			MATE_PARSE(TOKEN_PAYLOAD_KW);
<OUTSIDE>{transport_kw}			MATE_PARSE(TOKEN_TRANSPORT_KW);
<OUTSIDE>{criteria_kw}			MATE_PARSE(TOKEN_CRITERIA_KW);
<OUTSIDE>{accept_kw}			MATE_PARSE(TOKEN_ACCEPT_KW);
<OUTSIDE>{reject_kw}			MATE_PARSE(TOKEN_REJECT_KW);
<OUTSIDE>{extract_kw}			MATE_PARSE(TOKEN_EXTRACT_KW);
<OUTSIDE>{from_kw}			MATE_PARSE(TOKEN_FROM_KW);
<OUTSIDE>{drop_unassigned_kw}		MATE_PARSE(TOKEN_DROP_UNASSIGNED_KW);
<OUTSIDE>{discard_pdu_data_kw}		MATE_PARSE(TOKEN_DISCARD_PDU_DATA_KW);
<OUTSIDE>{last_pdu_kw}			MATE_PARSE(TOKEN_LAST_PDU_KW);
<OUTSIDE>{done_kw}			MATE_PARSE(TOKEN_DONE_KW);
<OUTSIDE>{filename_kw}			MATE_PARSE(TOKEN_FILENAME_KW);
<OUTSIDE>{debug_kw}			MATE_PARSE(TOKEN_DEBUG_KW);
<OUTSIDE>{level_kw}			MATE_PARSE(TOKEN_LEVEL_KW);
<OUTSIDE>{default_kw}			MATE_PARSE(TOKEN_DEFAULT_KW);

<OUTSIDE>{open_parens}			MATE_PARSE(TOKEN_OPEN_PARENS);
<OUTSIDE>{close_parens}			MATE_PARSE(TOKEN_CLOSE_PARENS);
<OUTSIDE>{open_brace}			MATE_PARSE(TOKEN_OPEN_BRACE);
<OUTSIDE>{close_brace}			MATE_PARSE(TOKEN_CLOSE_BRACE);
<OUTSIDE>{comma}			MATE_PARSE(TOKEN_COMMA);
<OUTSIDE>{semicolon}			MATE_PARSE(TOKEN_SEMICOLON);
<OUTSIDE>{slash}			MATE_PARSE(TOKEN_SLASH);
<OUTSIDE>{pipe}				MATE_PARSE(TOKEN_PIPE);

<OUTSIDE>{integer}			MATE_PARSE(TOKEN_INTEGER);
<OUTSIDE>{floating}			MATE_PARSE(TOKEN_FLOATING);
<OUTSIDE>{doted_ip}			MATE_PARSE(TOKEN_DOTED_IP);
<OUTSIDE>{colonized}			MATE_PARSE(TOKEN_COLONIZED);
<OUTSIDE>{name}				MATE_PARSE(TOKEN_NAME);
<OUTSIDE>{avp_operator}			MATE_PARSE(TOKEN_AVP_OPERATOR);


<OUTSIDE>{quote}			BEGIN QUOTED;
<QUOTED>{not_quoted}			MATE_PARSE(TOKEN_QUOTED);
<QUOTED>{quote}				BEGIN OUTSIDE;

%%

extern gboolean mate_load_config(const gchar* filename, mate_config* mc) {
	FILE *in;
	yyscan_t scanner;
	Mate_scanner_state_t state;
	volatile gboolean status = TRUE;

	in = ws_fopen(filename,"r");

	if (!in) {
		g_string_append_printf(mc->config_error,"Mate parser: Could not open file: '%s', error: %s", filename, g_strerror(errno) );
		return FALSE;
	}

	if (Mate_lex_init(&scanner) != 0) {
		g_string_append_printf(mc->config_error, "Mate parse: Could not initialize scanner: %s", g_strerror(errno));
		fclose(in);
		return FALSE;
	}

	Mate_set_in(in, scanner);

	mc->config_stack = g_ptr_array_new();

	state.mc = mc;

	state.current_frame = (mate_config_frame *)g_malloc(sizeof(mate_config_frame));
	state.current_frame->filename = g_strdup(filename);
	state.current_frame->linenum = 1;

	g_ptr_array_add(mc->config_stack,state.current_frame);

	state.pParser = MateParserAlloc(g_malloc);

	state.include_stack_ptr = 0;

	/* Associate the state with the scanner */
	Mate_set_extra(&state, scanner);

	/* MateParserTrace(stdout,""); */

	TRY {
		Mate_lex(scanner);

		/* Inform parser that end of input has reached. */
		MateParser(state.pParser, 0, NULL, mc);

		MateParserFree(state.pParser, g_free);
	} CATCH(MateConfigError) {
		status = FALSE;
	} CATCH_ALL {
		status = FALSE;
		g_string_append_printf(mc->config_error,"An unexpected error occurred");
	}
	ENDTRY;

	Mate_lex_destroy(scanner);
	fclose(in);

	g_ptr_array_foreach(mc->config_stack, (GFunc)free_config_frame, NULL);
	g_ptr_array_free(mc->config_stack, FALSE);

	return status;
}