4 * scanner for cfg files
6 * Copyright (C) 2001-2003 FhG Fokus
8 * This file is part of ser, a free SIP server.
10 * ser is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version
15 * For a license to use the ser software under conditions
16 * other than those described here, or to purchase support for this
17 * software, please contact iptel.org by e-mail at the following addresses:
20 * ser is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31 * 2003-01-29 src_port added (jiri)
32 * 2003-01-23 mhomed added (jiri)
33 * 2003-03-19 replaced all the mallocs/frees w/ pkg_malloc/pkg_free (andrei)
34 * 2003-04-01 added dst_port, proto (tcp, udp, tls), af(inet, inet6) (andrei)
35 * 2003-04-05 s/reply_route/failure_route, onreply_route introduced (jiri)
36 * 2003-04-12 added force_rport, chdir and wdir (andrei)
37 * 2003-04-22 strip_tail added (jiri)
38 * 2003-07-03 tls* (disable, certificate, private_key, ca_list, verify,
39 * require_certificate added (andrei)
40 * 2003-07-06 more tls config. vars added: tls_method, tls_port_no (andrei)
41 * 2003-10-02 added {,set_}advertised_{address,port} (andrei)
42 * 2003-10-07 added hex and octal numbers support (andrei)
43 * 2003-10-10 replaced len_gt w/ msg:len (andrei)
44 * 2003-10-13 added fifo_dir (andrei)
45 * 2003-10-28 added tcp_accept_aliases (andrei)
46 * 2003-11-29 added {tcp_send, tcp_connect, tls_*}_timeout (andrei)
47 * 2004-03-30 added DISABLE_CORE and OPEN_FD_LIMIT (andrei)
48 * 2004-04-28 added sock_mode (replaces fifo_mode), sock_user &
50 * 2004-05-03 applied multicast support patch from janakj
51 * added MCAST_TTL (andrei)
52 * 2004-10-08 more escapes: \", \xHH, \nnn and minor optimizations (andrei)
53 * 2004-10-19 added FROM_URI and TO_URI (andrei)
54 * 2004-11-30 added force_send_socket
55 * 2005-07-08 added tcp_connection_lifetime, tcp_poll_method,
56 * tcp_max_connections (andrei)
57 * 2005-07-11 added dns_retr_{time,no}, dns_servers_no, dns_use_search_list,
58 * dns_try_ipv6 (andrei)
59 * 2005-12-11 added onsend_route, snd_{ip,port,proto,af},
60 * to_{ip,port} (andrei)
61 * 2005-12-12 separated drop, exit, break, return, added RETCODE (andrei)
62 * 2005-12-19 select framework (mma)
63 * 2006-09-11 added dns cache (use, flags, ttls, mem ,gc) & dst blacklist
65 * 2006-10-13 added STUN_ALLOW_STUN, STUN_ALLOW_FP, STUN_REFRESH_INTERVAL
67 * 2007-06-07 added SHM_FORCE_ALLOC, MLOCK_PAGES, REAL_TIME, RT_PRIO,
68 * RT_POLICY, RT_TIMER1_PRIO, RT_TIMER1_POLICY, RT_TIMER2_PRIO,
69 * RT_TIMER2_POLICY (andrei)
70 * 2007-06-16 added DNS_SRV_LB, DNS_TRY_NAPTR (andrei)
71 * 2007-06-18 added DNS_{UDP,TCP,TLS}_PREF (andrei)
72 * 2007-09-10 introduced phone2tel option which allows NOT to consider
73 * user=phone URIs as TEL URIs (jiri)
74 * 2007-10-10 added DNS_SEARCH_FMATCH (mma)
75 * 2007-11-28 added TCP_OPT_{FD_CACHE, DEFER_ACCEPT, DELAYED_ACK, SYNCNT,
76 * LINGER2, KEEPALIVE, KEEPIDLE, KEEPINTVL, KEEPCNT} (andrei)
77 * 2008-01-24 added CFG_DESCRIPTION used by cfg_var (Miklos)
78 * 2008-11-28 added support for kamailio pvars and avp/pvar guessing (andrei)
79 * 2008-12-11 added support for "string1" "string2" (andrei)
80 * 2009-03-10 added SET_USERPHONE action (Miklos)
81 * 2009-04-24 add strlen, strempty and defined operators (andrei)
82 * 2009-03-07 RETCODE, it's now a core pvar (andrei)
83 * 2010-01-10 added SHM_MEM_SZ (andrei)
84 * 2010-02-17 added DST_BLST_{UDP,TCP,TLS,SCTP}_IMASK (andrei)
99 #include "sr_compat.h"
105 #define COMMENT_LN_S 2
107 #define ATTR_S 4 /* avp/attr */
109 #define AVP_PVAR_S 6 /* avp or pvar */
110 #define PVAR_P_S 7 /* pvar: $(...) or $foo(...)*/
111 #define PVARID_S 8 /* $foo.bar...*/
112 #define STR_BETWEEN_S 9
113 #define LINECOMMENT_S 10
115 #define DEFINE_EOL_S 12
117 #define IFDEF_EOL_S 14
118 #define IFDEF_SKIP_S 15
119 #define DEFINE_DATA_S 16
121 #define STR_BUF_ALLOC_UNIT 128
129 static int comment_nest=0;
131 static int state=0, old_state=0, old_initial=0;
132 static struct str_buf s_buf;
138 static int ign_lines=0;
139 static int ign_columns=0;
140 char* yy_number_str=0; /* str correspondent for the current NUMBER token */
144 static char* addchar(struct str_buf *, char);
145 static char* addstr(struct str_buf *, char*, int);
147 static void count_more();
148 static void count_ignore();
150 #define MAX_INCLUDE_DEPTH 10
151 static struct sr_yy_state {
152 YY_BUFFER_STATE state;
158 } include_stack[MAX_INCLUDE_DEPTH];
159 static int include_stack_ptr = 0;
161 static int sr_push_yy_state(char *fin, int mode);
162 static int sr_pop_yy_state();
164 static struct sr_yy_fname {
166 struct sr_yy_fname *next;
167 } *sr_yy_fname_list = 0;
169 static str *pp_define_get(int len, const char * text);
170 static int pp_ifdef_type(int pos);
171 static void pp_ifdef_var(int len, const char * text);
172 static void pp_ifdef();
173 static void pp_else();
174 static void pp_endif();
178 /* start conditions */
179 %x STRING1 STRING2 STR_BETWEEN COMMENT COMMENT_LN ATTR SELECT AVP_PVAR PVAR_P
180 %x PVARID INCLF IMPTF
181 %x LINECOMMENT DEFINE_ID DEFINE_EOL DEFINE_DATA IFDEF_ID IFDEF_EOL IFDEF_SKIP
183 /* config script types : #!SER or #!KAMAILIO or #!MAX_COMPAT */
185 KAMAILIO_CFG KAMAILIO|OPENSER
186 MAXCOMPAT_CFG MAXCOMPAT|ALL
188 /* action keywords */
190 FORWARD_TCP forward_tcp
191 FORWARD_UDP forward_udp
192 FORWARD_TLS forward_tls
193 FORWARD_SCTP forward_sctp
201 ROUTE_REQUEST request_route
202 ROUTE_FAILURE failure_route
203 ROUTE_REPLY reply_route
204 ROUTE_ONREPLY onreply_route
205 ROUTE_BRANCH branch_route
206 ROUTE_SEND onsend_route
207 ROUTE_EVENT event_route
209 FORCE_RPORT "force_rport"|"add_rport"
210 ADD_LOCAL_RPORT "add_local_rport"
211 FORCE_TCP_ALIAS "force_tcp_alias"|"add_tcp_alias"
213 UDP_MTU_TRY_PROTO "udp_mtu_try_proto"
215 UDP4_RAW_MTU "udp4_raw_mtu"
216 UDP4_RAW_TTL "udp4_raw_ttl"
220 FLAGS_DECL "flags"|"bool"
221 SETAVPFLAG setavpflag
222 RESETAVPFLAG resetavpflag
223 ISAVPFLAGSET isavpflagset
224 AVPFLAGS_DECL avpflags
225 SET_HOST "rewritehost"|"sethost"|"seth"
226 SET_HOSTPORT "rewritehostport"|"sethostport"|"sethp"
227 SET_HOSTPORTTRANS "rewritehostporttrans"|"sethostporttrans"|"sethpt"
228 SET_USER "rewriteuser"|"setuser"|"setu"
229 SET_USERPASS "rewriteuserpass"|"setuserpass"|"setup"
230 SET_PORT "rewriteport"|"setport"|"setp"
231 SET_URI "rewriteuri"|"seturi"
232 REVERT_URI "revert_uri"
235 STRIP_TAIL "strip_tail"
236 SET_USERPHONE "userphone"
237 REMOVE_BRANCH "remove_branch"
238 CLEAR_BRANCHES "clear_branches"
241 SET_ADV_ADDRESS "set_advertised_address"
242 SET_ADV_PORT "set_advertised_port"
243 FORCE_SEND_SOCKET "force_send_socket"
244 SET_FWD_NO_CONNECT "set_forward_no_connect"
245 SET_RPL_NO_CONNECT "set_reply_no_connect"
246 SET_FWD_CLOSE "set_forward_close"
247 SET_RPL_CLOSE "set_reply_close"
253 CFG_SELECT "cfg_select"
254 CFG_RESET "cfg_reset"
263 /* condition keywords */
265 /* hack -- the second element in first line is referable
266 as either uri or status; it only would makes sense to
267 call it "uri" from route{} and status from onreply_route{}
278 SNDPROTO snd_proto|to_proto
286 RETCODE \$\?|\$retcode|\$rc
319 /* Attribute specification */
334 AVP_PREF (([ft][rud]?)|g)\.
339 FORK_DELAY fork_delay
340 LOGSTDERROR log_stderror
341 LOGFACILITY log_facility
345 ADVERTISE advertise|ADVERTISE
347 SR_AUTO_ALIASES auto_aliases
350 DNS_TRY_IPV6 dns_try_ipv6
351 DNS_TRY_NAPTR dns_try_naptr
352 DNS_SRV_LB dns_srv_lb|dns_srv_loadbalancing
353 DNS_UDP_PREF dns_udp_pref|dns_udp_preference
354 DNS_TCP_PREF dns_tcp_pref|dns_tcp_preference
355 DNS_TLS_PREF dns_tls_pref|dns_tls_preference
356 DNS_SCTP_PREF dns_sctp_pref|dns_sctp_preference
357 DNS_RETR_TIME dns_retr_time
358 DNS_RETR_NO dns_retr_no
359 DNS_SERVERS_NO dns_servers_no
360 DNS_USE_SEARCH dns_use_search_list
361 DNS_SEARCH_FMATCH dns_search_full_match
363 DNS_CACHE_INIT dns_cache_init
364 DNS_USE_CACHE use_dns_cache
365 DNS_USE_FAILOVER use_dns_failover
366 DNS_CACHE_FLAGS dns_cache_flags
367 DNS_CACHE_NEG_TTL dns_cache_negative_ttl
368 DNS_CACHE_MIN_TTL dns_cache_min_ttl
369 DNS_CACHE_MAX_TTL dns_cache_max_ttl
370 DNS_CACHE_MEM dns_cache_mem
371 DNS_CACHE_GC_INT dns_cache_gc_interval
372 DNS_CACHE_DEL_NONEXP dns_cache_del_nonexp|dns_cache_delete_nonexpired
374 AUTO_BIND_IPV6 auto_bind_ipv6
376 DST_BLST_INIT dst_blacklist_init
377 USE_DST_BLST use_dst_blacklist
378 DST_BLST_MEM dst_blacklist_mem
379 DST_BLST_TTL dst_blacklist_expire|dst_blacklist_ttl
380 DST_BLST_GC_INT dst_blacklist_gc_interval
381 DST_BLST_UDP_IMASK dst_blacklist_udp_imask
382 DST_BLST_TCP_IMASK dst_blacklist_tcp_imask
383 DST_BLST_TLS_IMASK dst_blacklist_tls_imask
384 DST_BLST_SCTP_IMASK dst_blacklist_sctp_imask
390 SQL_BUFFER_SIZE sql_buffer_size
392 SOCKET_WORKERS socket_workers
395 SYN_BRANCH syn_branch
396 MEMLOG "memlog"|"mem_log"
397 MEMDBG "memdbg"|"mem_dbg"
399 MEMSAFETY "mem_safety"
401 CORELOG "corelog"|"core_log"
402 SIP_WARNING sip_warning
403 SERVER_SIGNATURE server_signature
404 SERVER_HEADER server_header
405 USER_AGENT_HEADER user_agent_header
406 REPLY_TO_VIA reply_to_via
410 WDIR "workdir"|"wdir"
412 DISABLE_TCP "disable_tcp"
413 TCP_CHILDREN "tcp_children"
414 TCP_ACCEPT_ALIASES "tcp_accept_aliases"
415 TCP_SEND_TIMEOUT "tcp_send_timeout"
416 TCP_CONNECT_TIMEOUT "tcp_connect_timeout"
417 TCP_CON_LIFETIME "tcp_connection_lifetime"
418 TCP_POLL_METHOD "tcp_poll_method"
419 TCP_MAX_CONNECTIONS "tcp_max_connections"
420 TLS_MAX_CONNECTIONS "tls_max_connections"
421 TCP_NO_CONNECT "tcp_no_connect"
422 TCP_SOURCE_IPV4 "tcp_source_ipv4"
423 TCP_SOURCE_IPV6 "tcp_source_ipv6"
424 TCP_OPT_FD_CACHE "tcp_fd_cache"
425 TCP_OPT_BUF_WRITE "tcp_buf_write"|"tcp_async"
426 TCP_OPT_CONN_WQ_MAX "tcp_conn_wq_max"
427 TCP_OPT_WQ_MAX "tcp_wq_max"
428 TCP_OPT_RD_BUF "tcp_rd_buf_size"
429 TCP_OPT_WQ_BLK "tcp_wq_blk_size"
430 TCP_OPT_DEFER_ACCEPT "tcp_defer_accept"
431 TCP_OPT_DELAYED_ACK "tcp_delayed_ack"
432 TCP_OPT_SYNCNT "tcp_syncnt"
433 TCP_OPT_LINGER2 "tcp_linger2"
434 TCP_OPT_KEEPALIVE "tcp_keepalive"
435 TCP_OPT_KEEPIDLE "tcp_keepidle"
436 TCP_OPT_KEEPINTVL "tcp_keepintvl"
437 TCP_OPT_KEEPCNT "tcp_keepcnt"
438 TCP_OPT_CRLF_PING "tcp_crlf_ping"
439 TCP_OPT_ACCEPT_NO_CL "tcp_accept_no_cl"
440 TCP_CLONE_RCVBUF "tcp_clone_rcvbuf"
441 DISABLE_TLS "disable_tls"|"tls_disable"
442 ENABLE_TLS "enable_tls"|"tls_enable"
443 TLSLOG "tlslog"|"tls_log"
444 TLS_PORT_NO "tls_port_no"
445 TLS_METHOD "tls_method"
446 TLS_VERIFY "tls_verify"
447 TLS_REQUIRE_CERTIFICATE "tls_require_certificate"
448 TLS_CERTIFICATE "tls_certificate"
449 TLS_PRIVATE_KEY "tls_private_key"
450 TLS_CA_LIST "tls_ca_list"
451 TLS_HANDSHAKE_TIMEOUT "tls_handshake_timeout"
452 TLS_SEND_TIMEOUT "tls_send_timeout"
453 DISABLE_SCTP "disable_sctp"
454 ENABLE_SCTP "enable_sctp"
455 SCTP_CHILDREN "sctp_children"
456 SCTP_SOCKET_RCVBUF "sctp_socket_rcvbuf"|"sctp_socket_receive_buffer"
457 SCTP_SOCKET_SNDBUF "sctp_socket_sndbuf"|"sctp_socket_send_buffer"
458 SCTP_AUTOCLOSE "sctp_autoclose"
459 SCTP_SEND_TTL "sctp_send_ttl"
460 SCTP_SEND_RETRIES "sctp_send_retries"
461 SCTP_ASSOC_TRACKING "sctp_assoc_tracking"
462 SCTP_ASSOC_REUSE "sctp_assoc_reuse"
463 SCTP_MAX_ASSOCS "sctp_max_assocs"
464 SCTP_SRTO_INITIAL "sctp_srto_initial"
465 SCTP_SRTO_MAX "sctp_srto_max"
466 SCTP_SRTO_MIN "sctp_srto_min"
467 SCTP_ASOCMAXRXT "sctp_asocmaxrxt"
468 SCTP_INIT_MAX_ATTEMPTS "sctp_init_max_attempts"
469 SCTP_INIT_MAX_TIMEO "sctp_init_max_timeo"
470 SCTP_HBINTERVAL "sctp_hbinterval"
471 SCTP_PATHMAXRXT "sctp_pathmaxrxt"
472 SCTP_SACK_DELAY "sctp_sack_delay"
473 SCTP_SACK_FREQ "sctp_sack_freq"
474 SCTP_MAX_BURST "sctp_max_burst"
476 ADVERTISED_ADDRESS "advertised_address"
477 ADVERTISED_PORT "advertised_port"
478 DISABLE_CORE "disable_core_dump"
479 OPEN_FD_LIMIT "open_files_limit"
480 SHM_MEM_SZ "shm"|"shm_mem"|"shm_mem_size"
481 SHM_FORCE_ALLOC "shm_force_alloc"
482 MLOCK_PAGES "mlock_pages"
483 REAL_TIME "real_time"
485 RT_POLICY "rt_policy"
486 RT_TIMER1_PRIO "rt_timer1_prio"|"rt_fast_timer_prio"|"rt_ftimer_prio"
487 RT_TIMER1_POLICY "rt_timer1_policy"|"rt_ftimer_policy"
488 RT_TIMER2_PRIO "rt_timer2_prio"|"rt_stimer_prio"
489 RT_TIMER2_POLICY "rt_timer2_policy"|"rt_stimer_policy"
490 MCAST_LOOPBACK "mcast_loopback"
491 MCAST_TTL "mcast_ttl"
493 PMTU_DISCOVERY "pmtu_discovery"
494 KILL_TIMEOUT "exit_timeout"|"ser_kill_timeout"
495 MAX_WLOOPS "max_while_loops"
496 PVBUFSIZE "pv_buffer_size"
497 PVBUFSLOTS "pv_buffer_slots"
498 HTTP_REPLY_HACK "http_reply_hack"
500 /* stun config variables */
501 STUN_REFRESH_INTERVAL "stun_refresh_interval"
502 STUN_ALLOW_STUN "stun_allow_stun"
503 STUN_ALLOW_FP "stun_allow_fp"
505 SERVER_ID "server_id"
507 LATENCY_LOG latency_log
508 LATENCY_LIMIT_DB latency_limit_db
509 LATENCY_LIMIT_ACTION latency_limit_action
513 CFG_DESCRIPTION "description"|"descr"|"desc"
515 LOADMODULE loadmodule
516 LOADPATH "loadpath"|"mpath"
520 YES "yes"|"true"|"on"|"enable"
521 NO "no"|"false"|"off"|"disable"
529 INET6 "inet6"|"INET6"
530 SSLv23 "sslv23"|"SSLv23"|"SSLV23"
531 SSLv2 "sslv2"|"SSLv2"|"SSLV2"
532 SSLv3 "sslv3"|"SSLv3"|"SSLV3"
533 TLSv1 "tlsv1"|"TLSv1"|"TLSV1"
538 ALPHANUM {LETTER_}|{DIGIT}
539 ID {LETTER_}{ALPHANUM}*
544 DECNUMBER 0|([1-9]{DIGIT}*)
547 IPV6ADDR ({HEX4}":"){7}{HEX4}|({HEX4}":"){1,7}(":"{HEX4}){1,7}|":"(":"{HEX4}){1,7}|({HEX4}":"){1,7}":"|"::"
563 EVENT_RT_NAME [a-zA-Z][0-9a-zA-Z-]*":"[a-zA-Z][0-9a-zA-Z-]*
570 /* start of pre-processing directives */
573 DEFINE "define"|"def"
577 TRYDEF "trydefine"|"trydef"
578 REDEF "redefine"|"redef"
580 /* else is already defined */
584 /* pre-processing blocks */
590 INCLUDEFILE "include_file"
591 IMPORTFILE "import_file"
596 <INITIAL>{EAT_ABLE} { count(); }
598 <INITIAL>{FORWARD} {count(); yylval.strval=yytext; return FORWARD; }
599 <INITIAL>{FORWARD_TCP} {count(); yylval.strval=yytext; return FORWARD_TCP; }
600 <INITIAL>{FORWARD_TLS} {count(); yylval.strval=yytext; return FORWARD_TLS; }
601 <INITIAL>{FORWARD_SCTP} {count(); yylval.strval=yytext; return FORWARD_SCTP;}
602 <INITIAL>{FORWARD_UDP} {count(); yylval.strval=yytext; return FORWARD_UDP; }
603 <INITIAL>{DROP} { count(); yylval.strval=yytext; return DROP; }
604 <INITIAL>{EXIT} { count(); yylval.strval=yytext; return EXIT; }
605 <INITIAL>{RETURN} { count(); yylval.strval=yytext; return RETURN; }
606 <INITIAL>{BREAK} { count(); yylval.strval=yytext; return BREAK; }
607 <INITIAL>{LOG} { count(); yylval.strval=yytext; return LOG_TOK; }
608 <INITIAL>{ERROR} { count(); yylval.strval=yytext; return ERROR; }
609 <INITIAL>{SETFLAG} { count(); yylval.strval=yytext; return SETFLAG; }
610 <INITIAL>{RESETFLAG} { count(); yylval.strval=yytext; return RESETFLAG; }
611 <INITIAL>{ISFLAGSET} { count(); yylval.strval=yytext; return ISFLAGSET; }
612 <INITIAL>{FLAGS_DECL} { count(); yylval.strval=yytext; return FLAGS_DECL; }
613 <INITIAL>{SETAVPFLAG} { count(); yylval.strval=yytext; return SETAVPFLAG; }
614 <INITIAL>{RESETAVPFLAG} { count(); yylval.strval=yytext; return RESETAVPFLAG; }
615 <INITIAL>{ISAVPFLAGSET} { count(); yylval.strval=yytext; return ISAVPFLAGSET; }
616 <INITIAL>{AVPFLAGS_DECL} { count(); yylval.strval=yytext; return AVPFLAGS_DECL; }
617 <INITIAL>{MSGLEN} { count(); yylval.strval=yytext; return MSGLEN; }
618 <INITIAL>{ROUTE} { count(); yylval.strval=yytext; return ROUTE; }
619 <INITIAL>{ROUTE_REQUEST} { count(); yylval.strval=yytext; return ROUTE_REQUEST; }
620 <INITIAL>{ROUTE_ONREPLY} { count(); yylval.strval=yytext;
621 return ROUTE_ONREPLY; }
622 <INITIAL>{ROUTE_REPLY} { count(); yylval.strval=yytext; return ROUTE_REPLY; }
623 <INITIAL>{ROUTE_FAILURE} { count(); yylval.strval=yytext;
624 return ROUTE_FAILURE; }
625 <INITIAL>{ROUTE_BRANCH} { count(); yylval.strval=yytext; return ROUTE_BRANCH; }
626 <INITIAL>{ROUTE_SEND} { count(); yylval.strval=yytext; return ROUTE_SEND; }
627 <INITIAL>{ROUTE_EVENT} { count(); yylval.strval=yytext; return ROUTE_EVENT; }
628 <INITIAL>{EXEC} { count(); yylval.strval=yytext; return EXEC; }
629 <INITIAL>{SET_HOST} { count(); yylval.strval=yytext; return SET_HOST; }
630 <INITIAL>{SET_HOSTPORT} { count(); yylval.strval=yytext; return SET_HOSTPORT; }
631 <INITIAL>{SET_HOSTPORTTRANS} { count(); yylval.strval=yytext; return SET_HOSTPORTTRANS; }
632 <INITIAL>{SET_USER} { count(); yylval.strval=yytext; return SET_USER; }
633 <INITIAL>{SET_USERPASS} { count(); yylval.strval=yytext; return SET_USERPASS; }
634 <INITIAL>{SET_PORT} { count(); yylval.strval=yytext; return SET_PORT; }
635 <INITIAL>{SET_URI} { count(); yylval.strval=yytext; return SET_URI; }
636 <INITIAL>{REVERT_URI} { count(); yylval.strval=yytext; return REVERT_URI; }
637 <INITIAL>{PREFIX} { count(); yylval.strval=yytext; return PREFIX; }
638 <INITIAL>{STRIP} { count(); yylval.strval=yytext; return STRIP; }
639 <INITIAL>{STRIP_TAIL} { count(); yylval.strval=yytext; return STRIP_TAIL; }
640 <INITIAL>{REMOVE_BRANCH} { count(); yylval.strval=yytext;
641 return REMOVE_BRANCH; }
642 <INITIAL>{CLEAR_BRANCHES} { count(); yylval.strval=yytext;
643 return CLEAR_BRANCHES; }
644 <INITIAL>{SET_USERPHONE} { count(); yylval.strval=yytext;
645 return SET_USERPHONE; }
646 <INITIAL>{FORCE_RPORT} { count(); yylval.strval=yytext; return FORCE_RPORT; }
647 <INITIAL>{ADD_LOCAL_RPORT} { count(); yylval.strval=yytext;
648 return ADD_LOCAL_RPORT; }
649 <INITIAL>{FORCE_TCP_ALIAS} { count(); yylval.strval=yytext;
650 return FORCE_TCP_ALIAS; }
651 <INITIAL>{UDP_MTU} { count(); yylval.strval=yytext; return UDP_MTU; }
652 <INITIAL>{UDP_MTU_TRY_PROTO} { count(); yylval.strval=yytext;
653 return UDP_MTU_TRY_PROTO; }
654 <INITIAL>{UDP4_RAW} { count(); yylval.strval=yytext; return UDP4_RAW; }
655 <INITIAL>{UDP4_RAW_MTU} { count(); yylval.strval=yytext; return UDP4_RAW_MTU; }
656 <INITIAL>{UDP4_RAW_TTL} { count(); yylval.strval=yytext; return UDP4_RAW_TTL; }
657 <INITIAL>{IF} { count(); yylval.strval=yytext; return IF; }
658 <INITIAL>{ELSE} { count(); yylval.strval=yytext; return ELSE; }
660 <INITIAL>{SET_ADV_ADDRESS} { count(); yylval.strval=yytext;
661 return SET_ADV_ADDRESS; }
662 <INITIAL>{SET_ADV_PORT} { count(); yylval.strval=yytext;
663 return SET_ADV_PORT; }
664 <INITIAL>{FORCE_SEND_SOCKET} { count(); yylval.strval=yytext;
665 return FORCE_SEND_SOCKET; }
666 <INITIAL>{SET_FWD_NO_CONNECT} { count(); yylval.strval=yytext;
667 return SET_FWD_NO_CONNECT; }
668 <INITIAL>{SET_RPL_NO_CONNECT} { count(); yylval.strval=yytext;
669 return SET_RPL_NO_CONNECT; }
670 <INITIAL>{SET_FWD_CLOSE} { count(); yylval.strval=yytext;
671 return SET_FWD_CLOSE; }
672 <INITIAL>{SET_RPL_CLOSE} { count(); yylval.strval=yytext;
673 return SET_RPL_CLOSE; }
674 <INITIAL>{SWITCH} { count(); yylval.strval=yytext; return SWITCH; }
675 <INITIAL>{CASE} { count(); yylval.strval=yytext; return CASE; }
676 <INITIAL>{DEFAULT} { count(); yylval.strval=yytext; return DEFAULT; }
677 <INITIAL>{WHILE} { count(); yylval.strval=yytext; return WHILE; }
679 <INITIAL>{INCLUDEFILE} { count(); BEGIN(INCLF); }
680 <INITIAL>{PREP_START}{INCLUDEFILE} { count(); BEGIN(INCLF); }
682 <INITIAL>{IMPORTFILE} { count(); BEGIN(IMPTF); }
683 <INITIAL>{PREP_START}{IMPORTFILE} { count(); BEGIN(IMPTF); }
685 <INITIAL>{CFG_SELECT} { count(); yylval.strval=yytext; return CFG_SELECT; }
686 <INITIAL>{CFG_RESET} { count(); yylval.strval=yytext; return CFG_RESET; }
688 <INITIAL>{URIHOST} { count(); yylval.strval=yytext; return URIHOST; }
689 <INITIAL>{URIPORT} { count(); yylval.strval=yytext; return URIPORT; }
691 <INITIAL>{MAX_LEN} { count(); yylval.strval=yytext; return MAX_LEN; }
693 <INITIAL>{METHOD} { count(); yylval.strval=yytext; return METHOD; }
694 <INITIAL>{URI} { count(); yylval.strval=yytext; return URI; }
695 <INITIAL>{FROM_URI} { count(); yylval.strval=yytext; return FROM_URI; }
696 <INITIAL>{TO_URI} { count(); yylval.strval=yytext; return TO_URI; }
697 <INITIAL>{SRCIP} { count(); yylval.strval=yytext; return SRCIP; }
698 <INITIAL>{SRCPORT} { count(); yylval.strval=yytext; return SRCPORT; }
699 <INITIAL>{DSTIP} { count(); yylval.strval=yytext; return DSTIP; }
700 <INITIAL>{DSTPORT} { count(); yylval.strval=yytext; return DSTPORT; }
701 <INITIAL>{SNDIP} { count(); yylval.strval=yytext; return SNDIP; }
702 <INITIAL>{SNDPORT} { count(); yylval.strval=yytext; return SNDPORT; }
703 <INITIAL>{SNDPROTO} { count(); yylval.strval=yytext; return SNDPROTO; }
704 <INITIAL>{SNDAF} { count(); yylval.strval=yytext; return SNDAF; }
705 <INITIAL>{TOIP} { count(); yylval.strval=yytext; return TOIP; }
706 <INITIAL>{TOPORT} { count(); yylval.strval=yytext; return TOPORT; }
707 <INITIAL>{PROTO} { count(); yylval.strval=yytext; return PROTO; }
708 <INITIAL>{AF} { count(); yylval.strval=yytext; return AF; }
709 <INITIAL>{MYSELF} { count(); yylval.strval=yytext; return MYSELF; }
711 <INITIAL>{DEBUG} { count(); yylval.strval=yytext; return DEBUG_V; }
712 <INITIAL>{FORK} { count(); yylval.strval=yytext; return FORK; }
713 <INITIAL>{FORK_DELAY} { count(); yylval.strval=yytext; return FORK_DELAY; }
714 <INITIAL>{LOGSTDERROR} { yylval.strval=yytext; return LOGSTDERROR; }
715 <INITIAL>{LOGFACILITY} { yylval.strval=yytext; return LOGFACILITY; }
716 <INITIAL>{LOGNAME} { yylval.strval=yytext; return LOGNAME; }
717 <INITIAL>{LOGCOLOR} { yylval.strval=yytext; return LOGCOLOR; }
718 <INITIAL>{LISTEN} { count(); yylval.strval=yytext; return LISTEN; }
719 <INITIAL>{ADVERTISE} { count(); yylval.strval=yytext; return ADVERTISE; }
720 <INITIAL>{ALIAS} { count(); yylval.strval=yytext; return ALIAS; }
721 <INITIAL>{SR_AUTO_ALIASES} { count(); yylval.strval=yytext;
722 return SR_AUTO_ALIASES; }
723 <INITIAL>{DNS} { count(); yylval.strval=yytext; return DNS; }
724 <INITIAL>{REV_DNS} { count(); yylval.strval=yytext; return REV_DNS; }
725 <INITIAL>{DNS_TRY_IPV6} { count(); yylval.strval=yytext;
726 return DNS_TRY_IPV6; }
727 <INITIAL>{DNS_TRY_NAPTR} { count(); yylval.strval=yytext;
728 return DNS_TRY_NAPTR; }
729 <INITIAL>{DNS_SRV_LB} { count(); yylval.strval=yytext;
731 <INITIAL>{DNS_UDP_PREF} { count(); yylval.strval=yytext;
732 return DNS_UDP_PREF; }
733 <INITIAL>{DNS_TCP_PREF} { count(); yylval.strval=yytext;
734 return DNS_TCP_PREF; }
735 <INITIAL>{DNS_TLS_PREF} { count(); yylval.strval=yytext;
736 return DNS_TLS_PREF; }
737 <INITIAL>{DNS_SCTP_PREF} { count(); yylval.strval=yytext;
738 return DNS_SCTP_PREF; }
739 <INITIAL>{DNS_RETR_TIME} { count(); yylval.strval=yytext;
740 return DNS_RETR_TIME; }
741 <INITIAL>{DNS_RETR_NO} { count(); yylval.strval=yytext;
742 return DNS_RETR_NO; }
743 <INITIAL>{DNS_SERVERS_NO} { count(); yylval.strval=yytext;
744 return DNS_SERVERS_NO; }
745 <INITIAL>{DNS_USE_SEARCH} { count(); yylval.strval=yytext;
746 return DNS_USE_SEARCH; }
747 <INITIAL>{DNS_SEARCH_FMATCH} { count(); yylval.strval=yytext;
748 return DNS_SEARCH_FMATCH; }
749 <INITIAL>{DNS_CACHE_INIT} { count(); yylval.strval=yytext;
750 return DNS_CACHE_INIT; }
751 <INITIAL>{DNS_USE_CACHE} { count(); yylval.strval=yytext;
752 return DNS_USE_CACHE; }
753 <INITIAL>{DNS_USE_FAILOVER} { count(); yylval.strval=yytext;
754 return DNS_USE_FAILOVER; }
755 <INITIAL>{DNS_CACHE_FLAGS} { count(); yylval.strval=yytext;
756 return DNS_CACHE_FLAGS; }
757 <INITIAL>{DNS_CACHE_NEG_TTL} { count(); yylval.strval=yytext;
758 return DNS_CACHE_NEG_TTL; }
759 <INITIAL>{DNS_CACHE_MIN_TTL} { count(); yylval.strval=yytext;
760 return DNS_CACHE_MIN_TTL; }
761 <INITIAL>{DNS_CACHE_MAX_TTL} { count(); yylval.strval=yytext;
762 return DNS_CACHE_MAX_TTL; }
763 <INITIAL>{DNS_CACHE_MEM} { count(); yylval.strval=yytext;
764 return DNS_CACHE_MEM; }
765 <INITIAL>{DNS_CACHE_GC_INT} { count(); yylval.strval=yytext;
766 return DNS_CACHE_GC_INT; }
767 <INITIAL>{DNS_CACHE_DEL_NONEXP} { count(); yylval.strval=yytext;
768 return DNS_CACHE_DEL_NONEXP; }
769 <INITIAL>{AUTO_BIND_IPV6} { count(); yylval.strval=yytext;
770 return AUTO_BIND_IPV6; }
771 <INITIAL>{DST_BLST_INIT} { count(); yylval.strval=yytext;
772 return DST_BLST_INIT; }
773 <INITIAL>{USE_DST_BLST} { count(); yylval.strval=yytext;
774 return USE_DST_BLST; }
775 <INITIAL>{DST_BLST_MEM} { count(); yylval.strval=yytext;
776 return DST_BLST_MEM; }
777 <INITIAL>{DST_BLST_TTL} { count(); yylval.strval=yytext;
778 return DST_BLST_TTL; }
779 <INITIAL>{DST_BLST_GC_INT} { count(); yylval.strval=yytext;
780 return DST_BLST_GC_INT; }
781 <INITIAL>{DST_BLST_UDP_IMASK} { count(); yylval.strval=yytext;
782 return DST_BLST_UDP_IMASK; }
783 <INITIAL>{DST_BLST_TCP_IMASK} { count(); yylval.strval=yytext;
784 return DST_BLST_TCP_IMASK; }
785 <INITIAL>{DST_BLST_TLS_IMASK} { count(); yylval.strval=yytext;
786 return DST_BLST_TLS_IMASK; }
787 <INITIAL>{DST_BLST_SCTP_IMASK} { count(); yylval.strval=yytext;
788 return DST_BLST_SCTP_IMASK; }
789 <INITIAL>{PORT} { count(); yylval.strval=yytext; return PORT; }
790 <INITIAL>{STAT} { count(); yylval.strval=yytext; return STAT; }
791 <INITIAL>{MAXBUFFER} { count(); yylval.strval=yytext; return MAXBUFFER; }
792 <INITIAL>{SQL_BUFFER_SIZE} { count(); yylval.strval=yytext; return SQL_BUFFER_SIZE; }
793 <INITIAL>{CHILDREN} { count(); yylval.strval=yytext; return CHILDREN; }
794 <INITIAL>{SOCKET_WORKERS} { count(); yylval.strval=yytext; return SOCKET_WORKERS; }
795 <INITIAL>{CHECK_VIA} { count(); yylval.strval=yytext; return CHECK_VIA; }
796 <INITIAL>{PHONE2TEL} { count(); yylval.strval=yytext; return PHONE2TEL; }
797 <INITIAL>{SYN_BRANCH} { count(); yylval.strval=yytext; return SYN_BRANCH; }
798 <INITIAL>{MEMLOG} { count(); yylval.strval=yytext; return MEMLOG; }
799 <INITIAL>{MEMDBG} { count(); yylval.strval=yytext; return MEMDBG; }
800 <INITIAL>{MEMSUM} { count(); yylval.strval=yytext; return MEMSUM; }
801 <INITIAL>{MEMSAFETY} { count(); yylval.strval=yytext; return MEMSAFETY; }
802 <INITIAL>{MEMJOIN} { count(); yylval.strval=yytext; return MEMJOIN; }
803 <INITIAL>{CORELOG} { count(); yylval.strval=yytext; return CORELOG; }
804 <INITIAL>{SIP_WARNING} { count(); yylval.strval=yytext; return SIP_WARNING; }
805 <INITIAL>{USER} { count(); yylval.strval=yytext; return USER; }
806 <INITIAL>{GROUP} { count(); yylval.strval=yytext; return GROUP; }
807 <INITIAL>{CHROOT} { count(); yylval.strval=yytext; return CHROOT; }
808 <INITIAL>{WDIR} { count(); yylval.strval=yytext; return WDIR; }
809 <INITIAL>{MHOMED} { count(); yylval.strval=yytext; return MHOMED; }
810 <INITIAL>{DISABLE_TCP} { count(); yylval.strval=yytext; return DISABLE_TCP; }
811 <INITIAL>{TCP_CHILDREN} { count(); yylval.strval=yytext; return TCP_CHILDREN; }
812 <INITIAL>{TCP_ACCEPT_ALIASES} { count(); yylval.strval=yytext;
813 return TCP_ACCEPT_ALIASES; }
814 <INITIAL>{TCP_SEND_TIMEOUT} { count(); yylval.strval=yytext;
815 return TCP_SEND_TIMEOUT; }
816 <INITIAL>{TCP_CONNECT_TIMEOUT} { count(); yylval.strval=yytext;
817 return TCP_CONNECT_TIMEOUT; }
818 <INITIAL>{TCP_CON_LIFETIME} { count(); yylval.strval=yytext;
819 return TCP_CON_LIFETIME; }
820 <INITIAL>{TCP_POLL_METHOD} { count(); yylval.strval=yytext;
821 return TCP_POLL_METHOD; }
822 <INITIAL>{TCP_MAX_CONNECTIONS} { count(); yylval.strval=yytext;
823 return TCP_MAX_CONNECTIONS; }
824 <INITIAL>{TLS_MAX_CONNECTIONS} { count(); yylval.strval=yytext;
825 return TLS_MAX_CONNECTIONS; }
826 <INITIAL>{TCP_NO_CONNECT} { count(); yylval.strval=yytext;
827 return TCP_NO_CONNECT; }
828 <INITIAL>{TCP_SOURCE_IPV4} { count(); yylval.strval=yytext;
829 return TCP_SOURCE_IPV4; }
830 <INITIAL>{TCP_SOURCE_IPV6} { count(); yylval.strval=yytext;
831 return TCP_SOURCE_IPV6; }
832 <INITIAL>{TCP_OPT_FD_CACHE} { count(); yylval.strval=yytext;
833 return TCP_OPT_FD_CACHE; }
834 <INITIAL>{TCP_OPT_CONN_WQ_MAX} { count(); yylval.strval=yytext;
835 return TCP_OPT_CONN_WQ_MAX; }
836 <INITIAL>{TCP_OPT_WQ_MAX} { count(); yylval.strval=yytext;
837 return TCP_OPT_WQ_MAX; }
838 <INITIAL>{TCP_OPT_RD_BUF} { count(); yylval.strval=yytext;
839 return TCP_OPT_RD_BUF; }
840 <INITIAL>{TCP_OPT_WQ_BLK} { count(); yylval.strval=yytext;
841 return TCP_OPT_WQ_BLK; }
842 <INITIAL>{TCP_OPT_BUF_WRITE} { count(); yylval.strval=yytext;
843 return TCP_OPT_BUF_WRITE; }
844 <INITIAL>{TCP_OPT_DEFER_ACCEPT} { count(); yylval.strval=yytext;
845 return TCP_OPT_DEFER_ACCEPT; }
846 <INITIAL>{TCP_OPT_DELAYED_ACK} { count(); yylval.strval=yytext;
847 return TCP_OPT_DELAYED_ACK; }
848 <INITIAL>{TCP_OPT_SYNCNT} { count(); yylval.strval=yytext;
849 return TCP_OPT_SYNCNT; }
850 <INITIAL>{TCP_OPT_LINGER2} { count(); yylval.strval=yytext;
851 return TCP_OPT_LINGER2; }
852 <INITIAL>{TCP_OPT_KEEPALIVE} { count(); yylval.strval=yytext;
853 return TCP_OPT_KEEPALIVE; }
854 <INITIAL>{TCP_OPT_KEEPIDLE} { count(); yylval.strval=yytext;
855 return TCP_OPT_KEEPIDLE; }
856 <INITIAL>{TCP_OPT_KEEPINTVL} { count(); yylval.strval=yytext;
857 return TCP_OPT_KEEPINTVL; }
858 <INITIAL>{TCP_OPT_KEEPCNT} { count(); yylval.strval=yytext;
859 return TCP_OPT_KEEPCNT; }
860 <INITIAL>{TCP_OPT_CRLF_PING} { count(); yylval.strval=yytext;
861 return TCP_OPT_CRLF_PING; }
862 <INITIAL>{TCP_OPT_ACCEPT_NO_CL} { count(); yylval.strval=yytext;
863 return TCP_OPT_ACCEPT_NO_CL; }
864 <INITIAL>{TCP_CLONE_RCVBUF} { count(); yylval.strval=yytext;
865 return TCP_CLONE_RCVBUF; }
866 <INITIAL>{DISABLE_TLS} { count(); yylval.strval=yytext; return DISABLE_TLS; }
867 <INITIAL>{ENABLE_TLS} { count(); yylval.strval=yytext; return ENABLE_TLS; }
868 <INITIAL>{TLSLOG} { count(); yylval.strval=yytext; return TLS_PORT_NO; }
869 <INITIAL>{TLS_PORT_NO} { count(); yylval.strval=yytext; return TLS_PORT_NO; }
870 <INITIAL>{TLS_METHOD} { count(); yylval.strval=yytext; return TLS_METHOD; }
871 <INITIAL>{TLS_VERIFY} { count(); yylval.strval=yytext; return TLS_VERIFY; }
872 <INITIAL>{TLS_REQUIRE_CERTIFICATE} { count(); yylval.strval=yytext;
873 return TLS_REQUIRE_CERTIFICATE; }
874 <INITIAL>{TLS_CERTIFICATE} { count(); yylval.strval=yytext;
875 return TLS_CERTIFICATE; }
876 <INITIAL>{TLS_PRIVATE_KEY} { count(); yylval.strval=yytext;
877 return TLS_PRIVATE_KEY; }
878 <INITIAL>{TLS_CA_LIST} { count(); yylval.strval=yytext;
879 return TLS_CA_LIST; }
880 <INITIAL>{TLS_HANDSHAKE_TIMEOUT} { count(); yylval.strval=yytext;
881 return TLS_HANDSHAKE_TIMEOUT; }
882 <INITIAL>{TLS_SEND_TIMEOUT} { count(); yylval.strval=yytext;
883 return TLS_SEND_TIMEOUT; }
884 <INITIAL>{DISABLE_SCTP} { count(); yylval.strval=yytext; return DISABLE_SCTP;}
885 <INITIAL>{ENABLE_SCTP} { count(); yylval.strval=yytext; return ENABLE_SCTP;}
886 <INITIAL>{SCTP_CHILDREN} { count(); yylval.strval=yytext;
887 return SCTP_CHILDREN; }
888 <INITIAL>{SCTP_SOCKET_RCVBUF} { count(); yylval.strval=yytext;
889 return SCTP_SOCKET_RCVBUF; }
890 <INITIAL>{SCTP_SOCKET_SNDBUF} { count(); yylval.strval=yytext;
891 return SCTP_SOCKET_SNDBUF; }
892 <INITIAL>{SCTP_AUTOCLOSE} { count(); yylval.strval=yytext;
893 return SCTP_AUTOCLOSE; }
894 <INITIAL>{SCTP_SEND_TTL} { count(); yylval.strval=yytext;
895 return SCTP_SEND_TTL; }
896 <INITIAL>{SCTP_SEND_RETRIES} { count(); yylval.strval=yytext;
897 return SCTP_SEND_RETRIES; }
898 <INITIAL>{SCTP_ASSOC_TRACKING} { count(); yylval.strval=yytext;
899 return SCTP_ASSOC_TRACKING; }
900 <INITIAL>{SCTP_ASSOC_REUSE} { count(); yylval.strval=yytext;
901 return SCTP_ASSOC_REUSE; }
902 <INITIAL>{SCTP_MAX_ASSOCS} { count(); yylval.strval=yytext;
903 return SCTP_MAX_ASSOCS; }
904 <INITIAL>{SCTP_SRTO_INITIAL} { count(); yylval.strval=yytext;
905 return SCTP_SRTO_INITIAL; }
906 <INITIAL>{SCTP_SRTO_MAX} { count(); yylval.strval=yytext;
907 return SCTP_SRTO_MAX; }
908 <INITIAL>{SCTP_SRTO_MIN} { count(); yylval.strval=yytext;
909 return SCTP_SRTO_MIN; }
910 <INITIAL>{SCTP_ASOCMAXRXT} { count(); yylval.strval=yytext;
911 return SCTP_ASOCMAXRXT; }
912 <INITIAL>{SCTP_INIT_MAX_ATTEMPTS} { count(); yylval.strval=yytext;
913 return SCTP_INIT_MAX_ATTEMPTS; }
914 <INITIAL>{SCTP_INIT_MAX_TIMEO} { count(); yylval.strval=yytext;
915 return SCTP_INIT_MAX_TIMEO; }
916 <INITIAL>{SCTP_HBINTERVAL} { count(); yylval.strval=yytext;
917 return SCTP_HBINTERVAL; }
918 <INITIAL>{SCTP_PATHMAXRXT} { count(); yylval.strval=yytext;
919 return SCTP_PATHMAXRXT; }
920 <INITIAL>{SCTP_SACK_DELAY} { count(); yylval.strval=yytext;
921 return SCTP_SACK_DELAY; }
922 <INITIAL>{SCTP_SACK_FREQ} { count(); yylval.strval=yytext;
923 return SCTP_SACK_FREQ; }
924 <INITIAL>{SCTP_MAX_BURST} { count(); yylval.strval=yytext;
925 return SCTP_MAX_BURST; }
926 <INITIAL>{SERVER_SIGNATURE} { count(); yylval.strval=yytext; return SERVER_SIGNATURE; }
927 <INITIAL>{SERVER_HEADER} { count(); yylval.strval=yytext; return SERVER_HEADER; }
928 <INITIAL>{USER_AGENT_HEADER} { count(); yylval.strval=yytext; return USER_AGENT_HEADER; }
929 <INITIAL>{REPLY_TO_VIA} { count(); yylval.strval=yytext; return REPLY_TO_VIA; }
930 <INITIAL>{ADVERTISED_ADDRESS} { count(); yylval.strval=yytext;
931 return ADVERTISED_ADDRESS; }
932 <INITIAL>{ADVERTISED_PORT} { count(); yylval.strval=yytext;
933 return ADVERTISED_PORT; }
934 <INITIAL>{DISABLE_CORE} { count(); yylval.strval=yytext;
935 return DISABLE_CORE; }
936 <INITIAL>{OPEN_FD_LIMIT} { count(); yylval.strval=yytext;
937 return OPEN_FD_LIMIT; }
938 <INITIAL>{SHM_MEM_SZ} { count(); yylval.strval=yytext;
940 <INITIAL>{SHM_FORCE_ALLOC} { count(); yylval.strval=yytext;
941 return SHM_FORCE_ALLOC; }
942 <INITIAL>{MLOCK_PAGES} { count(); yylval.strval=yytext;
943 return MLOCK_PAGES; }
944 <INITIAL>{REAL_TIME} { count(); yylval.strval=yytext;
946 <INITIAL>{RT_PRIO} { count(); yylval.strval=yytext;
948 <INITIAL>{RT_POLICY} { count(); yylval.strval=yytext;
950 <INITIAL>{RT_TIMER1_PRIO} { count(); yylval.strval=yytext;
951 return RT_TIMER1_PRIO; }
952 <INITIAL>{RT_TIMER1_POLICY} { count(); yylval.strval=yytext;
953 return RT_TIMER1_POLICY; }
954 <INITIAL>{RT_TIMER2_PRIO} { count(); yylval.strval=yytext;
955 return RT_TIMER2_PRIO; }
956 <INITIAL>{RT_TIMER2_POLICY} { count(); yylval.strval=yytext;
957 return RT_TIMER2_POLICY; }
958 <INITIAL>{MCAST_LOOPBACK} { count(); yylval.strval=yytext;
959 return MCAST_LOOPBACK; }
960 <INITIAL>{MCAST_TTL} { count(); yylval.strval=yytext;
962 <INITIAL>{TOS} { count(); yylval.strval=yytext;
964 <INITIAL>{PMTU_DISCOVERY} { count(); yylval.strval=yytext;
965 return PMTU_DISCOVERY; }
966 <INITIAL>{KILL_TIMEOUT} { count(); yylval.strval=yytext;
967 return KILL_TIMEOUT; }
968 <INITIAL>{MAX_WLOOPS} { count(); yylval.strval=yytext;
970 <INITIAL>{PVBUFSIZE} { count(); yylval.strval=yytext;
972 <INITIAL>{PVBUFSLOTS} { count(); yylval.strval=yytext;
974 <INITIAL>{HTTP_REPLY_HACK} { count(); yylval.strval=yytext;
975 return HTTP_REPLY_HACK; }
976 <INITIAL>{SERVER_ID} { count(); yylval.strval=yytext; return SERVER_ID;}
977 <INITIAL>{LATENCY_LOG} { count(); yylval.strval=yytext; return LATENCY_LOG;}
978 <INITIAL>{MSG_TIME} { count(); yylval.strval=yytext; return MSG_TIME;}
979 <INITIAL>{LATENCY_LIMIT_DB} { count(); yylval.strval=yytext; return LATENCY_LIMIT_DB;}
980 <INITIAL>{LATENCY_LIMIT_ACTION} { count(); yylval.strval=yytext; return LATENCY_LIMIT_ACTION;}
981 <INITIAL>{CFG_DESCRIPTION} { count(); yylval.strval=yytext; return CFG_DESCRIPTION; }
982 <INITIAL>{LOADMODULE} { count(); yylval.strval=yytext; return LOADMODULE; }
983 <INITIAL>{LOADPATH} { count(); yylval.strval=yytext; return LOADPATH; }
984 <INITIAL>{MODPARAM} { count(); yylval.strval=yytext; return MODPARAM; }
986 <INITIAL>{STUN_REFRESH_INTERVAL} { count(); yylval.strval=yytext; return STUN_REFRESH_INTERVAL;}
987 <INITIAL>{STUN_ALLOW_STUN} { count(); yylval.strval=yytext; return STUN_ALLOW_STUN;}
988 <INITIAL>{STUN_ALLOW_FP} { count(); yylval.strval=yytext; return STUN_ALLOW_FP;}
990 <INITIAL>{EQUAL} { count(); return EQUAL; }
991 <INITIAL>{ADDEQ} { count(); return ADDEQ; }
992 <INITIAL>{EQUAL_T} { count(); return EQUAL_T; }
993 <INITIAL>{GT} { count(); return GT; }
994 <INITIAL>{LT} { count(); return LT; }
995 <INITIAL>{GTE} { count(); return GTE; }
996 <INITIAL>{LTE} { count(); return LTE; }
997 <INITIAL>{DIFF} { count(); return DIFF; }
998 <INITIAL>{MATCH} { count(); return MATCH; }
999 <INITIAL>{NOT} { count(); return NOT; }
1000 <INITIAL>{LOG_AND} { count(); return LOG_AND; }
1001 <INITIAL>{BIN_AND} { count(); return BIN_AND; }
1002 <INITIAL>{LOG_OR} { count(); return LOG_OR; }
1003 <INITIAL>{BIN_OR} { count(); return BIN_OR; }
1004 <INITIAL>{BIN_NOT} { count(); return BIN_NOT; }
1005 <INITIAL>{BIN_XOR} { count(); return BIN_XOR; }
1006 <INITIAL>{BIN_LSHIFT} { count(); return BIN_LSHIFT; }
1007 <INITIAL>{BIN_RSHIFT} { count(); return BIN_RSHIFT; }
1008 <INITIAL>{PLUS} { count(); return PLUS; }
1009 <INITIAL>{MINUS} { count(); return MINUS; }
1010 <INITIAL>{MODULO} { count(); return MODULO; }
1011 <INITIAL>{STRLEN} { count(); return STRLEN; }
1012 <INITIAL>{STREMPTY} { count(); return STREMPTY; }
1013 <INITIAL>{DEFINED} { count(); return DEFINED; }
1014 <INITIAL>{STREQ} { count(); return STREQ; }
1015 <INITIAL>{INTEQ} { count(); return INTEQ; }
1016 <INITIAL>{STRDIFF} { count(); return STRDIFF; }
1017 <INITIAL>{INTDIFF} { count(); return INTDIFF; }
1018 <INITIAL>{INTCAST} { count(); return INTCAST; }
1019 <INITIAL>{STRCAST} { count(); return STRCAST; }
1021 <INITIAL>{SELECT_MARK} { count(); state = SELECT_S; BEGIN(SELECT); return SELECT_MARK; }
1022 <SELECT>{ID} { count(); addstr(&s_buf, yytext, yyleng);
1023 yylval.strval=s_buf.s;
1024 memset(&s_buf, 0, sizeof(s_buf));
1027 <SELECT>{DOT} { count(); return DOT; }
1028 <SELECT>{LBRACK} { count(); return LBRACK; }
1029 <SELECT>{RBRACK} { count(); return RBRACK; }
1030 <SELECT>{DECNUMBER} { count(); yylval.intval=atoi(yytext);
1031 yy_number_str=yytext; return NUMBER; }
1032 <SELECT>{HEXNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 16);
1033 yy_number_str=yytext; return NUMBER; }
1034 <SELECT>{OCTNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 8);
1035 yy_number_str=yytext; return NUMBER; }
1036 <SELECT>{BINNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 2);
1037 yy_number_str=yytext; return NUMBER; }
1040 <INITIAL>{ATTR_MARK} { count(); state = ATTR_S; BEGIN(ATTR);
1042 <ATTR>{ATTR_FROM} { count(); return ATTR_FROM; }
1043 <ATTR>{ATTR_TO} { count(); return ATTR_TO; }
1044 <ATTR>{ATTR_FROMURI} { count(); return ATTR_FROMURI; }
1045 <ATTR>{ATTR_TOURI} { count(); return ATTR_TOURI; }
1046 <ATTR>{ATTR_FROMUSER} { count(); return ATTR_FROMUSER; }
1047 <ATTR>{ATTR_TOUSER} { count(); return ATTR_TOUSER; }
1048 <ATTR>{ATTR_FROMDOMAIN} { count(); return ATTR_FROMDOMAIN; }
1049 <ATTR>{ATTR_TODOMAIN} { count(); return ATTR_TODOMAIN; }
1050 <ATTR>{ATTR_GLOBAL} { count(); return ATTR_GLOBAL; }
1051 <ATTR>{DOT} { count(); return DOT; }
1052 <ATTR>{LBRACK} { count(); return LBRACK; }
1053 <ATTR>{RBRACK} { count(); return RBRACK; }
1054 <ATTR>{STAR} { count(); return STAR; }
1055 <ATTR>{DECNUMBER} { count(); yylval.intval=atoi(yytext);
1056 yy_number_str=yytext; return NUMBER; }
1057 <ATTR>{ID} { count(); addstr(&s_buf, yytext, yyleng);
1058 yylval.strval=s_buf.s;
1059 memset(&s_buf, 0, sizeof(s_buf));
1065 <INITIAL>{VAR_MARK}{LPAREN} {
1066 switch(sr_cfg_compat){
1068 state=ATTR_S; BEGIN(ATTR);
1073 case SR_COMPAT_KAMAILIO:
1076 state = PVAR_P_S; BEGIN(PVAR_P);
1081 /* eat everything between 2 () and return PVAR token and a string
1082 containing everything (including $ and ()) */
1083 <PVAR_P>{RPAREN} { p_nest--;
1086 addstr(&s_buf, yytext, yyleng);
1087 yylval.strval=s_buf.s;
1088 memset(&s_buf, 0, sizeof(s_buf));
1095 <PVAR_P>{LPAREN} { p_nest++; yymore(); }
1096 <PVAR_P>. { yymore(); }
1098 <PVARID>{ID}|'\.' {yymore(); }
1099 <PVARID>{LPAREN} { state = PVAR_P_S; BEGIN(PVAR_P);
1100 p_nest=1; yymore(); }
1101 <PVARID>. { yyless(yyleng-1);
1103 addstr(&s_buf, yytext, yyleng);
1104 yylval.strval=s_buf.s;
1105 memset(&s_buf, 0, sizeof(s_buf));
1111 /* if found retcode => it's a built-in pvar */
1112 <INITIAL>{RETCODE} { count(); yylval.strval=yytext; return PVAR; }
1114 <INITIAL>{VAR_MARK} {
1115 switch(sr_cfg_compat){
1118 state=ATTR_S; BEGIN(ATTR);
1121 case SR_COMPAT_KAMAILIO:
1122 state=PVARID_S; BEGIN(PVARID);
1127 state=AVP_PVAR_S; BEGIN(AVP_PVAR);
1132 /* avp prefix detected -> go to avp mode */
1133 <AVP_PVAR>{AVP_PREF} |
1134 <AVP_PVAR>{ID}{LBRACK} { state = ATTR_S; BEGIN(ATTR); yyless(1); count();
1136 <AVP_PVAR>{ID}{LPAREN} { state = PVAR_P_S; p_nest=1; BEGIN(PVAR_P);
1138 <AVP_PVAR>{ID} { count(); addstr(&s_buf, yytext, yyleng);
1139 yylval.strval=s_buf.s;
1140 memset(&s_buf, 0, sizeof(s_buf));
1146 <INITIAL>{IPV6ADDR} { count(); yylval.strval=yytext; return IPV6ADDR; }
1147 <INITIAL>{DECNUMBER} { count(); yylval.intval=atoi(yytext);
1148 yy_number_str=yytext; return NUMBER; }
1149 <INITIAL>{HEXNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 16);
1150 yy_number_str=yytext; return NUMBER; }
1151 <INITIAL>{OCTNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 8);
1152 yy_number_str=yytext; return NUMBER; }
1153 <INITIAL>{BINNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 2);
1154 yy_number_str=yytext; return NUMBER; }
1155 <INITIAL>{YES} { count(); yylval.intval=1;
1156 yy_number_str=yytext; return NUMBER; }
1157 <INITIAL>{NO} { count(); yylval.intval=0;
1158 yy_number_str=yytext; return NUMBER; }
1159 <INITIAL>{TCP} { count(); return TCP; }
1160 <INITIAL>{UDP} { count(); return UDP; }
1161 <INITIAL>{TLS} { count(); return TLS; }
1162 <INITIAL>{SCTP} { count(); return SCTP; }
1163 <INITIAL>{WS} { count(); return WS; }
1164 <INITIAL>{WSS} { count(); return WSS; }
1165 <INITIAL>{INET} { count(); yylval.intval=AF_INET;
1166 yy_number_str=yytext; return NUMBER; }
1167 <INITIAL>{INET6} { count();
1169 yylval.intval=AF_INET6;
1171 yylval.intval=-1; /* no match*/
1173 yy_number_str=yytext;
1175 <INITIAL>{SSLv23} { count(); yylval.strval=yytext; return SSLv23; }
1176 <INITIAL>{SSLv2} { count(); yylval.strval=yytext; return SSLv2; }
1177 <INITIAL>{SSLv3} { count(); yylval.strval=yytext; return SSLv3; }
1178 <INITIAL>{TLSv1} { count(); yylval.strval=yytext; return TLSv1; }
1180 <INITIAL>{COMMA} { count(); return COMMA; }
1181 <INITIAL>{SEMICOLON} { count(); return SEMICOLON; }
1182 <INITIAL>{COLON} { count(); return COLON; }
1183 <INITIAL>{STAR} { count(); return STAR; }
1184 <INITIAL>{RPAREN} { count(); return RPAREN; }
1185 <INITIAL>{LPAREN} { count(); return LPAREN; }
1186 <INITIAL>{LBRACE} { count(); return LBRACE; }
1187 <INITIAL>{RBRACE} { count(); return RBRACE; }
1188 <INITIAL>{LBRACK} { count(); return LBRACK; }
1189 <INITIAL>{RBRACK} { count(); return RBRACK; }
1190 <INITIAL>{SLASH} { count(); return SLASH; }
1191 <INITIAL>{DOT} { count(); return DOT; }
1192 <INITIAL>\\{CR} {count(); } /* eat the escaped CR */
1193 <INITIAL>{CR} { count();/* return CR;*/ }
1194 <INITIAL>{EVENT_RT_NAME} { count();
1195 addstr(&s_buf, yytext, yyleng);
1196 yylval.strval=s_buf.s;
1197 memset(&s_buf, 0, sizeof(s_buf));
1198 return EVENT_RT_NAME; }
1201 <INITIAL,SELECT>{QUOTES} { count(); old_initial = YY_START;
1202 old_state = state; state=STRING_S;
1204 <INITIAL>{TICK} { count(); old_initial = YY_START; old_state = state;
1205 state=STRING_S; BEGIN(STRING2); }
1208 <STRING1>{QUOTES} { count_more();
1209 yytext[yyleng-1]=0; yyleng--;
1210 addstr(&s_buf, yytext, yyleng);
1211 state=STR_BETWEEN_S;
1214 <STRING2>{TICK} { count_more(); state=old_state; BEGIN(old_initial);
1215 yytext[yyleng-1]=0; yyleng--;
1216 addstr(&s_buf, yytext, yyleng);
1217 r = pp_subst_run(&s_buf.s);
1218 yylval.strval=s_buf.s;
1219 memset(&s_buf, 0, sizeof(s_buf));
1222 <STRING2>.|{EAT_ABLE}|{CR} { yymore(); }
1224 <STRING1>\\n { count_more(); addchar(&s_buf, '\n'); }
1225 <STRING1>\\r { count_more(); addchar(&s_buf, '\r'); }
1226 <STRING1>\\a { count_more(); addchar(&s_buf, '\a'); }
1227 <STRING1>\\t { count_more(); addchar(&s_buf, '\t'); }
1228 <STRING1>\\{QUOTES} { count_more(); addchar(&s_buf, '"'); }
1229 <STRING1>\\\\ { count_more(); addchar(&s_buf, '\\'); }
1230 <STRING1>\\x{HEX}{1,2} { count_more(); addchar(&s_buf,
1231 (char)strtol(yytext+2, 0, 16)); }
1232 /* don't allow \[0-7]{1}, it will eat the backreferences from
1233 subst_uri if allowed (although everybody should use '' in subt_uri) */
1234 <STRING1>\\[0-7]{2,3} { count_more(); addchar(&s_buf,
1235 (char)strtol(yytext+1, 0, 8)); }
1236 <STRING1>\\{CR} { count_more(); } /* eat escaped CRs */
1237 <STRING1>.|{EAT_ABLE}|{CR} { count_more(); addchar(&s_buf, *yytext); }
1239 <STR_BETWEEN>{EAT_ABLE}|{CR} { count_ignore(); }
1240 <STR_BETWEEN>{QUOTES} { count_more(); state=STRING_S;
1243 yyless(0); /* reparse it */
1244 /* ignore the whitespace now that is
1245 counted, return saved string value */
1246 state=old_state; BEGIN(old_initial);
1247 r = pp_subst_run(&s_buf.s);
1248 yylval.strval=s_buf.s;
1249 memset(&s_buf, 0, sizeof(s_buf));
1253 <INITIAL,COMMENT>{COM_START} { count(); comment_nest++; state=COMMENT_S;
1255 <COMMENT>{COM_END} { count(); comment_nest--;
1256 if (comment_nest==0){
1261 <COMMENT>.|{EAT_ABLE}|{CR} { count(); };
1263 <INITIAL>{COM_LINE}!{SER_CFG}{CR} { count();
1264 sr_cfg_compat=SR_COMPAT_SER;}
1265 <INITIAL>{COM_LINE}!{KAMAILIO_CFG}{CR} { count();
1266 sr_cfg_compat=SR_COMPAT_KAMAILIO;}
1267 <INITIAL>{COM_LINE}!{MAXCOMPAT_CFG}{CR} { count();
1268 sr_cfg_compat=SR_COMPAT_MAX;}
1270 <INITIAL>{PREP_START}{DEFINE}{EAT_ABLE}+ { count(); pp_define_set_type(0);
1271 state = DEFINE_S; BEGIN(DEFINE_ID); }
1272 <INITIAL>{PREP_START}{TRYDEF}{EAT_ABLE}+ { count(); pp_define_set_type(1);
1273 state = DEFINE_S; BEGIN(DEFINE_ID); }
1274 <INITIAL>{PREP_START}{REDEF}{EAT_ABLE}+ { count(); pp_define_set_type(2);
1275 state = DEFINE_S; BEGIN(DEFINE_ID); }
1276 <DEFINE_ID>{ID} { count();
1277 if (pp_define(yyleng, yytext)) return 1;
1278 state = DEFINE_EOL_S; BEGIN(DEFINE_EOL); }
1279 <DEFINE_EOL>{EAT_ABLE} { count(); }
1280 <DEFINE_EOL>{CR} { count();
1281 state = INITIAL; BEGIN(INITIAL); }
1282 <DEFINE_EOL>. { count();
1283 addstr(&s_buf, yytext, yyleng);
1284 state = DEFINE_DATA_S; BEGIN(DEFINE_DATA); }
1285 <DEFINE_DATA>\\{CR} { count(); } /* eat the escaped CR */
1286 <DEFINE_DATA>{CR} { count();
1287 if (pp_define_set(strlen(s_buf.s), s_buf.s)) return 1;
1288 memset(&s_buf, 0, sizeof(s_buf));
1289 state = INITIAL; BEGIN(INITIAL); }
1290 <DEFINE_DATA>. { count();
1291 addstr(&s_buf, yytext, yyleng); }
1293 <INITIAL>{PREP_START}{SUBST} { count(); return SUBST;}
1294 <INITIAL>{PREP_START}{SUBSTDEF} { count(); return SUBSTDEF;}
1295 <INITIAL>{PREP_START}{SUBSTDEFS} { count(); return SUBSTDEFS;}
1297 <INITIAL,IFDEF_SKIP>{PREP_START}{IFDEF}{EAT_ABLE}+ { count();
1298 if (pp_ifdef_type(1)) return 1;
1299 state = IFDEF_S; BEGIN(IFDEF_ID); }
1300 <INITIAL,IFDEF_SKIP>{PREP_START}{IFNDEF}{EAT_ABLE}+ { count();
1301 if (pp_ifdef_type(0)) return 1;
1302 state = IFDEF_S; BEGIN(IFDEF_ID); }
1303 <IFDEF_ID>{ID} { count();
1304 pp_ifdef_var(yyleng, yytext);
1305 state = IFDEF_EOL_S; BEGIN(IFDEF_EOL); }
1306 <IFDEF_EOL>{EAT_ABLE}*{CR} { count(); pp_ifdef(); }
1308 <INITIAL,IFDEF_SKIP>{PREP_START}{ELSE}{EAT_ABLE}*{CR} { count(); pp_else(); }
1310 <INITIAL,IFDEF_SKIP>{PREP_START}{ENDIF}{EAT_ABLE}*{CR} { count();
1313 /* we're in an ifdef that evaluated to false -- throw it away */
1314 <IFDEF_SKIP>.|{CR} { count(); }
1316 /* this is split so the shebangs match more, giving them priority */
1317 <INITIAL>{COM_LINE} { count(); state = LINECOMMENT_S;
1318 BEGIN(LINECOMMENT); }
1319 <LINECOMMENT>.*{CR} { count(); state = INITIAL_S; BEGIN(INITIAL); }
1321 <INITIAL>{ID} { if ((sdef = pp_define_get(yyleng, yytext))!=NULL) {
1322 for (r=sdef->len-1; r>=0; r--)
1323 unput(sdef->s[r]); /* reverse order */
1326 addstr(&s_buf, yytext, yyleng);
1327 yylval.strval=s_buf.s;
1328 memset(&s_buf, 0, sizeof(s_buf));
1332 <INITIAL>{NUM_ID} { count(); addstr(&s_buf, yytext, yyleng);
1333 yylval.strval=s_buf.s;
1334 memset(&s_buf, 0, sizeof(s_buf));
1337 <SELECT>. { unput(yytext[0]); state = INITIAL_S; BEGIN(INITIAL); } /* Rescan the token in INITIAL state */
1339 <INCLF>[ \t]* /* eat the whitespace */
1340 <INCLF>[^ \t\r\n]+ { /* get the include file name */
1341 memset(&s_buf, 0, sizeof(s_buf));
1342 addstr(&s_buf, yytext, yyleng);
1343 r = pp_subst_run(&s_buf.s);
1344 if(sr_push_yy_state(s_buf.s, 0)<0)
1346 LOG(L_CRIT, "error at %s line %d\n", (finame)?finame:"cfg", line);
1349 memset(&s_buf, 0, sizeof(s_buf));
1353 <IMPTF>[ \t]* /* eat the whitespace */
1354 <IMPTF>[^ \t\r\n]+ { /* get the import file name */
1355 memset(&s_buf, 0, sizeof(s_buf));
1356 addstr(&s_buf, yytext, yyleng);
1357 r = pp_subst_run(&s_buf.s);
1358 if(sr_push_yy_state(s_buf.s, 1)<0)
1360 LOG(L_CRIT, "error at %s line %d\n", (finame)?finame:"cfg", line);
1363 memset(&s_buf, 0, sizeof(s_buf));
1373 r = pp_subst_run(&s_buf.s);
1374 yylval.strval=s_buf.s;
1375 memset(&s_buf, 0, sizeof(s_buf));
1378 LOG(L_CRIT, "ERROR: cfg. parser: unexpected EOF in"
1379 " unclosed string\n");
1387 LOG(L_CRIT, "ERROR: cfg. parser: unexpected EOF:"
1388 " %d comments open\n", comment_nest);
1391 LOG(L_CRIT, "ERROR: unexpected EOF:"
1392 "comment line open\n");
1395 LOG(L_CRIT, "ERROR: unexpected EOF"
1402 LOG(L_CRIT, "ERROR: unexpected EOF"
1403 " while parsing pvar name"
1404 " (%d paranthesis open)\n",
1408 LOG(L_CRIT, "ERROR: unexpected EOF"
1410 " avp or pvar name\n");
1412 if(sr_pop_yy_state()<0)
1419 static char* addchar(struct str_buf* dst, char c)
1421 return addstr(dst, &c, 1);
1426 static char* addstr(struct str_buf* dst_b, char* src, int len)
1432 if (dst_b->left<(len+1)){
1433 used=(unsigned)(dst_b->crt-dst_b->s);
1435 /* round up to next multiple */
1436 size+= STR_BUF_ALLOC_UNIT-size%STR_BUF_ALLOC_UNIT;
1437 tmp=pkg_malloc(size);
1438 if (tmp==0) goto error;
1440 memcpy(tmp, dst_b->s, used);
1444 dst_b->crt=dst_b->s+used;
1445 dst_b->left=size-used;
1447 memcpy(dst_b->crt, src, len);
1454 LOG(L_CRIT, "ERROR:lex:addstr: memory allocation error\n");
1455 LOG(L_CRIT, "ERROR:lex:addstr: try to increase pkg size with"
1462 /** helper function for count_*(). */
1463 static void count_lc(int* l, int* c)
1466 for (i=0; i<yyleng;i++){
1467 if (yytext[i]=='\n'){
1470 }else if (yytext[i]=='\t'){
1472 /*(*c)+=8 -((*c)%8);*/
1481 /* helper function */
1482 static void count_restore_ignored()
1484 if (ign_lines) /* ignored line(s) => column has changed */
1487 column+=ign_columns;
1489 ign_lines=ign_columns=0;
1494 /** count/record position for stuff added to the current token. */
1495 static void count_more()
1497 count_restore_ignored();
1498 count_lc(&line, &column);
1503 /** count/record position for a new token. */
1506 count_restore_ignored();
1514 /** record discarded stuff (not contained in the token) so that
1515 the next token position can be adjusted properly*/
1516 static void count_ignore()
1518 count_lc(&ign_lines, &ign_columns);
1522 /* replacement yywrap, removes libfl dependency */
1528 static int sr_push_yy_state(char *fin, int mode)
1530 struct sr_yy_fname *fn = NULL;
1534 #define MAX_INCLUDE_FNAME 128
1535 char fbuf[MAX_INCLUDE_FNAME];
1537 char *tmpfiname = 0;
1539 if ( include_stack_ptr >= MAX_INCLUDE_DEPTH )
1541 LOG(L_CRIT, "too many includes\n");
1545 if(l>=MAX_INCLUDE_FNAME)
1547 LOG(L_CRIT, "included file name too long: %s\n", fin);
1550 if(fin[0]!='"' || fin[l-1]!='"')
1552 LOG(L_CRIT, "included file name must be between quotes: %s\n", fin);
1556 for(i=1; i<l-1; i++)
1562 LOG(L_CRIT, "invalid escape at %d in included file name: %s\n", i, fin);
1586 LOG(L_CRIT, "invalid included file name: %s\n", fin);
1591 fp = fopen(fbuf, "r" );
1595 tmpfiname = (finame==0)?cfg_file:finame;
1596 if(tmpfiname==0 || fbuf[0]=='/')
1600 LOG(L_CRIT, "cannot open included file: %s\n", fin);
1603 LOG(L_DBG, "importing file ignored: %s\n", fin);
1607 x = strrchr(tmpfiname, '/');
1610 /* nothing else to try */
1613 LOG(L_CRIT, "cannot open included file: %s\n", fin);
1616 LOG(L_DBG, "importing file ignored: %s\n", fin);
1621 newf = (char*)pkg_malloc(x-tmpfiname+strlen(fbuf)+2);
1624 LOG(L_CRIT, "no more pkg\n");
1628 strncat(newf, tmpfiname, x-tmpfiname);
1632 fp = fopen(newf, "r" );
1638 LOG(L_CRIT, "cannot open included file: %s (%s)\n", fbuf, newf);
1641 LOG(L_DBG, "importing file ignored: %s (%s)\n", fbuf, newf);
1645 LOG(L_DBG, "including file: %s (%s)\n", fbuf, newf);
1650 include_stack[include_stack_ptr].state = YY_CURRENT_BUFFER;
1651 include_stack[include_stack_ptr].line = line;
1652 include_stack[include_stack_ptr].column = column;
1653 include_stack[include_stack_ptr].startline = startline;
1654 include_stack[include_stack_ptr].startcolumn = startcolumn;
1655 include_stack[include_stack_ptr].finame = finame;
1656 include_stack_ptr++;
1665 /* make a copy in PKG if does not exist */
1666 fn = sr_yy_fname_list;
1669 if(strcmp(fn->fname, newf)==0)
1680 fn = (struct sr_yy_fname*)pkg_malloc(sizeof(struct sr_yy_fname));
1685 LOG(L_CRIT, "no more pkg\n");
1690 fn->fname = (char*)pkg_malloc(strlen(fbuf)+1);
1694 LOG(L_CRIT, "no more pkg!\n");
1697 strcpy(fn->fname, fbuf);
1701 fn->next = sr_yy_fname_list;
1702 sr_yy_fname_list = fn;
1707 yy_switch_to_buffer( yy_create_buffer(yyin, YY_BUF_SIZE ) );
1713 static int sr_pop_yy_state()
1715 include_stack_ptr--;
1716 if (include_stack_ptr<0 )
1719 yy_delete_buffer( YY_CURRENT_BUFFER );
1720 yy_switch_to_buffer(include_stack[include_stack_ptr].state);
1721 line=include_stack[include_stack_ptr].line;
1722 column=include_stack[include_stack_ptr].column;
1723 startline=include_stack[include_stack_ptr].startline;
1724 startcolumn=include_stack[include_stack_ptr].startcolumn;
1725 finame = include_stack[include_stack_ptr].finame;
1729 /* define/ifdef support */
1731 #define MAX_DEFINES 256
1732 static str pp_defines[MAX_DEFINES][2];
1733 static int pp_num_defines = 0;
1734 static int pp_define_type = 0;
1735 static int pp_define_index = -1;
1737 /* pp_ifdef_stack[i] is 1 if the ifdef test at depth i is either
1738 * ifdef(defined), ifndef(undefined), or the opposite of these
1739 * two, but in an else branch
1741 #define MAX_IFDEFS 256
1742 static int pp_ifdef_stack[MAX_IFDEFS];
1743 static int pp_sptr = 0; /* stack pointer */
1745 static int pp_lookup(int len, const char * text)
1747 str var = {(char *)text, len};
1750 for (i=0; i<pp_num_defines; i++)
1751 if (STR_EQ(pp_defines[i][0], var))
1757 int pp_define_set_type(int type)
1759 pp_define_type = type;
1763 int pp_define(int len, const char * text)
1767 LM_DBG("defining id: %.*s\n", len, text);
1769 if (pp_num_defines == MAX_DEFINES) {
1770 LOG(L_CRIT, "ERROR: too many defines -- adjust MAX_DEFINES\n");
1774 pp_define_index = -1;
1775 ppos = pp_lookup(len, text);
1777 if(pp_define_type==1) {
1778 LOG(L_DBG, "ignoring - already defined: %.*s\n", len, text);
1779 pp_define_index = -2;
1781 } else if(pp_define_type==2) {
1782 LOG(L_DBG, "redefining: %.*s\n", len, text);
1783 pp_define_index = ppos;
1784 if(pp_defines[ppos][1].s != NULL) {
1785 pkg_free(pp_defines[ppos][1].s);
1786 pp_defines[ppos][1].len = 0;
1787 pp_defines[ppos][1].s = NULL;
1791 LOG(L_CRIT, "ERROR: already defined: %.*s\n", len, text);
1796 pp_defines[pp_num_defines][0].len = len;
1797 pp_defines[pp_num_defines][0].s = (char*)pkg_malloc(len+1);
1798 if(pp_defines[pp_num_defines][0].s==NULL) {
1799 LOG(L_CRIT, "no more memory to define: %.*s\n", len, text);
1802 memcpy(pp_defines[pp_num_defines][0].s, text, len);
1803 pp_defines[pp_num_defines][1].len = 0;
1804 pp_defines[pp_num_defines][1].s = NULL;
1805 pp_define_index = pp_num_defines;
1811 int pp_define_set(int len, char *text)
1815 if(pp_define_index == -2) {
1816 /* #!trydef that should be ignored */
1820 if(pp_define_index < 0) {
1821 /* invalid position in define table */
1822 LOG(L_BUG, "BUG: the index in define table not set yet\n");
1826 LOG(L_DBG, "no define value - ignoring\n");
1829 if (pp_num_defines == MAX_DEFINES) {
1830 LOG(L_CRIT, "ERROR: too many defines -- adjust MAX_DEFINES\n");
1833 if (pp_num_defines == 0) {
1834 LOG(L_BUG, "BUG: setting define value, but no define id yet\n");
1838 ppos = pp_define_index;
1839 if (pp_defines[ppos][0].s == NULL) {
1840 LOG(L_BUG, "BUG: last define ID is null\n");
1844 if (pp_defines[ppos][1].s != NULL) {
1845 LOG(L_BUG, "BUG: ID %.*s [%d] overwritten\n",
1846 pp_defines[ppos][0].len,
1847 pp_defines[ppos][0].s, ppos);
1851 pp_defines[ppos][1].len = len;
1852 pp_defines[ppos][1].s = text;
1853 LM_DBG("### setting define ID [%.*s] value [%.*s]\n",
1854 pp_defines[ppos][0].len,
1855 pp_defines[ppos][0].s,
1856 pp_defines[ppos][1].len,
1857 pp_defines[ppos][1].s);
1861 static str *pp_define_get(int len, const char * text)
1863 str var = {(char *)text, len};
1866 for (i=0; i<pp_num_defines; i++)
1868 if (STR_EQ(pp_defines[i][0], var))
1870 if(pp_defines[i][0].s!=NULL)
1872 LM_DBG("### returning define ID [%.*s] value [%.*s]\n",
1873 pp_defines[i][0].len,
1875 pp_defines[i][1].len,
1876 pp_defines[i][1].s);
1877 return &pp_defines[i][1];
1885 static int pp_ifdef_type(int type)
1887 if (pp_sptr == MAX_IFDEFS) {
1888 LOG(L_CRIT, "ERROR: too many nested ifdefs -- adjust MAX_IFDEFS\n");
1892 pp_ifdef_stack[pp_sptr] = type;
1896 /* this sets the result of the if[n]def expr:
1897 * ifdef defined -> 1
1898 * ifdef undefined -> 0
1899 * ifndef defined -> 0
1900 * ifndef undefined -> 1
1902 static void pp_ifdef_var(int len, const char * text)
1904 pp_ifdef_stack[pp_sptr] ^= (pp_lookup(len, text) < 0);
1907 static void pp_update_state()
1911 for (i=0; i<pp_sptr; i++)
1912 if (! pp_ifdef_stack[i]) {
1913 state = IFDEF_SKIP_S; BEGIN(IFDEF_SKIP);
1917 state = INITIAL; BEGIN(INITIAL);
1920 static void pp_ifdef()
1926 static void pp_else()
1928 pp_ifdef_stack[pp_sptr-1] ^= 1;
1932 static void pp_endif()