/*

#include <stdlib.h>

#include <stdio.h>

#include <sys/socket.h>

#include <unistd.h>

#include <netinet/in.h>

#include <netinet/in_systm.h>

#include <netinet/ip.h>

#include <arpa/inet.h>

#include <string.h>

#include <errno.h>

#include "route_struct.h"

#include "globals.h"

#include "route.h"

#include "dprint.h"

#include "cfg_pp.h"

#include "sr_module.h"

#include "modparam.h"

#include "ip_addr.h"

#include "resolve.h"

#include "socket_info.h"

#include "name_alias.h"

#include "ut.h"

#include "pt_scaling.h"

#include "dset.h"

#include "pvar.h"

#include "blacklists.h"

#include "xlog.h"

#include "db/db_insertq.h"

#include "bin_interface.h"

#include "net/trans.h"

#include "config.h"

#include "mem/rpm_mem.h"

#include "poll_types.h"

#ifdef SHM_EXTRA_STATS

#include "mem/module_info.h"

#endif

#ifdef DEBUG_DMALLOC

#include <dmalloc.h>

#endif

#undef _ALLOCA_H

#undef MIN

#undef MAX

extern int yylex();

static void yyerror(char* s);

static void yyerrorf(char* fmt, ...);

static char* tmp;

static int i_tmp, rc;

static struct socket_id* lst_tmp;

static int rt; /* Type of route block for find_export */

static str s_tmp;

static str tstr;

static struct net* net_tmp;

static pv_spec_t *spec;

static pv_elem_t *elem;

static struct bl_rule *bl_head = 0;

static struct bl_rule *bl_tail = 0;

static struct script_route_ref *rt_ref = NULL;

action_elem_t elems[MAX_ACTION_ELEMS];

static action_elem_t route_elems[MAX_ACTION_ELEMS];

action_elem_t *a_tmp;

struct port_range {

int min;

int max;

struct port_range *next;

} *pr_tmp;

static struct script_return_param sr_tmp;

static inline void warn(char* s);

static struct socket_id* mk_listen_id(char*, enum sip_protos, int);

static struct socket_id* mk_listen_id_range(char*, enum sip_protos, struct port_range *);

static struct socket_id* set_listen_id_adv(struct socket_id *, char *, int);

static struct multi_str *new_string(char *s);

static struct port_range* mk_port_range(int, int);

static int parse_ipnet(char *in, int len, struct net **ipnet);

static struct script_return_param *mk_script_return(enum script_return_type type)

{

struct script_return_param *param = pkg_malloc(sizeof *param);

if (!param)

return NULL;

*param = sr_tmp;

param->type = type;

param->next = NULL;

return param;

}

extern int line;

extern int column;

extern int startcolumn;

extern char *finame;

struct listen_param {

enum si_flags flags;

int workers;

int tos;

struct socket_id *socket;

char *tag;

char *auto_scaling_profile;

} p_tmp;

static void fill_socket_id(struct listen_param *param, struct socket_id *s);

union route_name_var {

int iname;

struct _pv_spec *sname;

struct _pv_elem *ename;

void *data;

} rn_tmp;

#ifndef SHM_EXTRA_STATS

struct multi_str{

char *s;

struct multi_str* next;

};

#else

static struct multi_str *tmp_mod;

#endif

#define get_cfg_file_name \

((finame) ? finame : cfg_file ? cfg_file : "default")

#define si_subdomain_to_alias_flag(_flags) (int) _flags & SI_ACCEPT_SUBDOMAIN_ALIAS

#define mk_action_(_res, _type, _no, _elems) \

do { \

_res = mk_action(_type, _no, _elems, line, get_cfg_file_name); \

} while(0)

#define mk_action0(_res, _type) \

do { \

_res = mk_action(_type, 0, 0, line, get_cfg_file_name); \

} while(0)

#define mk_action1(_res, _type, _p1_type, _p1) \

do { \

elems[0].type = _p1_type; \

elems[0].u.data = _p1; \

_res = mk_action(_type, 1, elems, line, get_cfg_file_name); \

} while(0)

#define mk_action2(_res, _type, _p1_type, _p2_type, _p1, _p2) \

do { \

elems[0].type = _p1_type; \

elems[0].u.data = _p1; \

elems[1].type = _p2_type; \

elems[1].u.data = _p2; \

_res = mk_action(_type, 2, elems, line, get_cfg_file_name); \

} while(0)

#define mk_action3(_res, _type, _p1_type, _p2_type, _p3_type, _p1, _p2, _p3) \

do { \

elems[0].type = _p1_type; \

elems[0].u.data = _p1; \

elems[1].type = _p2_type; \

elems[1].u.data = _p2; \

elems[2].type = _p3_type; \

elems[2].u.data = _p3; \

_res = mk_action(_type, 3, elems, line, get_cfg_file_name); \

} while(0)

extern int cfg_parse_only_routes;

#define IFOR(_instr) \

if (cfg_parse_only_routes==1) {_instr;break;}

%union {

long intval;

unsigned long uval;

char* strval;

struct expr* expr;

struct action* action;

struct net* ipnet;

struct ip_addr* ipaddr;

struct socket_id* sockid;

struct listen_param* listen_param;

struct _pv_spec *specval;

struct multi_str* multistr;

struct port_range* portrange;

struct script_return_param* return_params;

}

%token DROP

%token ASSERT

%token EXIT

%token RETURN

%token LOG_TOK

%token ERROR

%token ROUTE

%token ROUTE_FAILURE

%token ROUTE_ONREPLY

%token ROUTE_BRANCH

%token ROUTE_ERROR

%token ROUTE_LOCAL

%token ROUTE_STARTUP

%token ROUTE_TIMER

%token ROUTE_EVENT

%token IF

%token ELSE

%token SWITCH

%token CASE

%token DEFAULT

%token BREAK

%token WHILE

%token FOR

%token IN

%token READONLY

%token EXPIRE

%token NULLV

%token XDBG

%token XLOG

%token XLOG_BUF_SIZE

%token XLOG_FORCE_COLOR

%token XLOG_PRINT_LEVEL

%token XLOG_LEVEL

%token PV_PRINT_BUF_SIZE

%token DEBUG_MODE

%token ENABLE_ASSERTS

%token ABORT_ON_ASSERT

%token LOGLEVEL

%token LOGPREFIX

%token LOGSTDOUT

%token LOGSTDERROR

%token STDERROR_ENABLED

%token SYSLOG_ENABLED

%token LOG_EVENT_ENABLED

%token STDERROR_LEVEL_FILTER

%token SYSLOG_LEVEL_FILTER

%token LOG_EVENT_LEVEL_FILTER

%token STDERROR_FORMAT

%token SYSLOG_FORMAT

%token LOG_JSON_BUF_SIZE

%token LOG_MSG_BUF_SIZE

%token LOGFACILITY

%token SYSLOG_FACILITY

%token LOGNAME

%token SYSLOG_NAME

%token AVP_ALIASES

%token LISTEN

%token SOCKET

%token MEMGROUP

%token ALIAS

%token AUTO_ALIASES

%token TAG

%token DNS

%token REV_DNS

%token DNS_TRY_IPV6

%token DNS_TRY_NAPTR

%token DNS_RETR_TIME

%token DNS_RETR_NO

%token DNS_SERVERS_NO

%token DNS_USE_SEARCH

%token MAX_WHILE_LOOPS

%token UDP_WORKERS

%token CHECK_VIA

%token SHM_HASH_SPLIT_PERCENTAGE

%token SHM_SECONDARY_HASH_SIZE

%token MEM_WARMING_ENABLED

%token MEM_WARMING_PATTERN_FILE

%token MEM_WARMING_PERCENTAGE

%token RPM_MEM_FILE

%token RPM_MEM_SIZE

%token MEMLOG

%token MEMDUMP

%token SHM_MEMLOG_SIZE

%token EXECMSGTHRESHOLD

%token EXECDNSTHRESHOLD

%token TCPTHRESHOLD

%token EVENT_SHM_THRESHOLD

%token EVENT_PKG_THRESHOLD

%token QUERYBUFFERSIZE

%token QUERYFLUSHTIME

%token SIP_WARNING

%token SERVER_SIGNATURE

%token SERVER_HEADER

%token USER_AGENT_HEADER

%token LOADMODULE

%token MPATH

%token MODPARAM

%token MAXBUFFER

%token CHROOT

%token WDIR

%token MHOMED

%token POLL_METHOD

%token TCP_ACCEPT_ALIASES

%token TCP_WORKERS

%token TCP_CONNECT_TIMEOUT

%token TCP_CON_LIFETIME

%token TCP_SOCKET_BACKLOG

%token TCP_MAX_CONNECTIONS

%token TCP_NO_NEW_CONN_BFLAG

%token TCP_NO_NEW_CONN_RPLFLAG

%token TCP_KEEPALIVE

%token TCP_KEEPCOUNT

%token TCP_KEEPIDLE

%token TCP_KEEPINTERVAL

%token TCP_MAX_MSG_TIME

%token TCP_PARALLEL_READ_ON_WORKERS

%token ADVERTISED_ADDRESS

%token ADVERTISED_PORT

%token DISABLE_CORE

%token OPEN_FD_LIMIT

%token MCAST_LOOPBACK

%token MCAST_TTL

%token TOS

%token DISABLE_DNS_FAILOVER

%token DISABLE_DNS_BLACKLIST

%token DST_BLACKLIST

%token DISABLE_STATELESS_FWD

%token DB_VERSION_TABLE

%token DB_DEFAULT_URL

%token DB_MAX_ASYNC_CONNECTIONS

%token DISABLE_503_TRANSLATION

%token SYNC_TOKEN

%token ASYNC_TOKEN

%token LAUNCH_TOKEN

%token AUTO_SCALING_PROFILE

%token AUTO_SCALING_CYCLE

%token TIMER_WORKERS

%nonassoc EQUAL

%nonassoc EQUAL_T

%nonassoc GT

%nonassoc LT

%nonassoc GTE

%nonassoc LTE

%nonassoc DIFF

%nonassoc MATCH

%nonassoc NOTMATCH

%nonassoc COLONEQ

%nonassoc PLUSEQ

%nonassoc MINUSEQ

%nonassoc SLASHEQ

%nonassoc MULTEQ

%nonassoc MODULOEQ

%nonassoc BANDEQ

%nonassoc BOREQ

%nonassoc BXOREQ

%left OR AND

%left BOR BAND BXOR BLSHIFT BRSHIFT

%left PLUS MINUS SLASH MULT MODULO

%right NOT BNOT

%right RPAREN ELSE /* solves the classic if-if-else ambiguity */

%token <intval> NUMBER

%token <intval> ZERO

%token <strval> ID

%token <strval> STRING

%token <strval> SCRIPTVAR

%token <strval> IPV6ADDR

%token <strval> IPV4ADDR

%token <strval> IPNET

%token COMMA

%token SEMICOLON

%token RPAREN

%token LPAREN

%token LBRACE

%token RBRACE

%token LBRACK

%token RBRACK

%token SLASH

%token AS

%token USE_WORKERS

%token SOCK_TOS

%token USE_AUTO_SCALING_PROFILE

%token MAX

%token MIN

%token DOT

%token CR

%token COLON

%token ANY

%token ANYCAST

%token ACCEPT_SUBDOMAIN

%token FRAG

%token REUSE_PORT

%token SCRIPTVARERR

%token SCALE_UP_TO

%token SCALE_DOWN_TO

%token ON

%token CYCLES

%token CYCLES_WITHIN

%token PERCENTAGE

%type <expr> exp exp_elem exp_cond assignexp /*, condition*/

%type <action> action actions brk_action brk_actions cmd if_cmd stm brk_stm

%type <action> exp_stm assign_cmd while_cmd foreach_cmd async_func brk_if_cmd

%type <action> switch_cmd switch_stm case_stms case_stm default_stm

%type <intval> func_param

%type <ipaddr> ipv4 ipv6 ipv6addr ip

%type <ipnet> ipnet

%type <specval> script_var

%type <strval> host

%type <strval> listen_id

%type <sockid> socket_def

%type <sockid> id_lst

%type <sockid> alias_def

%type <sockid> any_alias

%type <sockid> listen_id_def

%type <sockid> phostport phostportrange

%type <intval> proto port any_proto

%type <strval> host_sep

%type <intval> equalop compop matchop strop intop

%type <intval> assignop

%type <intval> snumber

%type <strval> route_name

%type <intval> route_name_var

%type <intval> route_param

%type <intval> blst_flag blst_flags

%type <strval> folded_string

%type <multistr> multi_string

%type <portrange> portrange

%type <return_params> return_params return_param

%expect 2

cfg: statements

;

statements: statements statement {}

| statement {}

| statements error { yyerror(""); YYABORT;}

;

statement: assign_stm

| module_stm

| {rt=REQUEST_ROUTE;} route_stm

| {rt=FAILURE_ROUTE;} failure_route_stm

| {rt=ONREPLY_ROUTE;} onreply_route_stm

| {rt=BRANCH_ROUTE;} branch_route_stm

| {rt=ERROR_ROUTE;} error_route_stm

| {rt=LOCAL_ROUTE;} local_route_stm

| {rt=STARTUP_ROUTE;} startup_route_stm

| {rt=TIMER_ROUTE;} timer_route_stm

| {rt=EVENT_ROUTE;} event_route_stm

| CR /* null statement*/

;

listen_id: ip { IFOR();

tmp=ip_addr2a($1);

if(tmp==0){

LM_CRIT("cfg. parser: bad ip address.\n");

$$=0;

}else{

$$=pkg_malloc(strlen(tmp)+1);

if ($$==0){

LM_CRIT("cfg. parser: out of memory.\n");

YYABORT;

}else{

memcpy($$, tmp, strlen(tmp)+1);

}

}

}

| STRING { IFOR();

$$=pkg_malloc(strlen($1)+1);

if ($$==0){

LM_CRIT("cfg. parser: out of memory.\n");

YYABORT;

}else{

memcpy($$, $1, strlen($1)+1);

}

}

| host { IFOR();

if ($1==0) {

$$ = 0;

} else {

$$=pkg_malloc(strlen($1)+1);

if ($$==0){

LM_CRIT("cfg. parser: out of memory.\n");

YYABORT;

}else{

memcpy($$, $1, strlen($1)+1);

}

}

}

;

host_sep: DOT {$$=".";}

| MINUS {$$="-"; }

;

host: ID { $$=$1; }

| host host_sep ID { IFOR();

$$=(char*)pkg_malloc(strlen($1)+1+strlen($3)+1);

if ($$==0){

LM_CRIT("cfg. parser: memory allocation"

" failure while parsing host\n");

YYABORT;

}else{

memcpy($$, $1, strlen($1));

$$[strlen($1)]=*$2;

memcpy($$+strlen($1)+1, $3, strlen($3));

$$[strlen($1)+1+strlen($3)]=0;

}

pkg_free($1); pkg_free($3);

}

| host DOT error { $$=0; pkg_free($1);

yyerror("invalid hostname (use quotes if hostname "

"has config keywords)"); }

;

proto: ID { IFOR();

if (parse_proto((unsigned char *)$1, strlen($1), &i_tmp) < 0) {

yyerrorf("cannot handle protocol <%s>\n", $1);

YYABORT;

}

pkg_free($1);

$$ = i_tmp;

}

;

port: NUMBER { $$=$1; }

| ANY { $$=0; }

;

portrange: portrange COMMA NUMBER MINUS NUMBER { IFOR();

if ($3 > $5) {

yyerrorf("invalid port range (%d > %d)\n", (int)$3, (int)$5);

YYABORT;

}

pr_tmp = mk_port_range($3, $5);

if (!pr_tmp) {

yyerror("cannot allocate new portrange\n");

YYABORT;

}

pr_tmp->next = $1;

$$ = pr_tmp;

}

| portrange COMMA NUMBER { IFOR();

pr_tmp = mk_port_range($3, $3);

if (!pr_tmp) {

yyerror("cannot allocate new portrange\n");

YYABORT;

}

pr_tmp->next = $1;

$$ = pr_tmp;

}

| NUMBER MINUS NUMBER { IFOR();

if ($1 > $3) {

yyerrorf("invalid port range (%d > %d)\n", (int)$1, (int)$3);

YYABORT;

}

$$=mk_port_range($1, $3);

}

| NUMBER { IFOR(); $$=mk_port_range($1, $1); }

;

snumber: NUMBER { $$=$1; }

| PLUS NUMBER { $$=$2; }

| MINUS NUMBER { $$=-$2; }

;

phostport: proto COLON listen_id { IFOR();

$$=mk_listen_id($3, $1, 0); }

| proto COLON listen_id COLON port { IFOR();

$$=mk_listen_id($3, $1, $5);}

| proto COLON listen_id COLON error {

$$=0;

yyerror("port number expected");

YYABORT;

}

| NUMBER error { $$=0;

yyerror("protocol expected");

YYABORT;

}

;

;

phostportrange: proto COLON MULT { IFOR();

$$=mk_listen_id(0, $1, 0); }

| proto COLON listen_id { IFOR();

$$=mk_listen_id_range($3, $1, 0); }

| proto COLON MULT COLON portrange { IFOR();

$$=mk_listen_id_range(0, $1, $5); }

| proto COLON listen_id COLON portrange { IFOR();

$$=mk_listen_id_range($3, $1, $5); }

| proto COLON MULT COLON error { IFOR();

$$=0;

yyerror("invalid port range");

YYABORT;

}

| proto COLON listen_id COLON error { IFOR();

$$=0;

yyerror("invalid port range");

YYABORT;

}

;

any_alias: listen_id { IFOR();

$$=mk_listen_id($1, PROTO_NONE, 0); }

| ANY COLON listen_id { IFOR();

$$=mk_listen_id($3, PROTO_NONE, 0); }

| ANY COLON listen_id COLON port { IFOR();

$$=mk_listen_id($3, PROTO_NONE, $5); }

| ANY COLON listen_id COLON error {

$$=0;

yyerror(" port number expected");

}

| phostport

;

alias_def: any_alias { $$=$1; }

| any_alias ACCEPT_SUBDOMAIN {

$$=$1;

$$->flags |= SI_ACCEPT_SUBDOMAIN_ALIAS;

}

;

id_lst: alias_def { IFOR(); $$=$1 ; }

| alias_def id_lst { IFOR(); $$=$1; $$->next=$2; }

;

listen_id_def: listen_id { IFOR();

$$=mk_listen_id($1, PROTO_NONE, 0); }

| listen_id COLON portrange { IFOR();

$$=mk_listen_id_range($1, PROTO_NONE, $3); }

| listen_id COLON error {

$$=0;

yyerror(" port number expected");

}

;

socket_def_param: ANYCAST { IFOR();

p_tmp.flags |= SI_IS_ANYCAST;

}

| FRAG { IFOR();

p_tmp.flags |= SI_FRAG;

}

| REUSE_PORT { IFOR();

p_tmp.flags |= SI_REUSEPORT;

}

| ACCEPT_SUBDOMAIN { IFOR();

p_tmp.flags |= SI_ACCEPT_SUBDOMAIN_ALIAS;

}

| USE_WORKERS NUMBER { IFOR();

p_tmp.workers=$2;

}

| SOCK_TOS NUMBER { IFOR();

p_tmp.tos=$2;

}

| AS listen_id_def { IFOR();

p_tmp.socket = $2;

}

| TAG ID { IFOR();

p_tmp.tag = $2;

}

| USE_AUTO_SCALING_PROFILE ID { IFOR();

p_tmp.auto_scaling_profile=$2;

}

;

socket_def_params: socket_def_param

| socket_def_param socket_def_params

;

socket_def: phostportrange { $$=$1; }

| phostportrange { IFOR();

memset(&p_tmp, 0, sizeof(p_tmp));

} socket_def_params { IFOR();

$$=$1; fill_socket_id(&p_tmp, $$);

}

;

any_proto: ANY { $$=PROTO_NONE; }

| proto { $$=$1; }

multi_string: STRING { IFOR(); $$=new_string($1); }

| STRING multi_string { IFOR(); $$=new_string($1); $$->next=$2; }

;

blst_elem: LPAREN any_proto COMMA ipnet COMMA port COMMA STRING RPAREN {

IFOR(pkg_free($4));

s_tmp.s=$8;

s_tmp.len=strlen($8);

if (add_rule_to_list(&bl_head,&bl_tail,$4,&s_tmp,$6,$2,0)) {

yyerror("failed to add backlist element\n");YYABORT;

}

}

| NOT LPAREN any_proto COMMA ipnet COMMA port COMMA STRING RPAREN {

IFOR(pkg_free($5));

s_tmp.s=$9;

s_tmp.len=strlen($9);

if (add_rule_to_list(&bl_head,&bl_tail,$5,&s_tmp,

$7,$3,BLR_APPLY_CONTRARY)) {

yyerror("failed to add backlist element\n");YYABORT;

}

}

| LPAREN any_proto COMMA ipnet COMMA port RPAREN {

IFOR(pkg_free($4));

if (add_rule_to_list(&bl_head,&bl_tail,$4,NULL,$6,$2,0)) {

yyerror("failed to add backlist element\n");YYABORT;

}

}

| NOT LPAREN any_proto COMMA ipnet COMMA port RPAREN {

IFOR(pkg_free($5));

if (add_rule_to_list(&bl_head,&bl_tail,$5,NULL,

$7,$3,BLR_APPLY_CONTRARY)) {

yyerror("failed to add backlist element\n");YYABORT;

}

}

| LPAREN any_proto COMMA ipnet RPAREN {

IFOR(pkg_free($4));

if (add_rule_to_list(&bl_head,&bl_tail,$4,NULL,0,$2,0)) {

yyerror("failed to add backlist element\n");YYABORT;

}

}

| NOT LPAREN any_proto COMMA ipnet RPAREN {

IFOR(pkg_free($5));

if (add_rule_to_list(&bl_head,&bl_tail,$5,NULL,

0,$3,BLR_APPLY_CONTRARY)) {

yyerror("failed to add backlist element\n");YYABORT;

}

}

| LPAREN ipnet COMMA port RPAREN {

IFOR(pkg_free($2));

if (add_rule_to_list(&bl_head,&bl_tail,$2,NULL,$4,PROTO_NONE,0)) {

yyerror("failed to add backlist element\n");YYABORT;

}

}

| NOT LPAREN ipnet COMMA port RPAREN {

IFOR(pkg_free($3));

if (add_rule_to_list(&bl_head,&bl_tail,$3,NULL,

$5,PROTO_NONE,BLR_APPLY_CONTRARY)) {

yyerror("failed to add backlist element\n");YYABORT;

}

}

| LPAREN ipnet RPAREN {

IFOR(pkg_free($2));

if (add_rule_to_list(&bl_head,&bl_tail,$2,NULL,0,PROTO_NONE,0)) {

yyerror("failed to add backlist element\n"); YYABORT;

}

}

| NOT LPAREN ipnet RPAREN {

IFOR(pkg_free($3));

if (add_rule_to_list(&bl_head,&bl_tail,$3,NULL,

0,PROTO_NONE,BLR_APPLY_CONTRARY)) {

yyerror("failed to add backlist element\n");YYABORT;

}

}

| ipnet {

IFOR(pkg_free($1));

if (add_rule_to_list(&bl_head,&bl_tail,$1,NULL,0,PROTO_NONE,0)) {

yyerror("failed to add backlist element\n"); YYABORT;

}

}

| NOT ipnet {

IFOR(pkg_free($2));

if (add_rule_to_list(&bl_head,&bl_tail,$2,NULL,

0,PROTO_NONE,BLR_APPLY_CONTRARY)) {

yyerror("failed to add backlist element\n");YYABORT;

}

}

;

blst_def: COLON LBRACE blst_elem_list RBRACE

| COLON LBRACE RBRACE

|

;

blst_flag: READONLY { $$ = BL_READONLY_LIST; }

| EXPIRE { $$ = BL_DO_EXPIRE; }

| DEFAULT { $$ = BL_BY_DEFAULT; }

;

blst_flags: blst_flags COMMA blst_flag { $$ = $1 | $3; }

| blst_flag {}

;

blst_elem_list: blst_elem_list COMMA blst_elem {}

| blst_elem {}

| blst_elem_list error { yyerror("bad black list element");}

;

mpath_def_list: mpath_def_list COLON STRING {IFOR(); add_mpath($3);}

| STRING { IFOR(); add_mpath($1);}

;

auto_scale_profile_def:

ID SCALE_UP_TO NUMBER ON NUMBER MODULO FOR

NUMBER CYCLES_WITHIN NUMBER

SCALE_DOWN_TO NUMBER ON NUMBER MODULO FOR

NUMBER CYCLES { IFOR();

if (create_auto_scaling_profile($1,$3,$5,$8,$10,

$12, $14, $17,10*$17)<0)

yyerror("failed to create auto scaling profile");

}

| ID SCALE_UP_TO NUMBER ON NUMBER MODULO FOR

NUMBER CYCLES

SCALE_DOWN_TO NUMBER ON NUMBER MODULO FOR

NUMBER CYCLES { IFOR();

if (create_auto_scaling_profile($1,$3,$5,$8,$8,

$11, $13, $16, 10*$16)<0)

yyerror("failed to create auto scaling profile");

}

| ID SCALE_UP_TO NUMBER ON NUMBER MODULO FOR

NUMBER CYCLES_WITHIN NUMBER { IFOR();

if (create_auto_scaling_profile($1,$3,$5,$8,$10,

0, 0, 0, 0)<0)

yyerror("failed to create auto scaling profile");

}

| ID SCALE_UP_TO NUMBER ON NUMBER MODULO FOR

NUMBER CYCLES { IFOR();

if (create_auto_scaling_profile($1,$3,$5,$8,$8,

0, 0, 0, 0)<0)

yyerror("failed to create auto scaling profile");

}

;

assign_stm: LOGLEVEL EQUAL snumber { IFOR();

/* in debug mode, force logging to DEBUG level*/

*log_level = debug_mode?L_DBG:$3;

}

| LOGPREFIX EQUAL STRING { IFOR();

if (*$3) {

int len = strlen($3);

char *buf = pkg_malloc(len + 2);

if (!buf)

yyerror("oom");

sprintf(buf, "%s:", $3);

log_prefix = buf;

} else {

log_prefix = $3;

}

}

| LOGPREFIX EQUAL error { yyerror("string value expected"); }

| ENABLE_ASSERTS EQUAL NUMBER { IFOR(); enable_asserts=$3; }

| ENABLE_ASSERTS EQUAL error { yyerror("boolean value expected"); }

| ABORT_ON_ASSERT EQUAL NUMBER { IFOR(); abort_on_assert=$3; }

| ABORT_ON_ASSERT EQUAL error { yyerror("boolean value expected"); }

| DEBUG_MODE EQUAL NUMBER { IFOR();

debug_mode=$3;

if (debug_mode) {

*log_level = L_DBG;

stderr_enabled=1;

syslog_enabled=0;

s_tmp.s=STDERR_CONSUMER_NAME;

s_tmp.len=strlen(STDERR_CONSUMER_NAME);

set_log_consumer_mute_state(&s_tmp, 0);

s_tmp.s=SYSLOG_CONSUMER_NAME;

s_tmp.len=strlen(SYSLOG_CONSUMER_NAME);

set_log_consumer_mute_state(&s_tmp, 1);

}

}

| DEBUG_MODE EQUAL error

{ yyerror("boolean value expected for debug_mode"); }

| LOGSTDOUT EQUAL NUMBER

/* may be useful when integrating 3rd party libraries */

{ IFOR(); log_stdout=$3; }

| LOGSTDOUT EQUAL error { yyerror("boolean value expected"); }

| LOGSTDERROR EQUAL NUMBER {

IFOR();

warn("'log_stderror' is deprecated, use 'stderror_enabled' and/or"

"'syslog_enabled' instead");

if (!config_check && !debug_mode) {

if ($3) {

stderr_enabled=1;

syslog_enabled=0;

} else {

stderr_enabled=0;

syslog_enabled=1;

}

s_tmp.s=STDERR_CONSUMER_NAME;

s_tmp.len=strlen(STDERR_CONSUMER_NAME);

set_log_consumer_mute_state(&s_tmp, !$3);

s_tmp.s=SYSLOG_CONSUMER_NAME;

s_tmp.len=strlen(SYSLOG_CONSUMER_NAME);

set_log_consumer_mute_state(&s_tmp, $3);

}

}

| LOGSTDERROR EQUAL error { yyerror("boolean value expected"); }

| STDERROR_ENABLED EQUAL NUMBER {

/* in config-check or debug mode we force logging

IFOR();

if (!config_check && !debug_mode) {

stderr_enabled=$3;

s_tmp.s=STDERR_CONSUMER_NAME;

s_tmp.len=strlen(STDERR_CONSUMER_NAME);

set_log_consumer_mute_state(&s_tmp, !$3);

}

}

| STDERROR_ENABLED EQUAL error { yyerror("boolean value expected"); }

| SYSLOG_ENABLED EQUAL NUMBER {

IFOR();

/* in config-check or debug mode we force logging