config_scan.c

sock protocol ,it is useful!

			buf[n++] = (char) c; \
		if ( c == EOF && ferror( yyin ) ) \
			YY_FATAL_ERROR( "input in flex scanner failed" ); \
		result = n; \
		} \
	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
		  && ferror( yyin ) ) \
		YY_FATAL_ERROR( "input in flex scanner failed" );
#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -
 * we don't want an extra ';' after the "return" because that will cause
 * some compilers to complain about unreachable statements.
 */
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
#endif

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL int yylex YY_PROTO(( void ))
#endif

/* Code executed at the beginning of each rule, after yytext and yyleng
 * have been set up.
 */
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif

/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK break;
#endif

#define YY_RULE_SETUP \
	YY_USER_ACTION

YY_DECL
	{
	register yy_state_type yy_current_state;
	register char *yy_cp, *yy_bp;
	register int yy_act;

#line 81 "config_scan.l"



	/*
	 * we can operate in more than one mode, find out which it is and
	 * let the parser know.
	 */



	if (!parseinit) {
		parseinit = 1;

		switch (configtype) {
			case CONFIGTYPE_SERVER:
				return SERVERCONFIG;

			case CONFIGTYPE_CLIENT:
				return CLIENTCONFIG;

			default:
				SERRX(configtype);
		}
	}


	/* start-condition dependent stuff. */


#line 1396 "lex.yy.c"

	if ( yy_init )
		{
		yy_init = 0;

#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

		if ( ! yy_start )
			yy_start = 1;	/* first start state */

		if ( ! yyin )
			yyin = stdin;

		if ( ! yyout )
			yyout = stdout;

		if ( ! yy_current_buffer )
			yy_current_buffer =
				yy_create_buffer( yyin, YY_BUF_SIZE );

		yy_load_buffer_state();
		}

	while ( 1 )		/* loops until end-of-file is reached */
		{
		yy_cp = yy_c_buf_p;

		/* Support of yytext. */
		*yy_cp = yy_hold_char;

		/* yy_bp points to the position in yy_ch_buf of the start of
		 * the current run.
		 */
		yy_bp = yy_cp;

		yy_current_state = yy_start;
		yy_state_ptr = yy_state_buf;
		*yy_state_ptr++ = yy_current_state;
yy_match:
		do
			{
			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
				{
				yy_current_state = (int) yy_def[yy_current_state];
				if ( yy_current_state >= 740 )
					yy_c = yy_meta[(unsigned int) yy_c];
				}
			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
			*yy_state_ptr++ = yy_current_state;
			++yy_cp;
			}
		while ( yy_base[yy_current_state] != 1835 );

yy_find_action:
		yy_current_state = *--yy_state_ptr;
		yy_lp = yy_accept[yy_current_state];
find_rule: /* we branch to this label when backing up */
		for ( ; ; ) /* until we find what rule we matched */
			{
			if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
				{
				yy_act = yy_acclist[yy_lp];
					{
					yy_full_match = yy_cp;
					break;
					}
				}
			--yy_cp;
			yy_current_state = *--yy_state_ptr;
			yy_lp = yy_accept[yy_current_state];
			}

		YY_DO_BEFORE_ACTION;

		if ( yy_act != YY_END_OF_BUFFER )
			{
			int yyl;
			for ( yyl = 0; yyl < yyleng; ++yyl )
				if ( yytext[yyl] == '\n' )
					++yylineno;
			}

do_action:	/* This label is used only to access EOF actions. */


		switch ( yy_act )
	{ /* beginning of action switch */
case 1:
YY_RULE_SETUP
#line 110 "config_scan.l"
{
	yylval.string = yytext;
	return PROXYPROTOCOL_SOCKS_V4;
}
	YY_BREAK
case 2:
YY_RULE_SETUP
#line 115 "config_scan.l"
{
	yylval.string = yytext;
	return PROXYPROTOCOL_SOCKS_V5;
}
	YY_BREAK
case 3:
YY_RULE_SETUP
#line 120 "config_scan.l"
{
	yylval.string = yytext;
	return PROXYPROTOCOL_MSPROXY_V2;
}
	YY_BREAK
case 4:
YY_RULE_SETUP
#line 125 "config_scan.l"
{
	yylval.string = yytext;
	return COMMAND_BIND;
}
	YY_BREAK
case 5:
YY_RULE_SETUP
#line 130 "config_scan.l"
{
	yylval.string = yytext;
	return COMMAND_CONNECT;
}
	YY_BREAK
case 6:
YY_RULE_SETUP
#line 135 "config_scan.l"
{
	yylval.string = yytext;
	return COMMAND_UDPASSOCIATE;
}
	YY_BREAK
case 7:
YY_RULE_SETUP
#line 140 "config_scan.l"
{
	yylval.string = yytext;
	return COMMAND_BINDREPLY;
}
	YY_BREAK
case 8:
YY_RULE_SETUP
#line 145 "config_scan.l"
{
	yylval.string = yytext;
	return COMMAND_UDPREPLY;
}
	YY_BREAK
case 9:
YY_RULE_SETUP
#line 151 "config_scan.l"
{
	yylval.string = yytext;
	return DIRECT;
}
	YY_BREAK
case 10:
YY_RULE_SETUP
#line 157 "config_scan.l"
{
	BEGIN(start_service);

	yylval.string = yytext;
	return PORT;
}
	YY_BREAK
/* compare */
case 11:
YY_RULE_SETUP
#line 165 "config_scan.l"
{
	yylval.string = yytext;
	return OPERATOR;
}
	YY_BREAK
case 12:
YY_RULE_SETUP
#line 171 "config_scan.l"
{
	yylval.string = yytext;
	return LOG_CONNECT;
}
	YY_BREAK
case 13:
YY_RULE_SETUP
#line 176 "config_scan.l"
{
	yylval.string = yytext;
	return LOG_DATA;
}
	YY_BREAK
case 14:
YY_RULE_SETUP
#line 181 "config_scan.l"
{
	yylval.string = yytext;
	return LOG_DISCONNECT;
}
	YY_BREAK
case 15:
YY_RULE_SETUP
#line 186 "config_scan.l"
{
	yylval.string = yytext;
	return LOG_ERROR;
}
	YY_BREAK
case 16:
YY_RULE_SETUP
#line 191 "config_scan.l"
{
	yylval.string = yytext;
	return LOG_IOOPERATION;
}
	YY_BREAK
case 17:
YY_RULE_SETUP
#line 196 "config_scan.l"
{
	BEGIN(INITIAL);

	yylval.string = yytext;
	return SERVICENAME;
}
	YY_BREAK
case 18:
YY_RULE_SETUP
#line 203 "config_scan.l"
{
	BEGIN(INIT