/*

* cfg grammar

*

* Copyright (C) 2001-2003 FhG Fokus

* Copyright (C) 2005-2009 Voice Sistem S.R.L.

* Copyright (C) 2006 enum.at

*

* This file is part of opensips, a free SIP server.

*

* opensips 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

*

* opensips 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

*/

/*

* History:

* ---------

* 2003-01-29 src_port added (jiri)

* 2003-01-23 mhomed added (jiri)

* 2003-03-19 replaced all mallocs/frees with pkg_malloc/pkg_free (andrei)

* 2003-03-19 Added support for route type in find_export (janakj)

* 2003-03-20 Regex support in modparam (janakj)

* 2003-04-01 added dst_port, proto , af (andrei)

* 2003-04-05 s/reply_route/failure_route, onreply_route introduced (jiri)

* 2003-04-12 added force_rport, chroot and wdir (andrei)

* 2003-04-15 added tcp_children, disable_tcp (andrei)

* 2003-04-22 strip_tail added (jiri)

* 2003-07-03 tls* (disable, certificate, private_key, ca_list, verify,

* require_certificate added (andrei)

* 2003-07-06 more tls config. vars added: tls_method, tls_port_no (andrei)

* 2003-10-02 added {,set_}advertised_{address,port} (andrei)

* 2003-10-10 added <,>,<=,>=, != operators support

* added msg:len (andrei)

* 2003-10-11 if(){} doesn't require a ';' after it anymore (andrei)

* 2003-10-13 added FIFO_DIR & proto:host:port listen/alias support (andrei)

* 2003-10-24 converted to the new socket_info lists (andrei)

* 2003-10-28 added tcp_accept_aliases (andrei)

* 2003-11-20 added {tcp_connect, tcp_send, tls_*}_timeout (andrei)

* 2004-03-30 added DISABLE_CORE and OPEN_FD_LIMIT (andrei)

* 2004-04-29 added SOCK_MODE, SOCK_USER & SOCK_GROUP (andrei)

* 2004-05-03 applied multicast support patch (MCAST_LOOPBACK) from janakj

added MCAST_TTL (andrei)

* 2004-07-05 src_ip & dst_ip will detect ip addresses between quotes

* (andrei)

* 2004-10-19 added FROM_URI, TO_URI (andrei)

* 2004-11-30 added force_send_socket (andrei)

* 2005-07-08 added TCP_CON_LIFETIME, TCP_POLL_METHOD, TCP_MAX_CONNECTIONS

* (andrei)

* 2005-07-26 default onreply route added (andrei)

* 2005-11-22 added tos configurability (thanks to Andreas Granig)

* 2005-11-29 added serialize_branches and next_branches (bogdan)

* 2006-03-02 MODULE_T action points to a cmd_export_t struct instead to

* a function address - more info is accessible (bogdan)

* 2006-03-02 store the cfg line into the action struct to be able to

* give more hints if fixups fail (bogdan)

* 2006-05-22 forward(_udp,_tcp,_tls) and send(_tcp) merged in forward() and

* send() (bogdan)

* 2006-12-22 functions for script and branch flags added (bogdan)

* 2007-01-11 auto_aliases option added (bogdan)

* 2007-01-25 disable_dns_failover option added (bogdan)

* 2012-01-19 added TCP keepalive support

* 2012-12-06 added event_route (razvanc)

* 2013-05-23 added NAPTR lookup option (dsandras)

* 2013-09-25 added TLS_CA_DIR option (chris_secusmart)

* 2013-10-06 added TLS_DH_PARAM option (mehmet_secusmart)

* 2013-10-30 added TLS_EC_CURVE option (yrjoe_secusmart)

*/

%{

#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

/* hack to avoid alloca usage in the generated C file (needed for compiler

with no built in alloca, like icc*/

#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 void* cmd_tmp;

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;

action_elem_t elems[MAX_ACTION_ELEMS];

static action_elem_t route_elems[MAX_ACTION_ELEMS];

action_elem_t *a_tmp;

static inline void warn(char* s);

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

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

static struct multi_str *new_string(char *s);

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

extern int line;

extern int column;

extern int startcolumn;

extern char *finame;

struct listen_param {

enum si_flags flags;

int workers;

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 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;

}

/* terminals */

/* keywords */

%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 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

/* config vars. */

%token DEBUG_MODE

%token ENABLE_ASSERTS

%token ABORT_ON_ASSERT

%token LOGLEVEL

%token LOGPREFIX

%token LOGSTDOUT

%token LOGSTDERROR

%token LOGFACILITY

%token LOGNAME

%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 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

/* operators */

%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 */

/* values */

%token <intval> NUMBER

%token <intval> ZERO

%token <strval> ID

%token <strval> STRING

%token <strval> SCRIPTVAR

%token <strval> IPV6ADDR

%token <strval> IPV4ADDR

%token <strval> IPNET

/* other */

%token COMMA

%token SEMICOLON

%token RPAREN

%token LPAREN

%token LBRACE

%token RBRACE

%token LBRACK

%token RBRACK

%token SLASH

%token AS

%token USE_WORKERS

%token USE_AUTO_SCALING_PROFILE

%token MAX

%token MIN

%token DOT

%token CR

%token COLON

%token ANY

%token ANYCAST

%token FRAG

%token SCRIPTVARERR

%token SCALE_UP_TO

%token SCALE_DOWN_TO

%token ON

%token CYCLES

%token CYCLES_WITHIN

%token PERCENTAGE

/*non-terminals */

%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> listen_id_def

%type <sockid> phostport panyhostport

%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 <strval> folded_string

%type <multistr> multi_string

/*

* known shift/reduce conflicts (the default action, shift, is correct):

* - RETURN PLUS NUMBER

* - RETURN MINUS NUMBER

* (reason: MINUS has left associativity, but for both "return -1;" and

* "return;" to work, it would need right assoc; same idea for PLUS)

*/

%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; }

;

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;

}

;

panyhostport: proto COLON MULT { IFOR();

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

| proto COLON MULT COLON port { IFOR();

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

;

alias_def: 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

;

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 port { IFOR();

$$=mk_listen_id($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;

}

| USE_WORKERS NUMBER { IFOR();

p_tmp.workers=$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: panyhostport { $$=$1; }

| phostport { $$=$1; }

| panyhostport { IFOR();

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

} socket_def_params { IFOR();

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

}

| phostport { 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;

}

}

;

blst_elem_list: blst_elem_list COMMA blst_elem {}

| blst_elem {}

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

;

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;log_stderr=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

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

* to standard error */

{ IFOR(); if (!config_check && !debug_mode) log_stderr=$3; }

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

| LOGFACILITY EQUAL ID { IFOR();

if ( (i_tmp=str2facility($3))==-1)

yyerror("bad facility (see syslog(3) man page)");

if (!config_check)

log_facility=i_tmp;

}

| LOGFACILITY EQUAL error { yyerror("ID expected"); }

| LOGNAME EQUAL STRING { IFOR(); log_name=$3; }

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

| DNS EQUAL NUMBER { IFOR(); received_dns|= ($3)?DO_DNS:0; }

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

| REV_DNS EQUAL NUMBER { IFOR(); received_dns|= ($3)?DO_REV_DNS:0; }

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

| DNS_TRY_IPV6 EQUAL NUMBER { IFOR(); dns_try_ipv6=$3; }

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

| DNS_TRY_NAPTR EQUAL NUMBER { IFOR(); dns_try_naptr=$3; }

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

| DNS_RETR_TIME EQUAL NUMBER { IFOR(); dns_retr_time=$3; }

| DNS_RETR_TIME error { yyerror("number expected"); }

| DNS_RETR_NO EQUAL NUMBER { IFOR(); dns_retr_no=$3; }

| DNS_RETR_NO error { yyerror("number expected"); }

| DNS_SERVERS_NO EQUAL NUMBER { IFOR(); dns_servers_no=$3; }

| DNS_SERVERS_NO error { yyerror("number expected"); }

| DNS_USE_SEARCH EQUAL NUMBER { IFOR(); dns_search_list=$3; }

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

| MAX_WHILE_LOOPS EQUAL NUMBER { IFOR(); max_while_loops=$3; }

| MAX_WHILE_LOOPS EQUAL error { yyerror("number expected"); }

| MAXBUFFER EQUAL NUMBER { IFOR(); maxbuffer=$3; }

| MAXBUFFER EQUAL error { yyerror("number expected"); }

| UDP_WORKERS EQUAL NUMBER { IFOR(); udp_workers_no=$3; }

| UDP_WORKERS EQUAL NUMBER USE_AUTO_SCALING_PROFILE ID { IFOR();

udp_workers_no=$3;

udp_auto_scaling_profile=$5;

}

| UDP_WORKERS EQUAL error { yyerror("number expected"); }

| TIMER_WORKERS EQUAL NUMBER { IFOR();

timer_workers_no=$3;

}

| TIMER_WORKERS EQUAL NUMBER USE_AUTO_SCALING_PROFILE ID { IFOR();

timer_workers_no=$3;

timer_auto_scaling_profile=$5;

}

| CHECK_VIA EQUAL NUMBER { check_via=$3; }

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

| SHM_HASH_SPLIT_PERCENTAGE EQUAL NUMBER { IFOR();

#ifdef HP_MALLOC

shm_hash_split_percentage=$3;

#else

LM_ERR("Cannot set parameter; Please recompile with support "

"for HP_MALLOC\n");

#endif

}

| SHM_HASH_SPLIT_PERCENTAGE EQUAL error {

#ifdef HP_MALLOC

yyerror("number expected");

#else

LM_ERR("Cannot set parameter; Please recompile with support "

"for HP_MALLOC\n");

#endif

}

| SHM_SECONDARY_HASH_SIZE EQUAL NUMBER { IFOR();

#ifdef HP_MALLOC

shm_secondary_hash_size=$3;

#else

LM_ERR("Cannot set parameter; Please recompile with support"

" for HP_MALLOC\n");

#endif

}

| SHM_SECONDARY_HASH_SIZE EQUAL error {

#ifdef HP_MALLOC

yyerror("number expected");

#else

LM_ERR("Cannot set parameter; Please recompile with support "

"for HP_MALLOC\n");

#endif

}

| MEM_WARMING_ENABLED EQUAL NUMBER { IFOR();

#ifdef HP_MALLOC

mem_warming_enabled = $3;

#else

LM_ERR("Cannot set parameter; Please recompile with support"

" for HP_MALLOC\n");

#endif

}

| MEM_WARMING_ENABLED EQUAL error {

#ifdef HP_MALLOC

yyerror("number expected");

#else

LM_ERR("Cannot set parameter; Please recompile with support "

"for HP_MALLOC\n");

#endif

}

| MEM_WARMING_PATTERN_FILE EQUAL STRING { IFOR();

#ifdef HP_MALLOC

mem_warming_pattern_file = $3;

#else

LM_ERR("Cannot set parameter; Please recompile with "

"support for HP_MALLOC\n");

#endif

}

| MEM_WARMING_PATTERN_FILE EQUAL error {

#ifdef HP_MALLOC

yyerror("string expected");

#else

LM_ERR("Cannot set parameter; Please recompile with support "

"for HP_MALLOC\n");

#endif

}

| MEM_WARMING_PERCENTAGE EQUAL NUMBER { IFOR();

#ifdef HP_MALLOC

mem_warming_percentage = $3;

#else

LM_ERR("Cannot set parameter; Please recompile with "

"support for HP_MALLOC\n");

#endif

}

| MEM_WARMING_PERCENTAGE EQUAL error {

#ifdef HP_MALLOC

yyerror("number expected");

#else

LM_ERR("Cannot set parameter; Please recompile with support "

"for HP_MALLOC\n");

#endif

}

| RPM_MEM_FILE EQUAL STRING { IFOR();

rpm_mem_file = $3;

}

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

| RPM_MEM_SIZE EQUAL NUMBER { IFOR();

rpm_mem_size = $3 * 1024 * 1024;

}

| RPM_MEM_SIZE EQUAL error { yyerror("int value expected"); }

| MEMLOG EQUAL snumber { IFOR(); memlog=$3; memdump=$3; }

| MEMLOG EQUAL error { yyerror("int value expected"); }

| MEMDUMP EQUAL snumber { IFOR(); memdump=$3; }

| MEMDUMP EQUAL error { yyerror("int value expected"); }

| EXECMSGTHRESHOLD EQUAL NUMBER { IFOR();execmsgthreshold=$3; }

| EXECMSGTHRESHOLD EQUAL error { yyerror("int value expected"); }

| EXECDNSTHRESHOLD EQUAL NUMBER { IFOR(); execdnsthreshold=$3; }

| EXECDNSTHRESHOLD EQUAL error { yyerror("int value expected"); }

| TCPTHRESHOLD EQUAL NUMBER { IFOR(); tcpthreshold=$3; }

| TCPTHRESHOLD EQUAL error { yyerror("int value expected"); }

| EVENT_SHM_THRESHOLD EQUAL NUMBER { IFOR();

#ifdef STATISTICS

if ($3 < 0 || $3 > 100)

yyerror("SHM threshold has to be a percentage between"

" 0 and 100");

event_shm_threshold=$3;

#else

yyerror("statistics support not compiled in");

#endif /* STATISTICS */

}

| EVENT_SHM_THRESHOLD EQUAL error { yyerror("int value expected"); }

| EVENT_PKG_THRESHOLD EQUAL NUMBER { IFOR();

#ifdef PKG_MALLOC

#ifdef STATISTICS

if ($3 < 0 || $3 > 100)

yyerror("PKG threshold has to be a percentage between "

"0 and 100");

event_pkg_threshold=$3;

#else

yyerror("statistics support not compiled in");

#endif

#else

yyerror("pkg_malloc support not compiled in");

#endif

}

| EVENT_PKG_THRESHOLD EQUAL error { yyerror("int value expected"); }

| QUERYBUFFERSIZE EQUAL NUMBER { IFOR(); query_buffer_size=$3; }

| QUERYBUFFERSIZE EQUAL error { yyerror("int value expected"); }

| QUERYFLUSHTIME EQUAL NUMBER { IFOR(); query_flush_time=$3; }

| QUERYFLUSHTIME EQUAL error { yyerror("int value expected"); }

| SIP_WARNING EQUAL NUMBER { IFOR(); sip_warning=$3; }

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

| CHROOT EQUAL STRING { IFOR(); chroot_dir=$3; }

| CHROOT EQUAL ID { IFOR(); chroot_dir=$3; }

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

| WDIR EQUAL STRING { IFOR(); working_dir=$3; }

| WDIR EQUAL ID { IFOR(); working_dir=$3; }

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

| MHOMED EQUAL NUMBER { IFOR(); mhomed=$3; }

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

| POLL_METHOD EQUAL ID { IFOR();

io_poll_method=get_poll_type($3);

if (io_poll_method==POLL_NONE){

LM_CRIT("bad poll method name:"

" %s\n, try one of %s.\n",

$3, poll_support);

yyerror("bad poll_method "

"value");

}

}

| POLL_METHOD EQUAL STRING { IFOR();

io_poll_method=get_poll_type($3);

if (io_poll_method==POLL_NONE){

LM_CRIT("bad poll method name:"

" %s\n, try one of %s.\n",

$3, poll_support);

yyerror("bad poll_method "

"value");

}

}

| POLL_METHOD EQUAL error { yyerror("poll method name expected"); }

| TCP_ACCEPT_ALIASES EQUAL NUMBER { IFOR();

if ($3 < TCP_ALIAS_NEVER || $3 > TCP_ALIAS_ALWAYS)

yyerror("invalid 'tcp_accept_aliases' value");

tcp_accept_aliases=$3;

}

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

| TCP_WORKERS EQUAL NUMBER { IFOR();

tcp_workers_no=$3;

}

| TCP_WORKERS EQUAL NUMBER USE_AUTO_SCALING_PROFILE ID{ IFOR();

tcp_workers_no=$3;

tcp_auto_scaling_profile=$5;

}

| TCP_WORKERS EQUAL error { yyerror("number expected"); }

| TCP_CONNECT_TIMEOUT EQUAL NUMBER { IFOR();

if ($3 <= 0)

yyerror("invalid 'tcp_connect_timeout' (value too low!)");

tcp_connect_timeout=$3;

}

| TCP_CONNECT_TIMEOUT EQUAL error { yyerror("number expected"); }

| TCP_CON_LIFETIME EQUAL NUMBER { IFOR();

tcp_con_lifetime=$3;

}

| TCP_CON_LIFETIME EQUAL error { yyerror("number expected"); }

| TCP_SOCKET_BACKLOG EQUAL NUMBER { IFOR();