[general]
; General settings for the operation of Yate

; modload: boolean: Should a module be loaded by default if there is no
;  reference to it in the [modules] section
;modload=enable

; modpath: string: Overrides the runtime module directory path which is
;  compiled in or specified with the -m command line option. Note that this
;  setting takes priority over anything else
; Note that you MUST NOT add a path separator at the end
;modpath=

; extrapath: string: Absolute or relative path to an extra modules directory,
;  gets loaded before those added by command line -x parameters
; Note that you MUST NOT add a path separator at the end
;extrapath=

; nodename: string: Name of this node in a cluster
; Defaults to detected machine hostname
;nodename=

: minworkers: int: Minimum / initial number of engine worker threads
; Valid range 1 to 100, default 1
;minworkers=1

; maxworkers: int: Maximum number of worker threads the engine can create
; This parameter is reloadable
; Valid range minworkers to 500, default 10
;maxworkers=10

; addworkers: int: How many workers to create in a batch when needed
; This parameter is reloadable
; Valid range 1 to 10, default 1
;addworkers=1

; semworkers: boolean: Use a timed semaphore to reduce idle CPU usage
; Default true if the software platform supports timed semaphores efficiently
;semworkers=

; maxmsgrate: int: Message rate threshold to declare engine congestion
; This parameter is reloadable
; Valid range 0 to 50000, default 0 (disable message rate check)
;maxmsgrate=0

; maxqueued: int: Message queue size threshold to declare engine congestion
; This parameter is reloadable
; Valid range 0 to 10000, default 0 (disable queue size check)
;maxqueued=0

; maxmsgage: int: Queued message age threshold (in msec) to declare engine congestion
; This parameter is reloadable
; Valid range 0 to 5000, default 0 (disable message age check)
;maxmsgage=0

; maxevents: int: Maximum number of events kept per type
; This parameter is reloadable
; Valid range 0 to 1000, default 25, 0 disables limit
;maxevents=25

; startevents: boolean: Capture all debug events at startup
;startevents=yes

; restarts: int: Time in seconds after startup the engine will try to restart
;  to clean up any accumulating problems. Restarts are performed only when
;  started in supervised mode
; If at restart time at least one of the modules is busy it will try again to
;  restart every 10 seconds
;restarts=0

; timejump: int: Forward system time jump in seconds accepted without restart
; If non-zero and system time jumps backwards or too much forward
;  an alert will be logged and if supervised the engine will restart
; Valid range 8 to 120, 0 disables check (default)
;timejump=0

; warntime: int: Warn time limit for message dispatch in milliseconds, a value
;  of zero disables such warnings
;warntime=0

; idlemsec: int: System idle time in milliseconds
;  Set to zero to use platform default
;  If not set the platform default is doubled only in client mode
;idlemsec=

; wintimer: int: Requested timer resolution in milliseconds (Windows only, does
;  not work on 9x and ME). The default resolution depends on hardware, Windows
;  version and currently running programs
;wintimer=0

; trackparam: string: Name of the parameter used to track message through handlers
;  If empty or boolean true the default "handlers" will be used instead
;  Set to boolean false to disable tracking only if you are sure what you want
;trackparam=handlers

; abortinfo: boolean: Display some engine statistics during a process abort
;abortinfo=enable

; nodeid: int: ID assigned to this node
;  Range 0 - 2^nodebits-1
;nodeid=

; nodebits: int: Length in bits of the node ID
;  Range 0 - 12. 0 means that node ID will be ignored
;nodebits=0

; msgsniff: bool: Activate message sniffer module (if loaded) at engine init time
;msgsniff=disable

; filtersniff: regexp: Default filter to apply to message sniffer at initialization
; If empty it will match all messages except engine.timer which is never displayed
; Example for a filter matching all chan.Anything messages and engine.halt:
;  filtersniff=^\(chan\.\|engine\.halt\)$
;filtersniff=

; agesniff: float: Display only messages whose age or delay is higher than this value
; This is a floating point number in seconds (1.5 means 1500msec)
;agesniff=0

; filtersniffparams: string: Default parameter(s) filter to apply to message sniffer at initialization
; If empty it will not attempt to match message parameters
; Format: [any] [negated] param1=value1 [param2=value2 ...]
; any: message matches if at least one configured parameter matches
; negated: message matches if list does not match
; Value to match is handled as regexp. It may end with '^' to revert match (i.e. matches if regexp don't match)
; Value may be empty. In this case the parameter matches if missing in message or present with empty value
; Example for a filter matching messages with empty route_type or route_type=call
;  filtersniffparams=route_type=^\(call\)\?$
; Example for a filter matching message with caller=123 or called=123
;  filtersniffparams=any caller=^123$ called=^123$
;filtersniffparams=

; msgsniff:<NAME>: string: Add a message sniffer rule
; <NAME> is optional. If missing the rule is handled as the one set using filtersniff/agesniff/filtersniffparams
; This parameter may be repeated with different <NAME> value to add multiple rules
; A rule will replace a previously defined rule with the same name
; Format: [filter=[value]] [age=[value]] [params [any negated] [name=value]]
; Examples:
; msgsniff:=filter=^\(chan\.\) age=0.5 params id=^sip/
; msgsniff:extra=filter=^\(call\.cdr\)$ params any caller=123 called=^2
;msgsniff:<NAME>=

; trace_msg_time: boolean: Instruct message dispatcher to set message event(s) time (enqueue / dispatch)
;trace_msg_time=no

; trace_msg_handler_time: boolean: Enable message dispatcher to trace the time spent by a
;  message handler to process a message
; Add the time in message handlers parameter
; The time will be added to message handler name as #<MSEC>.<USEC>
;trace_msg_handler_time=no

; uri_parse_tel_rfc: boolean/keyword: Set 'tel' uri parse bahavior
; This parameter is handled on engine start only 
; Boolean true: Parse using strict RFC 3966 
; Boolean false: Use old (generic) parse. May fail for some URIs
; Keyword 'local': Parse a failed 'global-number' value as 'local-number'
; Defaults to boolean true if missing or invalid
;uri_parse_tel_rfc=yes


[modules]
; This section should hold one line for each module whose loading behaviour
;  is to be changed from the default specified by modload= in section [general]
; Each line has to be of the form:
;   modulename.yate=boolean
; Note that modules can be located only in the module directory so no path
;  information should be specified


[localsym]
; This section is used to force some modules to be loaded without their
;  symbols being globally available - if the operating system supports.
; Windows will ignore this section completely.
; Each line has to be of the form:
;   modulename.yate=boolean

; pwlib does not clean up properly on Linux so we must disable global symbols
;  unfortunately preventing all pwlib plugins from loading
h323chan.yate=yes


[nounload]
; This section is used to prevent some modules from being unloaded from
;  memory, although finalization will be attempted if possible.
; Each line has to be of the form:
;   modulename.yate=boolean


[preload]
; Put a line in this section for each shared library that you want to load
;  before any Yate module
; Each line has to be of the form:
;   /path/to/the/library.so=boolean
; You should specify the full path to the library. Extension is operating
;  system specific - usually .so for *NIX systems and .dll for Windows


[postload]
; Put a line in this section for each shared library that you want to load
;  after all Yate modules
; Each line has to be of the form:
;   /path/to/the/library.so=boolean
; You should specify the full path to the library. Extension is operating
;  system specific - usually .so for *NIX systems and .dll for Windows


[debug]
; Each line in this section generates an engine.debug message immediately
;  after the first initialization. This is equivalent of issuing the debug
;  command in the Remote Manager.
; Each line has to be of the form:
;  modulename=parameters to debug
; Examples:
;  tone=off
;  h323=level 9
;  sip=level 8
;  sip=filter 127.0.0.1


[run_params]
; Extra runtime parameters to add to the Engine at startup
; It is not possible to overwrite existing parameters, only add new ones
; These parameters are only loaded once at startup
; Use the 'runparam' command to add more later
; Examples:
;  temppath=/tmp
;  remote_ip=10.1.2.3


[variables]
; Each line in this section initializes a variable in the Engine's shared list
; These variables can be accessed and modified from each module
; Examples:
;  index1=5
;  custom=EXAMPLE


[telephony]
; Default settings for telephony drivers

; timeout: int: Default channel timeout in milliseconds
;timeout=0

; maxroute: int: Maximum number of calls routed at once by each driver
;maxroute=0

; maxchans: int: Maximum number of channels running at once in each driver
;maxchans=0

; dtmfdups: bool: Allow duplicate DTMFs (detected with different methods)
;dtmfdups=disable


[configuration]
; Options for Configuration files
; These parameters are handled on first load only (repeated parameters are ignored)
; This section should be the first handled section if you need to apply parameters on this file also

; max_depth: integer: Maximum file include depth
; Allowed interval: 3..50 if recursive check is enabled, 3..10 otherwise
;max_depth=10 if recursive check is enabled, 3 otherwise

; disable_include_silent: boolean: Disable silent include in Configuration files
; The '$includesilent' directives of configuration file will be handled as '$include' if this
;  parameter is set to boolean true
; Same applies for '$includesectionsilent': handled as '$includesection'
;disable_include_silent=no

; check_recursive_include: boolean: Enable or disable recursive include of configuration files
;check_recursive_include=yes

; include_empty: boolean: Handle configuration file include when value is empty (configurared
;  value or after replacing running parameters)
; E.g. [$include ${some_param}] will evaluate to empty if 'some_param' is not in engine'r running
;  parameters list or its value is empty
; NOTE: Empty value include all configuration files in directory of current file (including itself)
;include_empty=no

; warnings: boolean: Enable various warnings on configuration file load
;warnings=yes
