/*

* $Id$

*

* cfg grammar

*

* Copyright (C) 2001-2003 FhG Fokus

* Copyright (C) 2005-2006 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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)

*/

%{

#include <stdlib.h>

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/stat.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 "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 "dset.h"

#include "pvar.h"

#include "blacklists.h"

#include "config.h"

#ifdef USE_TLS

#include "tls/tls_config.h"

#include "tls/tls_domain.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

extern int yylex();

static void yyerror(char* s);

static char* tmp;

static int i_tmp;

static void* cmd_tmp;

static struct socket_id* lst_tmp;

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

static str* str_tmp;

static str s_tmp;

static str tstr;

static struct ip_addr* ip_tmp;

static pv_spec_t *spec;

static pv_elem_t *pvmodel;

static struct bl_rule *bl_head = 0;

static struct bl_rule *bl_tail = 0;

static struct stat statf;

action_elem_t elems[MAX_ACTION_ELEMS];

#if !defined(USE_TLS) || !defined(USE_TCP) || !defined(USE_MCAST)

static void warn(char* s);

#endif

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

static char *mpath=NULL;

static char mpath_buf[256];

static int mpath_len = 0;

extern int line;

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

do { \

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

} while(0)

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

do { \

elems[0].type = _p1_type; \

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

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

} 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); \

} 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); \

} while(0)

%}

%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 _pv_spec *specval;

}

/* terminals */

/* keywords */

%token FORWARD

%token SEND

%token DROP

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

%token SET_HOSTPORT

%token PREFIX

%token STRIP

%token STRIP_TAIL

%token APPEND_BRANCH

%token PV_PRINTF

%token SET_USER

%token SET_USERPASS

%token SET_PORT

%token SET_URI

%token REVERT_URI

%token SET_DSTURI

%token RESET_DSTURI

%token ISDSTURISET

%token FORCE_RPORT

%token FORCE_LOCAL_RPORT

%token FORCE_TCP_ALIAS

%token IF

%token ELSE

%token SWITCH

%token CASE

%token DEFAULT

%token SBREAK

%token WHILE

%token SET_ADV_ADDRESS

%token SET_ADV_PORT

%token FORCE_SEND_SOCKET

%token SERIALIZE_BRANCHES

%token NEXT_BRANCHES

%token USE_BLACKLIST

%token UNUSE_BLACKLIST

%token MAX_LEN

%token SETDEBUG

%token SETFLAG

%token RESETFLAG

%token ISFLAGSET

%token SETBFLAG

%token RESETBFLAG

%token ISBFLAGSET

%token SETSFLAG

%token RESETSFLAG

%token ISSFLAGSET

%token METHOD

%token URI

%token FROM_URI

%token TO_URI

%token SRCIP

%token SRCPORT

%token DSTIP

%token DSTPORT

%token PROTO

%token AF

%token MYSELF

%token MSGLEN

%token UDP

%token TCP

%token TLS

%token SCTP

%token NULLV

/* config vars. */

%token DEBUG

%token FORK

%token LOGSTDERROR

%token LOGFACILITY

%token LOGNAME

%token AVP_ALIASES

%token LISTEN

%token ALIAS

%token AUTO_ALIASES

%token DNS

%token REV_DNS

%token DNS_TRY_IPV6

%token DNS_RETR_TIME

%token DNS_RETR_NO

%token DNS_SERVERS_NO

%token DNS_USE_SEARCH

%token MAX_WHILE_LOOPS

%token PORT

%token CHILDREN

%token CHECK_VIA

%token MEMLOG

%token SIP_WARNING

%token SOCK_MODE

%token SOCK_USER

%token SOCK_GROUP

%token UNIX_SOCK

%token UNIX_SOCK_CHILDREN

%token UNIX_TX_TIMEOUT

%token SERVER_SIGNATURE

%token SERVER_HEADER

%token USER_AGENT_HEADER

%token REPLY_TO_VIA

%token LOADMODULE

%token MPATH

%token MODPARAM

%token MAXBUFFER

%token USER

%token GROUP

%token CHROOT

%token WDIR

%token MHOMED

%token DISABLE_TCP

%token TCP_ACCEPT_ALIASES

%token TCP_CHILDREN

%token TCP_CONNECT_TIMEOUT

%token TCP_SEND_TIMEOUT

%token TCP_CON_LIFETIME

%token TCP_POLL_METHOD

%token TCP_MAX_CONNECTIONS

%token TCP_OPT_CRLF_PINGPONG

%token DISABLE_TLS

%token TLSLOG

%token TLS_PORT_NO

%token TLS_METHOD

%token TLS_HANDSHAKE_TIMEOUT

%token TLS_SEND_TIMEOUT

%token TLS_SERVER_DOMAIN

%token TLS_CLIENT_DOMAIN

%token TLS_CLIENT_DOMAIN_AVP

%token SSLv23

%token SSLv2

%token SSLv3

%token TLSv1

%token TLS_VERIFY_CLIENT

%token TLS_VERIFY_SERVER

%token TLS_REQUIRE_CLIENT_CERTIFICATE

%token TLS_CERTIFICATE

%token TLS_PRIVATE_KEY

%token TLS_CA_LIST

%token TLS_CIPHERS_LIST

%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

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

/* values */

%token <intval> NUMBER

%token <strval> ID

%token <strval> STRING

%token <strval> SCRIPTVAR

%token <strval> IPV6ADDR

/* other */

%token COMMA

%token SEMICOLON

%token RPAREN

%token LPAREN

%token LBRACE

%token RBRACE

%token LBRACK

%token RBRACK

%token SLASH

%token DOT

%token CR

%token COLON

%token ANY

%token SCRIPTVARERR

/*non-terminals */

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

%type <action> action actions cmd if_cmd stm exp_stm assign_cmd while_cmd

%type <action> switch_cmd switch_stm case_stms case_stm default_stm

%type <intval> module_func_param

%type <ipaddr> ipv4 ipv6 ipv6addr ip

%type <ipnet> ipnet

%type <specval> script_var

%type <strval> host

%type <strval> listen_id

%type <sockid> id_lst

%type <sockid> phostport

%type <intval> proto port

%type <strval> host_sep

%type <intval> uri_type

%type <intval> equalop compop matchop strop intop

%type <intval> assignop

%type <intval> snumber

%%

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

| CR /* null statement*/

;

listen_id: ip { 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");

}else{

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

}

}

}

| STRING { $$=pkg_malloc(strlen($1)+1);

if ($$==0){

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

}else{

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

}

}

| host { if ($1==0) {

$$ = 0;

} else {

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

if ($$==0){

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

}else{

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

}

}

}

;

proto: UDP { $$=PROTO_UDP; }

| TCP { $$=PROTO_TCP; }

| TLS {

#ifdef USE_TLS

$$=PROTO_TLS;

#else

$$=PROTO_TCP;

warn("tls support not compiled in");

#endif

}

| SCTP {

#ifdef USE_SCTP

$$=PROTO_SCTP;

#else

yyerror("sctp support not compiled in\n");YYABORT;

#endif

}

| ANY { $$=0; }

;

port: NUMBER { $$=$1; }

| ANY { $$=0; }

;

snumber: NUMBER { $$=$1; }

| PLUS NUMBER { $$=$2; }

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

;

phostport: listen_id { $$=mk_listen_id($1, 0, 0); }

| listen_id COLON port { $$=mk_listen_id($1, 0, $3); }

| proto COLON listen_id { $$=mk_listen_id($3, $1, 0); }

| proto COLON listen_id COLON port { $$=mk_listen_id($3, $1, $5);}

| listen_id COLON error { $$=0; yyerror(" port number expected"); }

;

id_lst: phostport { $$=$1 ; }

| phostport id_lst { $$=$1; $$->next=$2; }

;

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

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 proto COMMA ipnet COMMA port COMMA STRING RPAREN {

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");}

;

assign_stm: DEBUG EQUAL NUMBER {

#ifdef CHANGEABLE_DEBUG_LEVEL

*debug=$3;

#else

debug=$3;

#endif

}

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

| FORK EQUAL NUMBER { dont_fork= ! $3; }

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

| LOGSTDERROR EQUAL NUMBER { if (!config_check) log_stderr=$3; }

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

| LOGFACILITY EQUAL ID {

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 { log_name=$3; }

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

| AVP_ALIASES EQUAL STRING {

if ($3!=0 && $3[0]!=0)

if ( add_avp_galias_str($3)!=0 )

yyerror("invalid AVP aliases");;

}

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

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

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

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

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

| DNS_TRY_IPV6 EQUAL NUMBER { dns_try_ipv6=$3; }

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

| DNS_RETR_TIME EQUAL NUMBER { dns_retr_time=$3; }

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

| DNS_RETR_NO EQUAL NUMBER { dns_retr_no=$3; }

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

| DNS_SERVERS_NO EQUAL NUMBER { dns_servers_no=$3; }

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

| DNS_USE_SEARCH EQUAL NUMBER { dns_search_list=$3; }

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

| PORT EQUAL NUMBER { port_no=$3; }

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

| MAX_WHILE_LOOPS EQUAL NUMBER { max_while_loops=$3; }

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

| MAXBUFFER EQUAL NUMBER { maxbuffer=$3; }

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

| CHILDREN EQUAL NUMBER { children_no=$3; }

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

| CHECK_VIA EQUAL NUMBER { check_via=$3; }

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

| MEMLOG EQUAL NUMBER { memlog=$3; }

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

| SIP_WARNING EQUAL NUMBER { sip_warning=$3; }

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

| USER EQUAL STRING { user=$3; }

| USER EQUAL ID { user=$3; }

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

| GROUP EQUAL STRING { group=$3; }

| GROUP EQUAL ID { group=$3; }

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

| CHROOT EQUAL STRING { chroot_dir=$3; }

| CHROOT EQUAL ID { chroot_dir=$3; }

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

| WDIR EQUAL STRING { working_dir=$3; }

| WDIR EQUAL ID { working_dir=$3; }

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

| MHOMED EQUAL NUMBER { mhomed=$3; }

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

| DISABLE_TCP EQUAL NUMBER {

#ifdef USE_TCP

tcp_disable=$3;

#else

warn("tcp support not compiled in");

#endif

}

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

| TCP_ACCEPT_ALIASES EQUAL NUMBER {

#ifdef USE_TCP

tcp_accept_aliases=$3;

#else

warn("tcp support not compiled in");

#endif

}

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

| TCP_CHILDREN EQUAL NUMBER {

#ifdef USE_TCP

tcp_children_no=$3;

#else

warn("tcp support not compiled in");

#endif

}

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

| TCP_CONNECT_TIMEOUT EQUAL NUMBER {

#ifdef USE_TCP

tcp_connect_timeout=$3;

#else

warn("tcp support not compiled in");

#endif

}

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

| TCP_SEND_TIMEOUT EQUAL NUMBER {

#ifdef USE_TCP

tcp_send_timeout=$3;

#else

warn("tcp support not compiled in");

#endif

}

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

| TCP_CON_LIFETIME EQUAL NUMBER {

#ifdef USE_TCP

tcp_con_lifetime=$3;

#else

warn("tcp support not compiled in");

#endif

}

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

| TCP_POLL_METHOD EQUAL ID {

#ifdef USE_TCP

tcp_poll_method=get_poll_type($3);

if (tcp_poll_method==POLL_NONE){

LM_CRIT("bad poll method name:"

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

$3, poll_support);

yyerror("bad tcp_poll_method "

"value");

}

#else

warn("tcp support not compiled in");

#endif

}

| TCP_POLL_METHOD EQUAL STRING {

#ifdef USE_TCP

tcp_poll_method=get_poll_type($3);

if (tcp_poll_method==POLL_NONE){

LM_CRIT("bad poll method name:"

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

$3, poll_support);

yyerror("bad tcp_poll_method "

"value");

}

#else

warn("tcp support not compiled in");

#endif

}

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

| TCP_MAX_CONNECTIONS EQUAL NUMBER {

#ifdef USE_TCP

tcp_max_connections=$3;

#else

warn("tcp support not compiled in");

#endif

}

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

| TCP_OPT_CRLF_PINGPONG EQUAL NUMBER {

#ifdef USE_TCP

tcp_crlf_pingpong=$3;

#else

warn("tcp support not compiled in");

#endif

}

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

| DISABLE_TLS EQUAL NUMBER {

#ifdef USE_TLS

tls_disable=$3;

#else

warn("tls support not compiled in");

#endif

}

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

| TLSLOG EQUAL NUMBER {

#ifdef USE_TLS

tls_log=$3;

#else

warn("tls support not compiled in");

#endif

}

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

| TLS_PORT_NO EQUAL NUMBER {

#ifdef USE_TLS

tls_port_no=$3;

#else

warn("tls support not compiled in");

#endif

}

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

| TLS_METHOD EQUAL SSLv23 {

#ifdef USE_TLS

tls_default_server_domain->method =

TLS_USE_SSLv23;

tls_default_client_domain->method =

TLS_USE_SSLv23;

#else

warn("tls support not compiled in");

#endif

}

| TLS_METHOD EQUAL SSLv2 {

#ifdef USE_TLS

tls_default_server_domain->method =

TLS_USE_SSLv2;

tls_default_client_domain->method =

TLS_USE_SSLv2;

#else

warn("tls support not compiled in");

#endif

}

| TLS_METHOD EQUAL SSLv3 {

#ifdef USE_TLS

tls_default_server_domain->method =

TLS_USE_SSLv3;

tls_default_client_domain->method =

TLS_USE_SSLv3;

#else

warn("tls support not compiled in");

#endif

}

| TLS_METHOD EQUAL TLSv1 {

#ifdef USE_TLS

tls_default_server_domain->method =

TLS_USE_TLSv1;

tls_default_client_domain->method =

TLS_USE_TLSv1;

#else

warn("tls support not compiled in");

#endif

}

| TLS_METHOD EQUAL error {

#ifdef USE_TLS

yyerror("SSLv23, SSLv2, SSLv3 or TLSv1"

" expected");

#else

warn("tls support not compiled in");

#endif

}

| TLS_VERIFY_CLIENT EQUAL NUMBER {

#ifdef USE_TLS

tls_default_server_domain->verify_cert

= $3;

#else

warn("tls support not compiled in");

#endif

}

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

| TLS_VERIFY_SERVER EQUAL NUMBER {

#ifdef USE_TLS

tls_default_client_domain->verify_cert

=$3;

#else

warn("tls support not compiled in");

#endif

}

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

| TLS_REQUIRE_CLIENT_CERTIFICATE EQUAL NUMBER {

#ifdef USE_TLS

tls_default_server_domain->require_client_cert=$3;

#else

warn( "tls support not compiled in");

#endif

}

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

| TLS_CERTIFICATE EQUAL STRING {

#ifdef USE_TLS

tls_default_server_domain->cert_file=

$3;

tls_default_client_domain->cert_file=

$3;

#else

warn("tls support not compiled in");

#endif

}

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

| TLS_PRIVATE_KEY EQUAL STRING {

#ifdef USE_TLS

tls_default_server_domain->pkey_file=

$3;

tls_default_client_domain->pkey_file=

$3;

#else

warn("tls support not compiled in");

#endif

}

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

| TLS_CA_LIST EQUAL STRING {

#ifdef USE_TLS

tls_default_server_domain->ca_file =

$3;

tls_default_client_domain->ca_file =

$3;

#else

warn("tls support not compiled in");

#endif

}

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

| TLS_CIPHERS_LIST EQUAL STRING {

#ifdef USE_TLS

tls_default_server_domain->ciphers_list

= $3;

tls_default_client_domain->ciphers_list

= $3;

#else

warn("tls support not compiled in");

#endif

}

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

| TLS_HANDSHAKE_TIMEOUT EQUAL NUMBER {

#ifdef USE_TLS

tls_handshake_timeout=$3;

#else

warn("tls support not compiled in");

#endif

}

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

| TLS_SEND_TIMEOUT EQUAL NUMBER {

#ifdef USE_TLS

tls_send_timeout=$3;

#else

warn("tls support not compiled in");

#endif

}

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

| TLS_CLIENT_DOMAIN_AVP EQUAL NUMBER {

#ifdef USE_TLS

tls_client_domain_avp=$3;

#else

warn("tls support not compiled in");

#endif

}

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

| tls_server_domain_stm

| tls_client_domain_stm

| SERVER_SIGNATURE EQUAL NUMBER { server_signature=$3; }

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

| SERVER_HEADER EQUAL STRING { server_header.s=$3;

server_header.len=strlen($3);

}

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

| USER_AGENT_HEADER EQUAL STRING { user_agent_header.s=$3;

user_agent_header.len=strlen($3);

}

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

| REPLY_TO_VIA EQUAL NUMBER { reply_to_via=$3; }

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

| LISTEN EQUAL id_lst {

for(lst_tmp=$3; lst_tmp; lst_tmp=lst_tmp->next){

if (add_listen_iface( lst_tmp->name,

lst_tmp->port,

lst_tmp->proto,

0

)!=0){

LM_CRIT("cfg. parser: failed"

" to add listen address\n");

break;

}

}

}

| LISTEN EQUAL error { yyerror("ip address or hostname "

"expected (use quotes if the hostname includes"

" config keywords)"); }

| ALIAS EQUAL id_lst {

for(lst_tmp=$3; lst_tmp; lst_tmp=lst_tmp->next)

add_alias(lst_tmp->name, strlen(lst_tmp->name),

lst_tmp->port, lst_tmp->proto);

}

| ALIAS EQUAL error { yyerror("hostname expected (use quotes"

" if the hostname includes config keywords)"); }

| AUTO_ALIASES EQUAL NUMBER { auto_aliases=$3; }

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

| ADVERTISED_ADDRESS EQUAL listen_id {

if ($3) {

default_global_address.s=$3;

default_global_address.len=strlen($3);

}

}

|ADVERTISED_ADDRESS EQUAL error {yyerror("ip address or hostname "

"expected"); }

| ADVERTISED_PORT EQUAL NUMBER {

tmp=int2str($3, &i_tmp);

if ((default_global_port.s=pkg_malloc(i_tmp))

==0){

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

default_global_port.len=0;

}else{

default_global_port.len=i_tmp;

memcpy(default_global_port.s, tmp,

default_global_port.len);

};

}

|ADVERTISED_PORT EQUAL error {yyerror("ip address or hostname "

"expected"); }

| DISABLE_CORE EQUAL NUMBER {

disable_core_dump=$3;

}

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

| OPEN_FD_LIMIT EQUAL NUMBER {

open_files_limit=$3;

}

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

| MCAST_LOOPBACK EQUAL NUMBER {

#ifdef USE_MCAST

mcast_loopback=$3;

#else

warn("no multicast support compiled in");

#endif

}

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

| MCAST_TTL EQUAL NUMBER {

#ifdef USE_MCAST

mcast_ttl=$3;

#else

warn("no multicast support compiled in");

#endif

}

| MCAST_TTL EQUAL error { yyerror("number expected as tos"); }

| TOS EQUAL NUMBER { tos = $3;

if (tos<=0)

yyerror("invalid tos value");

}

| TOS EQUAL ID { if (strcasecmp($3,"IPTOS_LOWDELAY")) {

tos=IPTOS_LOWDELAY;

} else if (strcasecmp($3,"IPTOS_THROUGHPUT")) {

tos=IPTOS_THROUGHPUT;

} else if (strcasecmp($3,"IPTOS_RELIABILITY")) {

tos=IPTOS_RELIABILITY;

#if defined(IPTOS_MINCOST)

} else if (strcasecmp($3,"IPTOS_MINCOST")) {

tos=IPTOS_MINCOST;

#endif

#if defined(IPTOS_LOWCOST)

} else if (strcasecmp($3,"IPTOS_LOWCOST")) {

tos=IPTOS_LOWCOST;

#endif

} else {

yyerror("invalid tos value - allowed: "

"IPTOS_LOWDELAY,IPTOS_THROUGHPUT,"

"IPTOS_RELIABILITY"

#if defined(IPTOS_LOWCOST)

",IPTOS_LOWCOST"

#endif

#if defined(IPTOS_MINCOST)

",IPTOS_MINCOST"

#endif

"\n");

}

}

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

| MPATH EQUAL STRING { mpath=$3; strcpy(mpath_buf, $3);

mpath_len=strlen($3);

if(mpath_buf[mpath_len-1]!='/') {

mpath_buf[mpath_len]='/';

mpath_len++;

mpath_buf[mpath_len]='\0';

}

}