|
Home page |
Mailing list |
Docs
Last updated: Sat Feb 3 05:00:56 2007
Asterisk developer's documentation :: Codename Pineapple
sip3_config.c
Go to the documentation of this file.
00001 /* 00002 * Asterisk -- An open source telephony toolkit. 00003 * 00004 * Copyright (C) 1999 - 2007, Digium, Inc. 00005 * and Edvina AB, Sollentuna, Sweden (chan_sip3 changes/additions) 00006 * 00007 * Mark Spencer <markster@digium.com> 00008 * 00009 * See http://www.asterisk.org for more information about 00010 * the Asterisk project. Please do not directly contact 00011 * any of the maintainers of this project for assistance; 00012 * the project provides a web site, mailing lists and IRC 00013 * channels for your use. 00014 * 00015 * This program is free software, distributed under the terms of 00016 * the GNU General Public License Version 2. See the LICENSE file 00017 * at the top of the source tree. 00018 */ 00019 00020 /*! 00021 * \file 00022 * \brief Various SIP configuration functions 00023 * Version 3 of chan_sip 00024 * 00025 * \author Mark Spencer <markster@digium.com> 00026 * \author Olle E. Johansson <oej@edvina.net> (all the chan_sip3 changes) 00027 * 00028 * See Also: 00029 * \arg \ref AstCREDITS 00030 * 00031 */ 00032 00033 #include "asterisk.h" 00034 00035 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 53128 $") 00036 00037 #include <stdio.h> 00038 #include <ctype.h> 00039 #include <string.h> 00040 #include <unistd.h> 00041 #include <sys/socket.h> 00042 #include <sys/ioctl.h> 00043 #include <net/if.h> 00044 #include <errno.h> 00045 #include <stdlib.h> 00046 #include <fcntl.h> 00047 #include <netdb.h> 00048 #include <signal.h> 00049 #include <sys/signal.h> 00050 #include <netinet/in.h> 00051 #include <netinet/in_systm.h> 00052 #include <arpa/inet.h> 00053 #include <netinet/ip.h> 00054 #include <regex.h> 00055 00056 #include "asterisk/channel.h" 00057 #include "asterisk/cli.h" 00058 #include "asterisk/config.h" 00059 #include "asterisk/logger.h" 00060 #include "asterisk/module.h" 00061 #include "asterisk/pbx.h" 00062 #include "asterisk/options.h" 00063 #include "asterisk/lock.h" 00064 #include "asterisk/acl.h" 00065 #include "asterisk/callerid.h" 00066 #include "asterisk/musiconhold.h" 00067 #include "asterisk/manager.h" 00068 #include "asterisk/dsp.h" 00069 #include "asterisk/rtp.h" 00070 #include "asterisk/srv.h" 00071 #include "asterisk/causes.h" 00072 #include "asterisk/utils.h" 00073 #include "asterisk/file.h" 00074 #include "asterisk/astobj.h" 00075 #include "asterisk/dnsmgr.h" 00076 #include "asterisk/linkedlists.h" 00077 #include "asterisk/stringfields.h" 00078 #include "asterisk/monitor.h" 00079 #include "asterisk/localtime.h" 00080 #include "asterisk/compiler.h" 00081 #include "asterisk/version.h" 00082 #include "sip3.h" 00083 #include "sip3funcs.h" 00084 00085 static const char config[] = "sip3.conf"; 00086 const char notify_config[] = "sip3_notify.conf"; 00087 00088 /*! \brief The configuration matrix */ 00089 /* SIP_CONFOBJ_GENERAL General section 00090 SIP_CONFOBJ_PHONE Phone options 00091 SIP_CONFOBJ_SERVICE Service options 00092 SIP_CONFOBJ_TRUNK Trunk options 00093 SIP_CONFOBJ_DOMAIN Configurations valid for domains 00094 SIP_CONFOBJ_LINE Phone, service and trunk (macro) 00095 */ 00096 static struct sip_config_struct sip_config[] = { 00097 { SIP_CONF_NONE, SIP_CONFCAT_MISC, "", 0, 00098 ""}, /*!< Unknown */ 00099 00100 { SIP_CONF_TYPE, SIP_CONFCAT_MISC, "type", SIP_CONFOBJ_LINE, 00101 "Declares object type: phone, trunk, service or domain"}, 00102 00103 { SIP_CONF_AUTOCREATEPEER, SIP_CONFCAT_MISC, "autocreatepeer" , SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_DOMAIN, 00104 "Enable this to support automatic creation of peers at registration time" }, 00105 00106 { SIP_CONF_VMAILBOX, SIP_CONFCAT_MISC, "mailbox" , SIP_CONFOBJ_PHONE, 00107 "One or multiple voicemail box identifiers, separated by &. Used for MWI messages. Syntax \"vmbox@vmcontext\"."}, 00108 00109 { SIP_CONF_VMEXTEN, SIP_CONFCAT_MISC, "vmexten", SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_PHONE | SIP_CONFOBJ_DOMAIN, 00110 "Voicemailbox callback number that reach voicemailmain() in the dialplan"}, 00111 00112 { SIP_CONF_DEFCONTEXT, SIP_CONFCAT_MISC, "context" , SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00113 "Default context for incoming calls."}, 00114 00115 { SIP_CONF_SUBSCRIBECONTEXT, SIP_CONFCAT_MISC, "subscribecontext", SIP_CONFOBJ_PHONE , 00116 "Context to use for subscriptions from this device."}, 00117 00118 { SIP_CONF_CALLERID, SIP_CONFCAT_MISC, "callerid" , SIP_CONFOBJ_PHONE , 00119 "Caller ID number and name. Syntax: \'Firstname Lastname <extension>\'"}, 00120 00121 { SIP_CONF_CALLERPRES, SIP_CONFCAT_MISC, "callerpres" , SIP_CONFOBJ_PHONE | SIP_CONFOBJ_TRUNK, 00122 "Caller ID presentation flags."}, 00123 00124 { SIP_CONF_CDR_ACCOUNTCODE, SIP_CONFCAT_LINE, "accountcode" , SIP_CONFOBJ_PHONE | SIP_CONFOBJ_TRUNK, 00125 "CDR accountcode for calls on this trunk or from this device."}, 00126 00127 { SIP_CONF_SECRET, SIP_CONFCAT_LINE, "secret" , SIP_CONFOBJ_PHONE | SIP_CONFOBJ_TRUNK, 00128 "Authentication secret for inbound transactions."}, 00129 00130 { SIP_CONF_REALM, SIP_CONFCAT_MISC, "realm" , SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_DOMAIN, 00131 "Authentication REALM for digest authentication" }, 00132 00133 { SIP_CONF_USERAGENT, SIP_CONFCAT_MISC, "useragent" , SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_DOMAIN, 00134 "Useragent for this PBX. Defaults to \"Asterisk <version>\"" }, 00135 00136 { SIP_CONF_MD5SECRET, SIP_CONFCAT_LINE, "md5secret", SIP_CONFOBJ_PHONE, 00137 "MD5 authentication string for authentication. Based on md5(username:realm:secret)"}, 00138 00139 { SIP_CONF_ACCSECRET, SIP_CONFCAT_MISC, "accountsecret", SIP_CONFOBJ_SERVICE, 00140 "Our secret for authentication to service"}, 00141 00142 { SIP_CONF_CHANVAR, SIP_CONFCAT_LINE, "chanvar" , SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00143 "Dialplan channel variables set for incoming calls."}, 00144 00145 { SIP_CONF_PERMIT, SIP_CONFCAT_NETWORK, "permit" , SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00146 "ACL: IP address access control - access allowed for this IP range"}, 00147 00148 { SIP_CONF_DENY, SIP_CONFCAT_NETWORK, "deny", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00149 "ACL: IP address access control - access denied for this IP range"}, 00150 00151 { SIP_CONF_CALLGROUP, SIP_CONFCAT_LINE, "callgroup" , SIP_CONFOBJ_PHONE | SIP_CONFOBJ_DOMAIN, 00152 "Groups calls to this device belong to, for pickup (See pickupgroup) 0-63"}, 00153 00154 { SIP_CONF_PICKUPGROUP, SIP_CONFCAT_LINE, "pickupgroup" , SIP_CONFOBJ_PHONE | SIP_CONFOBJ_DOMAIN, 00155 "Groups this device can pickup calls in. (See callgroup) 0-63"}, 00156 00157 { SIP_CONF_GROUPVAR, SIP_CONFCAT_LINE, "changroup" , SIP_CONFOBJ_PHONE | SIP_CONFOBJ_TRUNK | SIP_CONFOBJ_SERVICE | SIP_CONFOBJ_DOMAIN , 00158 "Channel group for calls from a device."}, 00159 00160 { SIP_CONF_BINDADDR, SIP_CONFCAT_NETWORK, "bindaddr", SIP_CONFOBJ_GENERAL, 00161 "IP Address to bind SIP channel to"}, 00162 00163 { SIP_CONF_BINDPORT, SIP_CONFCAT_NETWORK, "bindport", SIP_CONFOBJ_GENERAL, 00164 "IP Port to bind SIP channel to"}, 00165 00166 { SIP_CONF_AUTH, SIP_CONFCAT_LINE, "auth", SIP_CONFOBJ_PHONE | SIP_CONFOBJ_SERVICE | SIP_CONFOBJ_DOMAIN | SIP_CONFOBJ_SERVICE , 00167 "Realm based digest authentication. Syntax: \"auth = <username>:<secret>@<Realm>\""}, 00168 00169 { SIP_CONF_SIPDEBUG, SIP_CONFCAT_MISC, "sipdebug", SIP_CONFOBJ_GENERAL, 00170 "Enable SIP debugging by default"}, 00171 00172 { SIP_CONF_SIPDEBUGLEVEL, SIP_CONFCAT_MISC, "sipdebuglevel", SIP_CONFOBJ_GENERAL, 00173 "What to show in SIP debugging (ALL, CALLS, NO-OPTIONS"}, 00174 00175 { SIP_CONF_HISTORYDUMP, SIP_CONFCAT_MISC, "dumphistory", SIP_CONFOBJ_GENERAL, 00176 "Dump SIP history at end of call to DEBUG channel"}, 00177 00178 { SIP_CONF_HISTORYRECORD, SIP_CONFCAT_MISC, "siphistory", SIP_CONFOBJ_GENERAL, 00179 "Enable logging of SIP history for each dialog."}, 00180 00181 { SIP_CONF_TRUSTRPID, SIP_CONFCAT_LINE, "trustrpid", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00182 "Use information in remote-party-id headers from this device or trunk"}, 00183 00184 { SIP_CONF_SENDRPID, SIP_CONFCAT_LINE, "sendrpid", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN , 00185 "Send Remote-Party-ID headers on calls to this device or trunk."}, 00186 00187 { SIP_CONF_G726NONSTANDARD, SIP_CONFCAT_MISC, "g726nonstandard", SIP_CONFOBJ_GENERAL , 00188 ""}, 00189 00190 { SIP_CONF_USECLIENTCODE, SIP_CONFCAT_MISC, "useclientcode", SIP_CONFOBJ_PHONE | SIP_CONFOBJ_DOMAIN, 00191 "Support for client code header on SNOM phones"}, 00192 00193 { SIP_CONF_DTMFMODE, SIP_CONFCAT_MISC, "dtmfmode", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN | SIP_CONFOBJ_GENERAL, 00194 "DTMF mode used for calls with this device (info, rfc2833, inband, auto)"}, 00195 00196 { SIP_CONF_NAT, SIP_CONFCAT_NAT, "nat", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN | SIP_CONFOBJ_GENERAL , 00197 "Nat support configuration"}, 00198 00199 { SIP_CONF_CANREINVITE, SIP_CONFCAT_NAT, "canreinvite", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN | SIP_CONFOBJ_GENERAL , 00200 "Whether this object supports SIP re-invites"}, 00201 00202 { SIP_CONF_INSECURE, SIP_CONFCAT_MISC, "insecure", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN | SIP_CONFOBJ_GENERAL , 00203 ""}, /*! \todo Needs to go */ 00204 00205 { SIP_CONF_PROGRESSINBAND, SIP_CONFCAT_SIGNAL, "progressinband", SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN , 00206 ""}, 00207 00208 { SIP_CONF_PROMISCREDIR, SIP_CONFCAT_MISC, "promiscredir", SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN , 00209 ""}, 00210 00211 { SIP_CONF_VIDEOSUPPORT, SIP_CONFCAT_MISC, "videosupport", SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN , 00212 ""}, 00213 00214 { SIP_CONF_ALLOWGUEST, SIP_CONFCAT_SIGNAL, "allowguest", SIP_CONFOBJ_GENERAL , 00215 ""}, 00216 { SIP_CONF_ALLOWOVERLAP, SIP_CONFCAT_SIGNAL, "allowoverlap", SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00217 ""}, 00218 { SIP_CONF_ALLOWSUBSCRIBE, SIP_CONFCAT_SIGNAL, "allowsubscribe", SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00219 ""}, 00220 { SIP_CONF_ALLOWTRANSFER, SIP_CONFCAT_SIGNAL, "allowtransfer", SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00221 ""}, 00222 { SIP_CONF_ALLOWEXTERNALDOMAINS, SIP_CONFCAT_SIGNAL, "allowexternaldomains", SIP_CONFOBJ_GENERAL , 00223 ""}, 00224 { SIP_CONF_T38PT_UDPTL, SIP_CONFCAT_MISC, "t38pt_udptl", SIP_CONFOBJ_PHONE | SIP_CONFOBJ_SERVICE | SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_DOMAIN , 00225 ""}, 00226 { SIP_CONF_T38PT_TCP, SIP_CONFCAT_MISC, "t38pt_tcp", SIP_CONFOBJ_NONE , 00227 ""}, 00228 { SIP_CONF_T38PT_RTP, SIP_CONFCAT_MISC, "t38pt_rtp", SIP_CONFOBJ_NONE , 00229 ""}, 00230 { SIP_CONF_RFC2833COMPENSATE, SIP_CONFCAT_MISC, "rfc2833compensate", SIP_CONFOBJ_LINE | SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, "RTP DTMF compensation (yes/no)"}, 00231 { SIP_CONF_DOMAIN, SIP_CONFCAT_MISC, "domain", SIP_CONFOBJ_PHONE | SIP_CONFOBJ_SERVICE | SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_DOMAIN , 00232 ""}, 00233 { SIP_CONF_AUTHUSER, SIP_CONFCAT_MISC, "authuser", SIP_CONFOBJ_SERVICE , 00234 ""}, /* User to use for authentication */ 00235 { SIP_CONF_CID_NAME, SIP_CONFCAT_MISC, "cid_name", SIP_CONFOBJ_PHONE , 00236 ""}, 00237 { SIP_CONF_CID_NUMBER, SIP_CONFCAT_MISC, "cid_number", SIP_CONFOBJ_PHONE , 00238 ""}, 00239 { SIP_CONF_USEREQPHONE, SIP_CONFCAT_MISC, "usereqphone", SIP_CONFOBJ_ALL , 00240 ""}, 00241 { SIP_CONF_FROMDOMAIN, SIP_CONFCAT_MISC, "fromdomain", SIP_CONFOBJ_SERVICE, 00242 "Domain part of From: SIP URI for connections to service"}, 00243 { SIP_CONF_FROMUSER, SIP_CONFCAT_MISC, "fromuser", SIP_CONFOBJ_SERVICE, 00244 "User part of From: SIP URI for connections to service"}, 00245 { SIP_CONF_HOST, SIP_CONFCAT_MISC, "host", SIP_CONFOBJ_PHONE | SIP_CONFOBJ_TRUNK, 00246 "Domain name, host name or IP address of remote host. \"dynamic\" if phone registers with us."}, 00247 { SIP_CONF_REGISTRAR, SIP_CONFCAT_MISC, "registrar", SIP_CONFOBJ_SERVICE, 00248 "Registrar proxy server for service"}, 00249 { SIP_CONF_PROXY, SIP_CONFCAT_MISC, "proxy", SIP_CONFOBJ_SERVICE | SIP_CONFOBJ_TRUNK, 00250 "Proxy server for service"}, 00251 { SIP_CONF_OUTBOUNDPROXY, SIP_CONFCAT_MISC, "outboundproxy", SIP_CONFOBJ_SERVICE | SIP_CONFOBJ_TRUNK, 00252 "Outbound proxy"}, 00253 { SIP_CONF_DEFAULTIP, SIP_CONFCAT_MISC, "defaultip", SIP_CONFOBJ_PHONE, 00254 "Default host name or IP address of phone that is not registred"}, 00255 { SIP_CONF_DEFAULTUSER, SIP_CONFCAT_MISC, "defaultuser", SIP_CONFOBJ_PHONE, 00256 "Default user name part of URI to contact not registred device"}, 00257 { SIP_CONF_DEFAULTPORT, SIP_CONFCAT_MISC, "defaultport", SIP_CONFOBJ_PHONE, 00258 "Port address to contact not registered device"}, 00259 { SIP_CONF_PROXYPORT, SIP_CONFCAT_MISC, "proxyport", SIP_CONFOBJ_SERVICE | SIP_CONFOBJ_TRUNK, 00260 "Proxy port address (disables DNS SRV)"}, 00261 { SIP_CONF_REGISTRARPORT, SIP_CONFCAT_MISC, "registrarport", SIP_CONFOBJ_SERVICE | SIP_CONFOBJ_TRUNK, 00262 "Registrar proxy port address"}, 00263 { SIP_CONF_OBPROXYPORT, SIP_CONFCAT_MISC, "outboundproxyport", SIP_CONFOBJ_SERVICE | SIP_CONFOBJ_TRUNK, 00264 "Outbound proxy port address"}, 00265 { SIP_CONF_LANGUAGE, SIP_CONFCAT_MISC, "language", SIP_CONFOBJ_PHONE | SIP_CONFOBJ_TRUNK | SIP_CONFOBJ_SERVICE | SIP_CONFOBJ_DOMAIN, 00266 "Default language for prompts"}, 00267 { SIP_CONF_REGEXTEN, SIP_CONFCAT_MISC, "regexten", SIP_CONFOBJ_PHONE, 00268 "Enable extension at registration from device" }, 00269 { SIP_CONF_REGCONTEXT, SIP_CONFCAT_MISC, "regcontext", SIP_CONFOBJ_GENERAL, 00270 "Context for regexten= extensions" }, 00271 { SIP_CONF_CALL_LIMIT, SIP_CONFCAT_MISC, "call-limit", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00272 "Call limit for device or trunk line"}, 00273 { SIP_CONF_CALL_LIMIT, SIP_CONFCAT_MISC, "call_limit", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00274 "Call limit for device or trunk line"}, 00275 { SIP_CONF_CDR_AMAFLAGS, SIP_CONFCAT_MISC, "amaflags", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00276 "CDR AMA flags for incoming calls"}, 00277 { SIP_CONF_CDR_ACCOUNTCODE, SIP_CONFCAT_MISC, "accountcode", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00278 "CDR accountcode for incoming calls"}, 00279 { SIP_CONF_MOHINTERPRET, SIP_CONFCAT_MISC, "mohinterpret", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00280 ""}, 00281 { SIP_CONF_MOHSUGGEST, SIP_CONFCAT_MISC, "mohsuggest", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00282 ""}, 00283 { SIP_CONF_MWISUBSCRIBE, SIP_CONFCAT_MISC, "subscribemwi", SIP_CONFOBJ_PHONE | SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_DOMAIN, 00284 ""}, 00285 { SIP_CONF_MWICHECK, SIP_CONFCAT_MISC, "checkmwi", SIP_CONFOBJ_GENERAL, 00286 ""}, 00287 00288 { SIP_CONF_DISALLOW, SIP_CONFCAT_MISC, "disallow", SIP_CONFOBJ_LINE | SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_DOMAIN, 00289 ""}, 00290 00291 { SIP_CONF_ALLOW, SIP_CONFCAT_MISC, "allow", SIP_CONFOBJ_LINE | SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_DOMAIN, 00292 ""}, 00293 00294 { SIP_CONF_AUTOFRAMING, SIP_CONFCAT_MISC, "autoframing", SIP_CONFOBJ_ALL, 00295 ""}, 00296 00297 { SIP_CONF_RTPTIMEOUT, SIP_CONFCAT_MISC, "rtptimeout", SIP_CONFOBJ_ALL, 00298 ""}, 00299 00300 { SIP_CONF_RTPHOLDTIMEOUT, SIP_CONFCAT_MISC, "rtpholdtimeout", SIP_CONFOBJ_ALL, 00301 ""}, 00302 00303 { SIP_CONF_RTPKEEPALIVE, SIP_CONFCAT_MISC, "rtpkeepalive", SIP_CONFOBJ_ALL, 00304 "NAT support: Send RTP keepalives"}, 00305 00306 { SIP_CONF_SETVAR, SIP_CONFCAT_MISC, "setvar", SIP_CONFOBJ_LINE | SIP_CONFOBJ_DOMAIN, 00307 "Configure channel variables to be set in channels created by the phone or on this trunk"}, 00308 00309 { SIP_CONF_QUALIFY, SIP_CONFCAT_MISC, "qualify", SIP_CONFOBJ_LINE | SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_DOMAIN, 00310 ""}, 00311 00312 { SIP_CONF_MAXCALLBITRATE, SIP_CONFCAT_MISC, "maxcallbitrate", SIP_CONFOBJ_ALL, 00313 "Maximum bitrate for call (kbps), default 384"}, 00314 00315 { SIP_CONF_REGISTER, SIP_CONFCAT_MISC, "register", SIP_CONFOBJ_GENERAL | SIP_CONFOBJ_SERVICE, 00316 ""}, /* ??? NEEDED ANY MORE */ 00317 00318 { SIP_CONF_RT_CACHEFRIENDS, SIP_CONFCAT_REALTIME, "rtcachefriends", SIP_CONFOBJ_GENERAL, 00319 "Realtime - cache realtime friends in memory"}, 00320 00321 { SIP_CONF_RTSAVESYSTEMNAME, SIP_CONFCAT_REALTIME, "rtsavesysname", SIP_CONFOBJ_GENERAL, 00322 "Realtime - save system name in database at registration"}, 00323 00324 { SIP_CONF_RTUPDATE, SIP_CONFCAT_REALTIME, "rtupdate", SIP_CONFOBJ_GENERAL, 00325 "Realtime - update database at registration"}, 00326 00327 { SIP_CONF_IGNOREREGEXPIRE, SIP_CONFCAT_REALTIME, "ignoreregexpire", SIP_CONFOBJ_GENERAL, 00328 ""}, 00329 { SIP_CONF_RTAUTOCLEAR, SIP_CONFCAT_REALTIME, "rtautoclear", SIP_CONFOBJ_GENERAL, 00330 ""}, 00331 { SIP_CONF_MAXFORWARDS, SIP_CONFCAT_MISC, "maxforwards", SIP_CONFOBJ_GENERAL, 00332 ""}, 00333 { SIP_CONF_T1MIN, SIP_CONFCAT_MISC, "t1min", SIP_CONFOBJ_GENERAL, 00334 ""}, 00335 { SIP_CONF_T1DEFAULT, SIP_CONFCAT_MISC, "t1default", SIP_CONFOBJ_GENERAL, 00336 "SIP Timer T1 - roundtrip time for packets. Used in calculations for retransmits."}, 00337 { SIP_CONF_T2DEFAULT, SIP_CONFCAT_MISC, "t2default", SIP_CONFOBJ_GENERAL, 00338 "SIP Timer T2 - retransmit intervals for non-INIVTE requests"}, 00339 { SIP_CONF_T4DEFAULT, SIP_CONFCAT_MISC, "t4default", SIP_CONFOBJ_GENERAL, 00340 "SIP Timer T4 - maximum time for handling NON-invite retransmits"}, 00341 { SIP_CONF_TIMER_B, SIP_CONFCAT_MISC, "siptimer_b", SIP_CONFOBJ_GENERAL, 00342 "SIP Timer B - timeout for INVITE transactions" }, 00343 { SIP_CONF_TIMER_F, SIP_CONFCAT_MISC, "siptimer_f", SIP_CONFOBJ_GENERAL, 00344 "SIP Timer F - timeout for non-INVITE transactions" }, 00345 { SIP_CONF_RELAXDTMF, SIP_CONFCAT_MISC, "relaxdtmf", SIP_CONFOBJ_GENERAL, 00346 ""}, 00347 { SIP_CONF_COMPACTHEADERS, SIP_CONFCAT_MISC, "compactheaders", SIP_CONFOBJ_LINE | SIP_CONFOBJ_GENERAL, 00348 ""}, 00349 { SIP_CONF_NOTIFYRINGING, SIP_CONFCAT_MISC, "notifyringing", SIP_CONFOBJ_GENERAL, 00350 ""}, 00351 { SIP_CONF_NOTIFYHOLD, SIP_CONFCAT_MISC, "notifymime", SIP_CONFOBJ_GENERAL, 00352 ""}, 00353 { SIP_CONF_NOTIFYHOLD, SIP_CONFCAT_MISC, "notifyhold", SIP_CONFOBJ_GENERAL, 00354 ""}, 00355 { SIP_CONF_CALLEVENTS, SIP_CONFCAT_MISC, "callevents", SIP_CONFOBJ_GENERAL, 00356 ""}, 00357 { SIP_CONF_ALWAYSAUTHREJECT, SIP_CONFCAT_MISC, "alwaysauthreject", SIP_CONFOBJ_GENERAL, 00358 ""}, 00359 { SIP_CONF_SRVLOOKUP, SIP_CONFCAT_MISC, "srvlookup", SIP_CONFOBJ_GENERAL, 00360 ""}, 00361 { SIP_CONF_EXPIRYMAX, SIP_CONFCAT_MISC, "maxexpiry", SIP_CONFOBJ_GENERAL, 00362 ""}, 00363 { SIP_CONF_EXPIRYMIN, SIP_CONFCAT_MISC, "minexpiry", SIP_CONFOBJ_GENERAL, 00364 ""}, 00365 { SIP_CONF_EXPIRYDEFAULT, SIP_CONFCAT_MISC, "defaultexpiry", SIP_CONFOBJ_GENERAL, 00366 ""}, 00367 { SIP_CONF_REGISTERTIMEOUT, SIP_CONFCAT_MISC, "registertimeout", SIP_CONFOBJ_GENERAL, 00368 ""}, 00369 { SIP_CONF_REGISTERATTEMPTS, SIP_CONFCAT_MISC, "registerattempts", SIP_CONFOBJ_GENERAL, 00370 ""}, 00371 { SIP_CONF_LOCALNET, SIP_CONFCAT_NAT, "localnet", SIP_CONFOBJ_GENERAL, 00372 ""}, 00373 { SIP_CONF_EXTERNIP, SIP_CONFCAT_NAT, "externip", SIP_CONFOBJ_GENERAL, 00374 ""}, 00375 { SIP_CONF_EXTERNPORT, SIP_CONFCAT_NAT, "externport", SIP_CONFOBJ_GENERAL, 00376 ""}, 00377 { SIP_CONF_EXTERNHOST, SIP_CONFCAT_NAT, "externhost", SIP_CONFOBJ_GENERAL, 00378 ""}, 00379 { SIP_CONF_EXTERNREFRESH, SIP_CONFCAT_NAT, "externrefresh", SIP_CONFOBJ_GENERAL, 00380 ""}, 00381 { SIP_CONF_AUTODOMAIN, SIP_CONFCAT_MISC, "autodomain", SIP_CONFOBJ_GENERAL, 00382 ""}, 00383 { SIP_CONF_TOS_SIP, SIP_CONFCAT_MISC, "tos_sip", SIP_CONFOBJ_GENERAL, 00384 ""}, 00385 { SIP_CONF_TOS_AUDIO, SIP_CONFCAT_MISC, "tos_audio", SIP_CONFOBJ_GENERAL, 00386 ""}, 00387 { SIP_CONF_TOS_VIDEO, SIP_CONFCAT_MISC, "tos_video", SIP_CONFOBJ_GENERAL, 00388 ""}, 00389 { SIP_CONF_TOS_PRESENSE, SIP_CONFCAT_MISC, "tos_presense", SIP_CONFOBJ_GENERAL, 00390 ""}, 00391 { SIP_CONF_QUALIFY_TIMER_OK, SIP_CONFCAT_MISC, "qualify_timer_ok", SIP_CONFOBJ_GENERAL, 00392 ""}, 00393 { SIP_CONF_QUALIFY_TIMER_NOT_OK, SIP_CONFCAT_MISC, "qualify_timer_not_ok", SIP_CONFOBJ_GENERAL, 00394 ""}, 00395 { SIP_CONF_RTFULLCONTACT, SIP_CONFCAT_REALTIME, "fullcontact", SIP_CONFOBJ_PHONE, 00396 ""}, 00397 { SIP_CONF_RTREGSECONDS, SIP_CONFCAT_REALTIME, "regseconds ", SIP_CONFOBJ_PHONE, 00398 ""}, /* Only realtime */ 00399 { SIP_CONF_RTNAME, SIP_CONFCAT_REALTIME, "name", SIP_CONFOBJ_PHONE, 00400 ""}, 00401 { SIP_CONF_JBENABLE, SIP_CONFCAT_JB, "jbenable", SIP_CONFOBJ_GENERAL, 00402 ""}, 00403 { SIP_CONF_JBFORCE, SIP_CONFCAT_JB, "jbforce", SIP_CONFOBJ_GENERAL, 00404 ""}, 00405 { SIP_CONF_JBMAXSIZE, SIP_CONFCAT_JB, "jbmaxsize", SIP_CONFOBJ_GENERAL, 00406 ""}, 00407 { SIP_CONF_JBRESYNC, SIP_CONFCAT_JB, "jbresynchtreshold", SIP_CONFOBJ_GENERAL, 00408 ""}, 00409 { SIP_CONF_JBIMPL, SIP_CONFCAT_JB, "jbimpl", SIP_CONFOBJ_GENERAL, 00410 ""}, 00411 { SIP_CONF_JBLOG, SIP_CONFCAT_JB, "jblog", SIP_CONFOBJ_GENERAL, 00412 ""}, 00413 }; 00414 00415 /*! \brief Global jitterbuffer configuration - by default, jb is disabled */ 00416 static struct ast_jb_conf default_jbconf = 00417 { 00418 .flags = 0, 00419 .max_size = -1, 00420 .resync_threshold = -1, 00421 .impl = "" 00422 }; 00423 00424 /*! \brief Remove reference for device. When we reach 0, device is removed from memory */ 00425 void device_unref(struct sip_device *device) 00426 { 00427 if (!device) 00428 return; 00429 00430 if (option_debug > 3 && sipdebug) 00431 ast_log(LOG_DEBUG, "/// Removing reference from device %s - refcount now %d\n", device->name, device->refcount - 1); 00432 ASTOBJ_UNREF(device, sip_destroy_device); 00433 } 00434 00435 /*! \brief Add reference for device. */ 00436 struct sip_device *device_ref(struct sip_device *device) 00437 { 00438 ASTOBJ_REF(device); 00439 if (option_debug > 3 && sipdebug) 00440 ast_log(LOG_DEBUG, "/// Adding reference to device %s - refcount now %d\n", device->name, device->refcount); 00441 return device; 00442 } 00443 00444 /*! \brief Parse configuration file label, check if it's valid in this 00445 object context and return label */ 00446 static enum sip_config_options sip_config_parse(char *label, enum sip_config_objects object) 00447 { 00448 int x; 00449 if (option_debug > 4) 00450 ast_log(LOG_DEBUG, "--Checking for configuration option: %s\n", label); 00451 00452 00453 for (x = 0; x < (sizeof(sip_config) / sizeof(struct sip_config_struct)); x++) { 00454 if (!strcasecmp(sip_config[x].label, label)) { 00455 if (sip_config[x].valid & object) { 00456 if (option_debug > 4) 00457 ast_log(LOG_DEBUG, "--Found valid configuration option: %s\n", label); 00458 return sip_config[x].option; 00459 } else 00460 return SIP_CONF_NOT_VALID_FOR_OBJECT; 00461 } 00462 }; 00463 return SIP_CONF_NOT_FOUND; 00464 } 00465 00466 /*! \brief * implement the servar config line */ 00467 static struct ast_variable *add_var(const char *buf, struct ast_variable *list) 00468 { 00469 struct ast_variable *tmpvar = NULL; 00470 char *varname = ast_strdupa(buf), *varval = NULL; 00471 00472 if ((varval = strchr(varname,'='))) { 00473 *varval++ = '\0'; 00474 if ((tmpvar = ast_variable_new(varname, varval))) { 00475 tmpvar->next = list; 00476 list = tmpvar; 00477 } 00478 } 00479 return list; 00480 } 00481 /*! \brief Destroy disused contexts between reloads 00482 Only used in reload_config so the code for regcontext doesn't get ugly 00483 */ 00484 static void cleanup_stale_contexts(char *new, char *old) 00485 { 00486 char *oldcontext, *newcontext, *stalecontext, *stringp, newlist[AST_MAX_CONTEXT]; 00487 00488 while ((oldcontext = strsep(&old, "&"))) { 00489 stalecontext = '\0'; 00490 ast_copy_string(newlist, new, sizeof(newlist)); 00491 stringp = newlist; 00492 while ((newcontext = strsep(&stringp, "&"))) { 00493 if (strcmp(newcontext, oldcontext) == 0) { 00494 /* This is not the context you're looking for */ 00495 stalecontext = '\0'; 00496 break; 00497 } else if (strcmp(newcontext, oldcontext)) { 00498 stalecontext = oldcontext; 00499 } 00500 00501 } 00502 if (stalecontext) 00503 ast_context_destroy(ast_context_find(stalecontext), "SIP"); 00504 } 00505 } 00506 00507 /*! 00508 \brief Handle flag-type options common to configuration of devices - users and peers 00509 \param flags array of two struct ast_flags 00510 \param mask array of two struct ast_flags 00511 \param v linked list of config variables to process 00512 \returns non-zero if any config options were handled, zero otherwise 00513 */ 00514 static int handle_common_options(enum sip_config_options option, struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v) 00515 { 00516 int error = 0; /* Number of errors */ 00517 00518 switch (option) { 00519 case SIP_CONF_TRUSTRPID: 00520 ast_set_flag(&mask[0], SIP_TRUSTRPID); 00521 ast_set2_flag(&flags[0], ast_true(v->value), SIP_TRUSTRPID); 00522 break; 00523 case SIP_CONF_SENDRPID: 00524 ast_set_flag(&mask[0], SIP_SENDRPID); 00525 ast_set2_flag(&flags[0], ast_true(v->value), SIP_SENDRPID); 00526 break; 00527 case SIP_CONF_G726NONSTANDARD: 00528 ast_set_flag(&mask[0], SIP_G726_NONSTANDARD); 00529 ast_set2_flag(&flags[0], ast_true(v->value), SIP_G726_NONSTANDARD); 00530 break; 00531 case SIP_CONF_USECLIENTCODE: 00532 ast_set_flag(&mask[0], SIP_USECLIENTCODE); 00533 ast_set2_flag(&flags[0], ast_true(v->value), SIP_USECLIENTCODE); 00534 break; 00535 case SIP_CONF_DTMFMODE: 00536 ast_set_flag(&mask[0], SIP_DTMF); 00537 ast_clear_flag(&flags[0], SIP_DTMF); 00538 if (!strcasecmp(v->value, "inband")) 00539 ast_set_flag(&flags[0], SIP_DTMF_INBAND); 00540 else if (!strcasecmp(v->value, "rfc2833")) 00541 ast_set_flag(&flags[0], SIP_DTMF_RFC2833); 00542 else if (!strcasecmp(v->value, "info")) 00543 ast_set_flag(&flags[0], SIP_DTMF_INFO); 00544 else if (!strcasecmp(v->value, "auto")) 00545 ast_set_flag(&flags[0], SIP_DTMF_AUTO); 00546 else { 00547 ast_log(LOG_WARNING, "Unknown dtmf mode '%s' on line %d, using rfc2833\n", v->value, v->lineno); 00548 error++; 00549 ast_set_flag(&flags[0], SIP_DTMF_RFC2833); 00550 } 00551 break; 00552 case SIP_CONF_NAT: 00553 ast_set_flag(&mask[0], SIP_NAT); 00554 ast_clear_flag(&flags[0], SIP_NAT); 00555 if (!strcasecmp(v->value, "never")) 00556 ast_set_flag(&flags[0], SIP_NAT_NEVER); 00557 else if (!strcasecmp(v->value, "route")) 00558 ast_set_flag(&flags[0], SIP_NAT_ROUTE); 00559 else if (ast_true(v->value)) 00560 ast_set_flag(&flags[0], SIP_NAT_ALWAYS); 00561 else 00562 ast_set_flag(&flags[0], SIP_NAT_RFC3581); 00563 break; 00564 case SIP_CONF_CANREINVITE: 00565 ast_set_flag(&mask[0], SIP_REINVITE); 00566 ast_clear_flag(&flags[0], SIP_REINVITE); 00567 if (ast_true(v->value)) { 00568 ast_set_flag(&flags[0], SIP_CAN_REINVITE | SIP_CAN_REINVITE_NAT); 00569 } else if (!ast_false(v->value)) { 00570 char buf[64]; 00571 char *word, *next = buf; 00572 00573 ast_copy_string(buf, v->value, sizeof(buf)); 00574 while ((word = strsep(&next, ","))) { 00575 if (!strcasecmp(word, "update")) { 00576 ast_set_flag(&flags[0], SIP_REINVITE_UPDATE | SIP_CAN_REINVITE); 00577 } else if (!strcasecmp(word, "nonat")) { 00578 ast_set_flag(&flags[0], SIP_CAN_REINVITE); 00579 ast_clear_flag(&flags[0], SIP_CAN_REINVITE_NAT); 00580 } else { 00581 ast_log(LOG_WARNING, "Unknown canreinvite mode '%s' on line %d\n", v->value, v->lineno); 00582 error++; 00583 } 00584 } 00585 } 00586 break; 00587 case SIP_CONF_INSECURE: 00588 ast_set_flag(&mask[0], SIP_INSECURE_PORT | SIP_INSECURE_INVITE); 00589 ast_clear_flag(&flags[0], SIP_INSECURE_PORT | SIP_INSECURE_INVITE); 00590 if (!ast_false(v->value)) { 00591 char buf[64]; 00592 char *word, *next; 00593 00594 ast_copy_string(buf, v->value, sizeof(buf)); 00595 next = buf; 00596 while ((word = strsep(&next, ","))) { 00597 if (!strcasecmp(word, "port")) 00598 ast_set_flag(&flags[0], SIP_INSECURE_PORT); 00599 else if (!strcasecmp(word, "invite")) 00600 ast_set_flag(&flags[0], SIP_INSECURE_INVITE); 00601 else 00602 ast_log(LOG_WARNING, "Unknown insecure mode '%s' on line %d\n", v->value, v->lineno); 00603 error++; 00604 } 00605 } 00606 break; 00607 case SIP_CONF_PROGRESSINBAND: 00608 ast_set_flag(&mask[0], SIP_PROG_INBAND); 00609 ast_clear_flag(&flags[0], SIP_PROG_INBAND); 00610 if (ast_true(v->value)) 00611 ast_set_flag(&flags[0], SIP_PROG_INBAND_YES); 00612 else if (strcasecmp(v->value, "never")) 00613 ast_set_flag(&flags[0], SIP_PROG_INBAND_NO); 00614 break; 00615 case SIP_CONF_COMPACTHEADERS: 00616 ast_set_flag(&mask[1], SIP_PAGE2_COMPACTHEADERS); 00617 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_COMPACTHEADERS); 00618 break; 00619 case SIP_CONF_PROMISCREDIR: 00620 ast_set_flag(&mask[0], SIP_PROMISCREDIR); 00621 ast_set2_flag(&flags[0], ast_true(v->value), SIP_PROMISCREDIR); 00622 break; 00623 case SIP_CONF_VIDEOSUPPORT: 00624 ast_set_flag(&mask[1], SIP_PAGE2_VIDEOSUPPORT); 00625 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_VIDEOSUPPORT); 00626 break; 00627 case SIP_CONF_ALLOWOVERLAP: 00628 ast_set_flag(&mask[1], SIP_PAGE2_ALLOWOVERLAP); 00629 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_ALLOWOVERLAP); 00630 break; 00631 case SIP_CONF_ALLOWSUBSCRIBE: 00632 ast_set_flag(&mask[1], SIP_PAGE2_ALLOWSUBSCRIBE); 00633 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_ALLOWSUBSCRIBE); 00634 break; 00635 case SIP_CONF_T38PT_UDPTL: 00636 ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_UDPTL); 00637 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_UDPTL); 00638 break; 00639 case SIP_CONF_T38PT_RTP: 00640 ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_RTP); 00641 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_RTP); 00642 break; 00643 case SIP_CONF_T38PT_TCP: 00644 ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_TCP); 00645 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_TCP); 00646 break; 00647 case SIP_CONF_RFC2833COMPENSATE: 00648 ast_set_flag(&mask[1], SIP_PAGE2_RFC2833_COMPENSATE); 00649 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_RFC2833_COMPENSATE); 00650 break; 00651 default: 00652 /* We should not come here, unless it's a source code error. 00653 Makes the compiler happy to have a default, since 00654 we're basing the case on an enum. 00655 */ 00656 break; 00657 } 00658 00659 return error; 00660 } 00661 00662 /*! \brief Set peer defaults before configuring specific configurations */ 00663 void set_device_defaults(struct sip_device *device) 00664 { 00665 if (device->expire == 0) { 00666 /* Don't reset expire or port time during reload 00667 if we have an active registration 00668 */ 00669 device->expire = -1; 00670 device->pokeexpire = -1; 00671 device->addr.sin_port = htons(STANDARD_SIP_PORT); 00672 } 00673 ast_copy_flags(&device->flags[0], &global.flags[0], SIP_FLAGS_TO_COPY); 00674 ast_copy_flags(&device->flags[1], &global.flags[1], SIP_PAGE2_FLAGS_TO_COPY); 00675 00676 ast_string_field_set(&device->extra, context, global.default_context); 00677 ast_string_field_set(&device->extra, subscribecontext, global.default_subscribecontext); 00678 strcpy(device->language, global.default_language); 00679 strcpy(device->extra.mohinterpret, global.default_mohinterpret); 00680 strcpy(device->extra.mohsuggest, global.default_mohsuggest); 00681 device->addr.sin_family = AF_INET; 00682 device->defaddr.sin_family = AF_INET; 00683 device->capability = global.capability; 00684 device->rtptimer.rtptimeout = global.rtptimer.rtptimeout; 00685 device->rtptimer.rtpholdtimeout = global.rtptimer.rtpholdtimeout; 00686 device->rtptimer.rtpkeepalive = global.rtptimer.rtpkeepalive; 00687 device->maxcallbitrate = global.default_maxcallbitrate; 00688 ast_string_field_set(device, secret, ""); 00689 ast_string_field_set(device, md5secret, ""); 00690 ast_string_field_set(device, extra.fromdomain, ""); 00691 ast_string_field_set(device, extra.fromuser, ""); 00692 ast_string_field_set(device, extra.regexten, ""); 00693 device->extra.cid_num[0] = '\0'; 00694 device->extra.cid_name[0] = '\0'; 00695 device->callgroup = 0; 00696 device->pickupgroup = 0; 00697 device->allowtransfer = global.allowtransfer; 00698 device->maxms = global.default_qualify; 00699 device->prefs = global.default_prefs; 00700 ast_string_field_set(device, mailbox.vmexten, global.default_vmexten); 00701 ast_string_field_set(device, mailbox.mailbox, ""); 00702 } 00703 00704 /*! \brief Set Caller ID for phone or service */ 00705 static void set_device_cid(struct sip_device *device, enum sip_config_options option, struct ast_variable *v) 00706 { 00707 switch (option) { 00708 case SIP_CONF_CID_NAME: 00709 ast_copy_string(device->extra.cid_name, v->value, sizeof(device->extra.cid_name)); 00710 break; 00711 case SIP_CONF_CID_NUMBER: 00712 ast_copy_string(device->extra.cid_num, v->value, sizeof(device->extra.cid_num)); 00713 break; 00714 default: 00715 ast_callerid_split(v->value, device->extra.cid_name, sizeof(device->extra.cid_name), device->extra.cid_num, sizeof(device->extra.cid_num)); 00716 break; 00717 } 00718 } 00719 00720 /*! \brief Configure Host= setting for device */ 00721 static void set_device_host(struct sip_device *device, struct ast_variable *v, int found, enum sip_config_objects object) 00722 { 00723 00724 if (option_debug > 4) 00725 ast_log(LOG_DEBUG, "--Configuring device %s - Host config value %s\n", device->name, v->value); 00726 if (object == SIP_CONFOBJ_PHONE && !strcasecmp(v->value, "dynamic")) { 00727 if (option_debug > 4) 00728 ast_log(LOG_DEBUG, "--Dynamic host enabled (sip device registering with us)\n"); 00729 /* They'll register with us */ 00730 ast_set_flag(&device->flags[1], SIP_PAGE2_DYNAMIC); 00731 if (!found) { 00732 /* Initialize stuff if we're not found, otherwise we keep going with what we had */ 00733 memset(&device->addr.sin_addr, 0, 4); 00734 if (device->addr.sin_port) { 00735 /* If we've already got a port, make it the default rather than absolute */ 00736 device->defaddr.sin_port = device->addr.sin_port; 00737 device->addr.sin_port = 0; 00738 } 00739 } 00740 } else { 00741 /* Non-dynamic. Make sure we become that way if we're not */ 00742 if (device->expire > -1) 00743 ast_sched_del(sched, device->expire); 00744 device->expire = -1; 00745 ast_clear_flag(&device->flags[1], SIP_PAGE2_DYNAMIC); 00746 ast_copy_string(device->extra.tohost, v->value, sizeof(device->extra.tohost)); 00747 if (!device->addr.sin_port) 00748 device->addr.sin_port = htons(STANDARD_SIP_PORT); 00749 } 00750 } 00751 00752 /*! \brief Add ACL entry (permit/deny) to device */ 00753 static int set_device_acl(struct sip_device *device, struct ast_variable *v) 00754 { 00755 int ha_error = 0; 00756 00757 device->ha = ast_append_ha(v->name, v->value, device->ha, &ha_error); 00758 return ha_error; 00759 } 00760 00761 00762 /*! \brief Build peer from configuration (file or realtime static/dynamic) */ 00763 static struct sip_device *build_device(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime) 00764 { 00765 struct sip_device *device = NULL; 00766 struct ast_ha *oldha = NULL; 00767 int found = 0; 00768 int firstpass = 1; 00769 int format = 0; /* Ama flags */ 00770 time_t regseconds = 0; 00771 struct ast_flags peerflags[2] = {{(0)}}; 00772 struct ast_flags mask[2] = {{(0)}}; 00773 int register_lineno = 0; 00774 int error = 0; 00775 00776 if (!realtime) 00777 /* Note we do NOT use find_peer here, to avoid realtime recursion */ 00778 /* We also use a case-sensitive comparison (unlike find_peer) so 00779 that case changes made to the peer name will be properly handled 00780 during reload 00781 */ 00782 device = ASTOBJ_CONTAINER_FIND_UNLINK_FULL(&devicelist, name, name, 0, 0, strcmp); 00783 00784 if (device) { 00785 /* Already in the list, remove it and it will be added back (or FREE'd) */ 00786 found++; 00787 if (!(device->objflags & ASTOBJ_FLAG_MARKED)) 00788 firstpass = 0; 00789 } else { 00790 if (!(device = ast_calloc(1, sizeof(*device)))) 00791 return NULL; 00792 00793 if (ast_string_field_init(device, 512)) { /* Initialize string field buffer */ 00794 free(device); 00795 return NULL; 00796 } 00797 if (ast_string_field_init(&device->mailbox, 512)) { /* Initialize string field buffer */ 00798 free(device); 00799 return NULL; 00800 } 00801 if (ast_string_field_init(&device->extra, 512)) { /* Initialize string field buffer */ 00802 free(device); 00803 return NULL; 00804 } 00805 00806 if (realtime) 00807 sipcounters.realtime_peers++; 00808 else 00809 sipcounters.static_peers++; 00810 ASTOBJ_INIT(device); 00811 } 00812 device->type &= SIP_PEER; 00813 00814 /* Note that our peer HAS had its reference count incrased */ 00815 00816 if (firstpass) { 00817 device->mailbox.lastmsgssent = -1; 00818 oldha = device->ha; 00819 device->ha = NULL; 00820 set_device_defaults(device); /* Set peer defaults */ 00821 } 00822 if (!found && name) 00823 ast_copy_string(device->name, name, sizeof(device->name)); 00824 00825 /* If we have channel variables, remove them (reload) */ 00826 if (device->chanvars) { 00827 ast_variables_destroy(device->chanvars); 00828 device->chanvars = NULL; 00829 /* XXX should unregister ? */ 00830 } 00831 for (; v || ((v = alt) && !(alt=NULL)); v = v->next) { 00832 enum sip_config_options option = sip_config_parse(v->name, SIP_CONFOBJ_PHONE); 00833 switch (option) { 00834 case SIP_CONF_TYPE: 00835 /* Ignore this, it's already parsed */ 00836 break; 00837 case SIP_CONF_TRUSTRPID: 00838 case SIP_CONF_SENDRPID: 00839 case SIP_CONF_G726NONSTANDARD: 00840 case SIP_CONF_USECLIENTCODE: 00841 case SIP_CONF_DTMFMODE: 00842 case SIP_CONF_NAT: 00843 case SIP_CONF_CANREINVITE: 00844 case SIP_CONF_INSECURE: 00845 case SIP_CONF_PROGRESSINBAND: 00846 case SIP_CONF_PROMISCREDIR: 00847 case SIP_CONF_VIDEOSUPPORT: 00848 case SIP_CONF_ALLOWOVERLAP: 00849 case SIP_CONF_ALLOWSUBSCRIBE: 00850 case SIP_CONF_T38PT_UDPTL: 00851 case SIP_CONF_RFC2833COMPENSATE: 00852 case SIP_CONF_COMPACTHEADERS: 00853 error += handle_common_options(option, &peerflags[0], &mask[0], v); 00854 break; 00855 case SIP_CONF_ALLOW: 00856 error += ast_parse_allow_disallow(&device->prefs, &device->capability, v->value, 1); 00857 break; 00858 case SIP_CONF_ALLOWTRANSFER: 00859 device->allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED; 00860 break; 00861 case SIP_CONF_AUTH: 00862 device->auth = add_realm_authentication(device->auth, v->value, v->lineno); 00863 break; 00864 case SIP_CONF_AUTHUSER: 00865 ast_string_field_set(device, authuser, v->value); 00866 break; 00867 case SIP_CONF_AUTOFRAMING: 00868 device->autoframing = ast_true(v->value); 00869 break; 00870 case SIP_CONF_CALLERID: 00871 case SIP_CONF_CID_NAME: 00872 case SIP_CONF_CID_NUMBER: 00873 set_device_cid(device, option, v); 00874 break; 00875 case SIP_CONF_CALLERPRES: 00876 device->callingpres = ast_parse_caller_presentation(v->value); 00877 if (device->callingpres == -1) 00878 device->callingpres = atoi(v->value); 00879 break; 00880 case SIP_CONF_CALLGROUP: 00881 device->callgroup = ast_get_group(v->value); 00882 break; 00883 case SIP_CONF_CALL_LIMIT: 00884 device->call_limit = atoi(v->value); 00885 if (device->call_limit < 0) 00886 device->call_limit = 0; 00887 break; 00888 case SIP_CONF_CDR_ACCOUNTCODE: 00889 ast_copy_string(device->extra.accountcode, v->value, sizeof(device->extra.accountcode)); 00890 break; 00891 case SIP_CONF_CDR_AMAFLAGS: 00892 format = ast_cdr_amaflags2int(v->value); 00893 if (format < 0) { 00894 ast_log(LOG_WARNING, "Invalid AMA Flags for peer: %s at line %d\n", v->value, v->lineno); 00895 error++; 00896 } else 00897 device->extra.amaflags = format; 00898 break; 00899 case SIP_CONF_CHANVAR: 00900 break; 00901 case SIP_CONF_DEFAULTIP: 00902 if (ast_get_ip(&device->defaddr, v->value)) { 00903 ast_log(LOG_WARNING, "Default IP ignored, bad/unparseable value: %s\n", v->value); 00904 error++; 00905 } 00906 break; 00907 case SIP_CONF_DEFAULTUSER: 00908 ast_string_field_set(device, defaultuser, v->value); 00909 break; 00910 case SIP_CONF_DEFAULTPORT: 00911 device->defaddr.sin_port = htons(atoi(v->value)); 00912 break; 00913 case SIP_CONF_DEFCONTEXT: 00914 ast_string_field_set(&device->extra, context, v->value); 00915 break; 00916 case SIP_CONF_DENY: 00917 if(set_device_acl(device, v) != 0) { 00918 ast_log(LOG_WARNING, "Bad DENY setting in sip.conf line %d : %s\n", v->lineno, v->value); 00919 error++; 00920 } 00921 break; 00922 case SIP_CONF_DISALLOW: 00923 error += ast_parse_allow_disallow(&device->prefs, &device->capability, v->value, FALSE); 00924 break; 00925 case SIP_CONF_DOMAIN: 00926 ast_copy_string(device->domain, v->value, sizeof(device->domain)); 00927 break; 00928 case SIP_CONF_GROUPDESC: 00929 break; 00930 case SIP_CONF_GROUPVAR: 00931 break; 00932 case SIP_CONF_HOST: 00933 set_device_host(device, v, found, SIP_CONFOBJ_PHONE); 00934 break; 00935 case SIP_CONF_LANGUAGE: 00936 ast_copy_string(device->language, v->value, sizeof(device->language)); 00937 break; 00938 case SIP_CONF_LOCALNET: 00939 break; 00940 case SIP_CONF_MAXCALLBITRATE: 00941 device->maxcallbitrate = atoi(v->value); 00942 if (device->maxcallbitrate < 0) { 00943 device->maxcallbitrate = global.default_maxcallbitrate; 00944 ast_log(LOG_WARNING, "Max call bitrate setting of device '%s' out of bonds (line %d)\n", device->name, v->lineno); 00945 error++; 00946 } 00947 break; 00948 case SIP_CONF_EXPIRYMAX: 00949 break; 00950 case SIP_CONF_MD5SECRET: 00951 ast_string_field_set(device, md5secret, v->value); 00952 break; 00953 case SIP_CONF_MOHINTERPRET: 00954 ast_copy_string(device->extra.mohinterpret, v->value, sizeof(device->extra.mohinterpret)); 00955 break; 00956 case SIP_CONF_MOHSUGGEST: 00957 ast_copy_string(device->extra.mohsuggest, v->value, sizeof(device->extra.mohsuggest)); 00958 break; 00959 case SIP_CONF_OUTBOUNDPROXY: 00960 break; 00961 case SIP_CONF_OBPROXYPORT: 00962 break; 00963 case SIP_CONF_PERMIT: 00964 if(set_device_acl(device, v) != 0) { 00965 ast_log(LOG_WARNING, "Bad PERMIT setting in sip.conf line %d : %s\n", v->lineno, v->value); 00966 error++; 00967 } 00968 break; 00969 case SIP_CONF_PICKUPGROUP: 00970 device->pickupgroup = ast_get_group(v->value); 00971 break; 00972 case SIP_CONF_PORT: 00973 device->addr.sin_port = htons(atoi(v->value)); 00974 break; 00975 case SIP_CONF_PROXY: 00976 break; 00977 case SIP_CONF_PROXYPORT: 00978 break; 00979 case SIP_CONF_QUALIFY: 00980 if (!strcasecmp(v->value, "no")) { 00981 device->maxms = 0; 00982 } else if (!strcasecmp(v->value, "yes")) { 00983 device->maxms = DEFAULT_QUALIFY_MAXMS; 00984 } else if (sscanf(v->value, "%d", &device->maxms) != 1) { 00985 ast_log(LOG_WARNING, "Qualification of device '%s' should be 'yes', 'no', or a number of milliseconds at line %d of sip.conf\n", device->name, v->lineno); 00986 error++; 00987 device->maxms = 0; 00988 } 00989 break; 00990 case SIP_CONF_REGEXTEN: 00991 ast_string_field_set(device, extra.regexten, v->value); 00992 break; 00993 case SIP_CONF_REGISTER: 00994 if (ast_true(v->value)) { 00995 if (realtime) { 00996 ast_log(LOG_ERROR, "register=yes is not supported for realtime.\n"); 00997 } else { 00998 ast_set_flag(&device->flags[1], SIP_PAGE2_SERVICE); 00999 register_lineno = v->lineno; 01000 } 01001 } else if (!ast_false(v->value)) { 01002 ast_log(LOG_ERROR, "Bad value for register= in line %d, device %s\n", v->lineno, device->name); 01003 error++; 01004 } 01005 break; 01006 case SIP_CONF_REGISTERTIMEOUT: 01007 break; 01008 case SIP_CONF_RTAUTOCLEAR: 01009 break; 01010 case SIP_CONF_IGNOREREGEXPIRE: 01011 break; 01012 case SIP_CONF_RTIPADDR: /* Realtime only */ 01013 if(realtime && !ast_strlen_zero(v->value)) 01014 inet_aton(v->value, &(device->addr.sin_addr)); 01015 break; 01016 case SIP_CONF_RTNAME: /* Realtime only */ 01017 if(realtime && !ast_strlen_zero(v->value)) 01018 ast_copy_string(device->name, v->value, sizeof(device->name)); 01019 break; 01020 case SIP_CONF_RTREGSECONDS: /* REALTIME */ 01021 ast_get_time_t(v->value, ®seconds, 0, NULL); 01022 break; 01023 case SIP_CONF_RTPHOLDTIMEOUT: 01024 if ((sscanf(v->value, "%d", &device->rtptimer.rtpholdtimeout) != 1) || (device->rtptimer.rtpholdtimeout < 0)) { 01025 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno); 01026 device->rtptimer.rtpholdtimeout = global.rtptimer.rtpholdtimeout; 01027 error++; 01028 } 01029 break; 01030 case SIP_CONF_RTPKEEPALIVE: 01031 if ((sscanf(v->value, "%d", &device->rtptimer.rtpkeepalive) != 1) || (device->rtptimer.rtpkeepalive < 0)) { 01032 ast_log(LOG_WARNING, "'%s' is not a valid RTP keepalive time at line %d. Using default.\n", v->value, v->lineno); 01033 device->rtptimer.rtpkeepalive = global.rtptimer.rtpkeepalive; 01034 error++; 01035 } 01036 break; 01037 case SIP_CONF_RTFULLCONTACT: /* Realtime only */ 01038 if (realtime) { 01039 ast_string_field_set(device, fullcontact, v->value); 01040 ast_set_flag(&device->flags[1], SIP_PAGE2_RT_FROMCONTACT); 01041 } else { 01042 ast_log(LOG_WARNING, "'%s' is not a valid configuration option (line %d, device %s).\n", v->value, v->lineno, device->name); 01043 error++; 01044 } 01045 break; 01046 case SIP_CONF_RTPTIMEOUT: 01047 if ((sscanf(v->value, "%d", &device->rtptimer.rtptimeout) != 1) || (device->rtptimer.rtptimeout < 0)) { 01048 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno); 01049 error++; 01050 device->rtptimer.rtptimeout = global.rtptimer.rtptimeout; 01051 } 01052 break; 01053 case SIP_CONF_SECRET: 01054 ast_string_field_set(device, secret, v->value); 01055 break; 01056 case SIP_CONF_SETVAR: 01057 device->chanvars = add_var(v->value, device->chanvars); 01058 break; 01059 case SIP_CONF_SUBSCRIBECONTEXT: 01060 ast_string_field_set(&device->extra, subscribecontext, v->value); 01061 break; 01062 case SIP_CONF_MWISUBSCRIBE: 01063 ast_set2_flag(&device->flags[1], ast_true(v->value), SIP_PAGE2_SUBSCRIBEMWIONLY); 01064 break; 01065 case SIP_CONF_T1MIN: 01066 break; 01067 case SIP_CONF_T1DEFAULT: 01068 break; 01069 case SIP_CONF_USEREQPHONE: 01070 ast_set2_flag(&device->flags[0], ast_true(v->value), SIP_USEREQPHONE); 01071 break; 01072 case SIP_CONF_VMAILBOX: 01073 ast_string_field_set(device, mailbox.mailbox, v->value); 01074 sipcounters.peers_with_mwi++; 01075 break; 01076 case SIP_CONF_VMEXTEN: 01077 ast_string_field_set(device, mailbox.vmexten, v->value); 01078 break; 01079 case SIP_CONF_NONE: 01080 case SIP_CONF_NOT_VALID_FOR_OBJECT: 01081 case SIP_CONF_NOT_FOUND: 01082 ast_log(LOG_ERROR, "Bad configuration entry in line %d: %s = %s\n", v->lineno, v->name, v->value); 01083 error++; 01084 break; 01085 default: 01086 ast_log(LOG_ERROR, "This error message should not happen. Bad config error: %d\n", option); 01087 break; 01088 } 01089 01090 /*--------------------- 01091 SERVICE CONFIGS 01092 } else if (!strcasecmp(v->name, "fromdomain")) { 01093 ast_string_field_set(device, extra.fromdomain, v->value); 01094 //ast_copy_string(device->fromdomain, v->value, sizeof(device->fromdomain)); 01095 } else if (!strcasecmp(v->name, "fromuser")) { 01096 ast_string_field_set(device, extra.fromuser, v->value); 01097 //ast_copy_string(device->fromuser, v->value, sizeof(device->fromuser)); 01098 ----------*/ 01099 } 01100 if (error) 01101 ast_log(LOG_WARNING, "Errors found in phone config: %s = %d\n", device->name, error); 01102 01103 /* Set flags from handle_common_options */ 01104 ast_copy_flags(&device->flags[0], &peerflags[0], mask[0].flags); 01105 ast_copy_flags(&device->flags[1], &peerflags[1], mask[1].flags); 01106 01107 /* If not realtime and dynamic - check if we have a current registration */ 01108 if (!found && ast_test_flag(&device->flags[1], SIP_PAGE2_DYNAMIC) && !ast_test_flag(&device->flags[0], SIP_REALTIME)) 01109 reg_source_db(device); 01110 01111 01112 /* If dynamic and realtime, check registration expiry - it might have 01113 expired already */ 01114 if (!ast_test_flag(&global.flags[1], SIP_PAGE2_IGNOREREGEXPIRE) && ast_test_flag(&device->flags[1], SIP_PAGE2_DYNAMIC) && realtime) { 01115 time_t nowtime = time(NULL); 01116 01117 if ((nowtime - regseconds) > 0) { 01118 destroy_association(device); 01119 memset(&device->addr, 0, sizeof(device->addr)); 01120 if (option_debug) 01121 ast_log(LOG_DEBUG, "Bah, we're expired (%d/%d/%d)!\n", (int)(nowtime - regseconds), (int)regseconds, (int)nowtime); 01122 } 01123 } 01124 01125 /* If we have an allowsubscribe, enable it */ 01126 if (ast_test_flag(&device->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE)) 01127 global.allowsubscribe = TRUE; /* No global ban any more */ 01128 01129 ASTOBJ_UNMARK(device); 01130 /* Delete the old ACL list */ 01131 ast_free_ha(oldha); 01132 01133 /* Start registration if needed */ 01134 if (ast_test_flag(&device->flags[1], SIP_PAGE2_SERVICE)) { 01135 sip_register(NULL, register_lineno, device); /* XXX How do we handle this at reload?? */ 01136 } else if (device->registry) { 01137 /* We have a registry entry for a peer that no longer wished to be registered */ 01138 ASTOBJ_UNREF(device->registry,sip_registry_destroy); 01139 device->registry = NULL; 01140 } 01141 return device; 01142 } 01143 01144 /*! \brief realtime_peer: Get peer from realtime storage 01145 * Checks the "sippeers" realtime family from extconfig.conf 01146 * \todo Consider adding check of port address when matching here to follow the same 01147 * algorithm as for static peers. Will we break anything by adding that? 01148 */ 01149 struct sip_device *realtime_peer(const char *newpeername, struct sockaddr_in *sin) 01150 { 01151 struct sip_device *peer; 01152 struct ast_variable *var = NULL; 01153 struct ast_variable *tmp; 01154 char ipaddr[INET_ADDRSTRLEN]; 01155 01156 /* First check on peer name */ 01157 if (newpeername) 01158 var = ast_load_realtime("sippeers", "name", newpeername, NULL); 01159 else if (sin) { /* Then check on IP address for dynamic peers */ 01160 ast_copy_string(ipaddr, ast_inet_ntoa(sin->sin_addr), sizeof(ipaddr)); 01161 var = ast_load_realtime("sippeers", "host", ipaddr, NULL); /* First check for fixed IP hosts */ 01162 if (!var) 01163 var = ast_load_realtime("sippeers", "ipaddr", ipaddr, NULL); /* Then check for registred hosts */ 01164 } 01165 01166 if (!var) 01167 return NULL; 01168 01169 for (tmp = var; tmp; tmp = tmp->next) { 01170 /* If this is type=user, then skip this object. */ 01171 if (!strcasecmp(tmp->name, "type") && 01172 !strcasecmp(tmp->value, "user")) { 01173 ast_variables_destroy(var); 01174 return NULL; 01175 } else if (!newpeername && !strcasecmp(tmp->name, "name")) { 01176 newpeername = tmp->value; 01177 } 01178 } 01179 01180 if (!newpeername) { /* Did not find peer in realtime */ 01181 ast_log(LOG_WARNING, "Cannot Determine peer name ip=%s\n", ipaddr); 01182 ast_variables_destroy(var); 01183 return NULL; 01184 } 01185 01186 /* Peer found in realtime, now build it in memory */ 01187 peer = build_device(newpeername, var, NULL, !ast_test_flag(&global.flags[1], SIP_PAGE2_RTCACHEFRIENDS)); 01188 if (!peer) { 01189 ast_variables_destroy(var); 01190 return NULL; 01191 } 01192 01193 if (ast_test_flag(&global.flags[1], SIP_PAGE2_RTCACHEFRIENDS)) { 01194 /* Cache peer */ 01195 ast_copy_flags(&peer->flags[1],&global.flags[1], SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS); 01196 if (ast_test_flag(&global.flags[1], SIP_PAGE2_RTAUTOCLEAR)) { 01197 if (peer->expire > -1) { 01198 ast_sched_del(sched, peer->expire); 01199 } 01200 peer->expire = ast_sched_add(sched, (global.rtautoclear) * 1000, expire_register, (void *)peer); 01201 } 01202 ASTOBJ_CONTAINER_LINK(&devicelist,peer); 01203 } else { 01204 ast_set_flag(&peer->flags[0], SIP_REALTIME); 01205 } 01206 ast_variables_destroy(var); 01207 01208 return peer; 01209 } 01210 01211 /*! \brief Reset settings of global settings structure */ 01212 static void reset_global_settings(struct sip_globals *global) 01213 { 01214 ast_clear_flag(&global->flags[0], AST_FLAGS_ALL); 01215 ast_clear_flag(&global->flags[1], AST_FLAGS_ALL); 01216 memset(&global->default_prefs, 0 , sizeof(global->default_prefs)); 01217 global->srvlookup = TRUE; 01218 /*! \brief Codecs that we support by default: */ 01219 global->capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263; 01220 //global->dtmf_capability = AST_RTP_DTMF; 01221 /*!< This is default: NO MMR and JBIG trancoding, NO fill bit removal, transferredTCF TCF, UDP FEC, Version 0 and 9600 max fax rate */ 01222 global->t38_capability = T38FAX_VERSION_0 | T38FAX_RATE_2400 | T38FAX_RATE_4800 | T38FAX_RATE_7200 | T38FAX_RATE_9600; 01223 01224 global->maxforwards = DEFAULT_MAX_FORWARDS; 01225 global->tos_sip = DEFAULT_TOS_SIP; 01226 global->tos_audio = DEFAULT_TOS_AUDIO; 01227 global->tos_video = DEFAULT_TOS_VIDEO; 01228 global->tos_presense = DEFAULT_TOS_SIP; /* Initialize to SIP type of service */ 01229 global->allow_external_domains = DEFAULT_ALLOW_EXT_DOM; /* Allow external invites */ 01230 global->regcontext[0] = '\0'; 01231 global->notifyringing = DEFAULT_NOTIFYRINGING; 01232 global->alwaysauthreject = 0; 01233 global->allowsubscribe = FALSE; 01234 snprintf(global->useragent, sizeof(global->useragent), "%s %s", DEFAULT_USERAGENT, ASTERISK_VERSION); 01235 ast_copy_string(global->default_notifymime, DEFAULT_NOTIFYMIME, sizeof(global->default_notifymime)); 01236 if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) 01237 ast_copy_string(global->realm, DEFAULT_REALM, sizeof(global->realm)); 01238 else 01239 ast_copy_string(global->realm, ast_config_AST_SYSTEM_NAME, sizeof(global->realm)); 01240 ast_copy_string(global->default_callerid, DEFAULT_CALLERID, sizeof(global->default_callerid)); 01241 global->compactheaders = DEFAULT_COMPACTHEADERS; 01242 global->reg_timeout = DEFAULT_REGISTRATION_TIMEOUT; 01243 global->regattempts_max = 0; 01244 global->mwitime = DEFAULT_MWITIME; 01245 global->autocreatepeer = DEFAULT_AUTOCREATEPEER; 01246 global->allowguest = DEFAULT_ALLOWGUEST; 01247 global->rtptimer.rtptimeout = 0; 01248 global->rtptimer.rtpholdtimeout = 0; 01249 global->rtptimer.rtpkeepalive = 0; 01250 global->autoframing = 0; 01251 global->default_subscribecontext[0] = '\0'; 01252 global->default_language[0] = '\0'; 01253 global->default_fromdomain[0] = '\0'; 01254 global->default_qualify = DEFAULT_QUALIFY; 01255 global->default_qualifycheck_ok = DEFAULT_QUALIFY_FREQ_OK; /*!< Default qualify time when status is ok */ 01256 global->default_qualifycheck_notok = DEFAULT_QUALIFY_FREQ_NOTOK; /*!< Default qualify time when statusis not ok */ 01257 global->default_maxcallbitrate = DEFAULT_MAX_CALL_BITRATE; 01258 ast_copy_string(global->default_mohinterpret, DEFAULT_MOHINTERPRET, sizeof(global->default_mohinterpret)); 01259 ast_copy_string(global->default_mohsuggest, DEFAULT_MOHSUGGEST, sizeof(global->default_mohsuggest)); 01260 ast_copy_string(global->default_vmexten, DEFAULT_VMEXTEN, sizeof(global->default_vmexten)); 01261 ast_set_flag(&global->flags[0], SIP_DTMF_RFC2833); /*!< Default DTMF setting: RFC2833 */ 01262 ast_set_flag(&global->flags[0], SIP_NAT_RFC3581); /*!< NAT support if requested by device with rport */ 01263 ast_set_flag(&global->flags[0], SIP_CAN_REINVITE); /*!< Allow re-invites */ 01264 01265 /* Debugging settings, always default to off */ 01266 global->dumphistory = FALSE; 01267 global->recordhistory = FALSE; 01268 ast_clear_flag(&global->flags[1], SIP_PAGE2_DEBUG_CONFIG); 01269 01270 01271 global->allowtransfer = TRANSFER_OPENFORALL; /* Merrily accept all transfers by default */ 01272 global->rtautoclear = 120; 01273 ast_set_flag(&global->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE); /* Default for peers, users: TRUE */ 01274 ast_set_flag(&global->flags[1], SIP_PAGE2_ALLOWOVERLAP); /* Default for peers, users: TRUE */ 01275 ast_set_flag(&global->flags[1], SIP_PAGE2_RTUPDATE); 01276 01277 ast_copy_string(global->default_context, DEFAULT_CONTEXT, sizeof(global->default_context)); 01278 global->relaxdtmf = FALSE; 01279 global->callevents = FALSE; 01280 global->t1min = DEFAULT_T1MIN; 01281 global->t1default = SIP_TIMER_T1_DEFAULT; 01282 global->t2default = SIP_TIMER_T2_DEFAULT; 01283 global->t4default = SIP_TIMER_T4_DEFAULT; 01284 global->siptimer_b = SIP_TIMER_B_DEFAULT; 01285 global->siptimer_f = SIP_TIMER_F_DEFAULT; 01286 sipcounters.peers_with_mwi = 0; /* Reset counter for mwi peers */ 01287 } 01288 01289 /*! \brief Re-read SIP.conf config file 01290 \note This function reloads all config data. 01291 They will only change configuration data at restart, not at reload. 01292 SIP debug and recordhistory state will not change 01293 */ 01294 int reload_config(enum channelreloadreason reason) 01295 { 01296 struct ast_config *cfg; 01297 struct ast_variable *v; 01298 struct sip_device *device = (struct sip_device *) NULL; 01299 struct ast_hostent ahp; 01300 char *cat, *stringp, *context, *oldregcontext; 01301 char newcontexts[AST_MAX_CONTEXT], oldcontexts[AST_MAX_CONTEXT]; 01302 struct hostent *hp; 01303 int format; 01304 struct ast_flags dummy[2]; 01305 int auto_sip_domains = FALSE; 01306 struct sockaddr_in old_bindaddr = sipnet.bindaddr; 01307 int registry_count = 0, peer_count = 0, user_count = 0; 01308 struct ast_flags debugflag = {0}; 01309 int error = 0; 01310 01311 cfg = ast_config_load(config); 01312 01313 /* We *must* have a config file otherwise stop immediately */ 01314 if (!cfg) { 01315 ast_log(LOG_NOTICE, "Unable to load config %s\n", config); 01316 return -1; 01317 } 01318 01319 /* Initialize copy of current global.regcontext for later use in removing stale contexts */ 01320 ast_copy_string(oldcontexts, global.regcontext, sizeof(oldcontexts)); 01321 oldregcontext = oldcontexts; 01322 01323 /* Clear all flags before setting default values */ 01324 /* Preserve debugging settings for console */ 01325 ast_copy_flags(&debugflag, &global.flags[1], SIP_PAGE2_DEBUG_CONSOLE); 01326 ast_copy_flags(&global.flags[1], &debugflag, SIP_PAGE2_DEBUG_CONSOLE); 01327 01328 /* Reset channel settings to default before re-configuring */ 01329 reset_ip_interface(&sipnet); /* Clear IP interfaces */ 01330 reset_global_settings(&global); /* Reset global global settings */ 01331 01332 expiry.min_expiry = DEFAULT_MIN_EXPIRY; /*!< Minimum accepted registration time */ 01333 expiry.max_expiry = DEFAULT_MAX_EXPIRY; /*!< Maximum accepted registration time */ 01334 expiry.default_expiry = DEFAULT_DEFAULT_EXPIRY; 01335 expiry.expiry = DEFAULT_EXPIRY; /* Used anywhere??? */ 01336 01337 01338 /* Copy the default jb config over global.jbconf */ 01339 memcpy(&global.jbconf, &default_jbconf, sizeof(struct ast_jb_conf)); 01340 01341 ast_clear_flag(&global.flags[1], SIP_PAGE2_VIDEOSUPPORT); 01342 01343 /* Read the [general] config section of sip.conf (or from realtime config) */ 01344 for (v = ast_variable_browse(cfg, "general"); v; v = v->next) { 01345 int i = 0; 01346 enum sip_config_options option = sip_config_parse(v->name, SIP_CONFOBJ_GENERAL); 01347 switch(option) { 01348 case SIP_CONF_TRUSTRPID: 01349 case SIP_CONF_SENDRPID: 01350 case SIP_CONF_G726NONSTANDARD: 01351 case SIP_CONF_USECLIENTCODE: 01352 case SIP_CONF_DTMFMODE: 01353 case SIP_CONF_NAT: 01354 case SIP_CONF_CANREINVITE: 01355 case SIP_CONF_INSECURE: 01356 case SIP_CONF_PROGRESSINBAND: 01357 case SIP_CONF_PROMISCREDIR: 01358 case SIP_CONF_VIDEOSUPPORT: 01359 case SIP_CONF_ALLOWOVERLAP: 01360 case SIP_CONF_ALLOWSUBSCRIBE: 01361 case SIP_CONF_T38PT_UDPTL: 01362 case SIP_CONF_RFC2833COMPENSATE: 01363 case SIP_CONF_COMPACTHEADERS: 01364 error += handle_common_options(option, &global.flags[0], &dummy[0], v); 01365 break; 01366 case SIP_CONF_JBENABLE: 01367 case SIP_CONF_JBFORCE: 01368 case SIP_CONF_JBIMPL: 01369 case SIP_CONF_JBLOG: 01370 case SIP_CONF_JBMAXSIZE: 01371 case SIP_CONF_JBRESYNC: 01372 /* handle jb conf */ 01373 ast_jb_read_conf(&global.jbconf, v->name, v->value); 01374 break; 01375 01376 case SIP_CONF_DEFCONTEXT: 01377 ast_copy_string(global.default_context, v->value, sizeof(global.default_context)); 01378 case SIP_CONF_ALLOWGUEST: 01379 global.allowguest = ast_true(v->value) ? 1 : 0; 01380 break; 01381 case SIP_CONF_REALM: 01382 ast_copy_string(global.realm, v->value, sizeof(global.realm)); 01383 break; 01384 case SIP_CONF_USERAGENT: 01385 ast_copy_string(global.useragent, v->value, sizeof(global.useragent)); 01386 break; 01387 case SIP_CONF_ALLOWTRANSFER: 01388 global.allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED; 01389 break; 01390 case SIP_CONF_RT_CACHEFRIENDS: 01391 ast_set2_flag(&global.flags[1], ast_true(v->value), SIP_PAGE2_RTCACHEFRIENDS); 01392 break; 01393 case SIP_CONF_RTSAVESYSTEMNAME: 01394 ast_set2_flag(&global.flags[1], ast_true(v->value), SIP_PAGE2_RTSAVE_SYSNAME); 01395 break; 01396 case SIP_CONF_RTUPDATE: 01397 ast_set2_flag(&global.flags[1], ast_true(v->value), SIP_PAGE2_RTUPDATE); 01398 break; 01399 case SIP_CONF_RTAUTOCLEAR: 01400 i = atoi(v->value); 01401 if (i > 0) 01402 global.rtautoclear = i; 01403 else { 01404 i = 0; 01405 error++; 01406 } 01407 ast_set2_flag(&global.flags[1], i || ast_true(v->value), SIP_PAGE2_RTAUTOCLEAR); 01408 break; 01409 case SIP_CONF_MAXFORWARDS: 01410 global.maxforwards = atoi(v->value); 01411 if (global.maxforwards < 1) { 01412 ast_log(LOG_WARNING, "Bad setting for maxforwards (%d), resetting to default %d\n", global.maxforwards, DEFAULT_MAX_FORWARDS); 01413 global.maxforwards = DEFAULT_MAX_FORWARDS; 01414 error++; 01415 } 01416 break; 01417 case SIP_CONF_IGNOREREGEXPIRE: 01418 ast_set2_flag(&global.flags[1], ast_true(v->value), SIP_PAGE2_IGNOREREGEXPIRE); 01419 break; 01420 case SIP_CONF_T1MIN: 01421 global.t1min = atoi(v->value); 01422 break; 01423 case SIP_CONF_T1DEFAULT: 01424 global.t1default = atoi(v->value); 01425 break; 01426 case SIP_CONF_T2DEFAULT: 01427 global.t2default = atoi(v->value); 01428 break; 01429 case SIP_CONF_T4DEFAULT: 01430 global.t4default = atoi(v->value); 01431 break; 01432 case SIP_CONF_TIMER_B: 01433 global.siptimer_b = atoi(v->value); 01434 break; 01435 case SIP_CONF_TIMER_F: 01436 global.siptimer_f = atoi(v->value); 01437 break; 01438 case SIP_CONF_USEREQPHONE: 01439 ast_set2_flag(&global.flags[0], ast_true(v->value), SIP_USEREQPHONE); 01440 break; 01441 case SIP_CONF_RELAXDTMF: 01442 global.relaxdtmf = ast_true(v->value); 01443 break; 01444 case SIP_CONF_MWICHECK: 01445 if ((sscanf(v->value, "%d", &global.mwitime) != 1) || (global.mwitime < 0)) { 01446 ast_log(LOG_WARNING, "'%s' is not a valid MWI time setting at line %d. Using default (10).\n", v->value, v->lineno); 01447 global.mwitime = DEFAULT_MWITIME; 01448 error++; 01449 }; 01450 break; 01451 case SIP_CONF_VMEXTEN: 01452 ast_copy_string(global.default_vmexten, v->value, sizeof(global.default_vmexten)); 01453 break; 01454 case SIP_CONF_RTPTIMEOUT: 01455 if ((sscanf(v->value, "%d", &global.rtptimer.rtptimeout) != 1) || (global.rtptimer.rtptimeout < 0)) { 01456 ast_log(LOG_WARNING, "'%s' is not a valid RTP time at line %d. Disabling RTP timeout.\n", v->value, v->lineno); 01457 global.rtptimer.rtptimeout = 0; 01458 error++; 01459 } 01460 break; 01461 case SIP_CONF_RTPHOLDTIMEOUT: 01462 if ((sscanf(v->value, "%d", &global.rtptimer.rtpholdtimeout) != 1) || (global.rtptimer.rtpholdtimeout < 0)) { 01463 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno); 01464 global.rtptimer.rtpholdtimeout = 0; 01465 error++; 01466 } 01467 break; 01468 case SIP_CONF_RTPKEEPALIVE: 01469 if ((sscanf(v->value, "%d", &global.rtptimer.rtpkeepalive) != 1) || (global.rtptimer.rtpkeepalive < 0)) { 01470 ast_log(LOG_WARNING, "'%s' is not a valid RTP keepalive time at line %d. Using default.\n", v->value, v->lineno); 01471 global.rtptimer.rtpkeepalive = 0; 01472 error++; 01473 } 01474 break; 01475 case SIP_CONF_NOTIFYMIME: 01476 ast_copy_string(global.default_notifymime, v->value, sizeof(global.default_notifymime)); 01477 break; 01478 case SIP_CONF_NOTIFYRINGING: 01479 global.notifyringing = ast_true(v->value); 01480 break; 01481 case SIP_CONF_ALWAYSAUTHREJECT: 01482 global.alwaysauthreject = ast_true(v->value); 01483 break; 01484 case SIP_CONF_MOHINTERPRET: 01485 ast_copy_string(global.default_mohinterpret, v->value, sizeof(global.default_mohinterpret)); 01486 break; 01487 case SIP_CONF_MOHSUGGEST: 01488 ast_copy_string(global.default_mohsuggest, v->value, sizeof(global.default_mohsuggest)); 01489 break; 01490 case SIP_CONF_LANGUAGE: 01491 ast_copy_string(global.default_language, v->value, sizeof(global.default_language)); 01492 break; 01493 case SIP_CONF_REGCONTEXT: 01494 ast_copy_string(newcontexts, v->value, sizeof(newcontexts)); 01495 stringp = newcontexts; 01496 /* Let's remove any contexts that are no longer defined in regcontext */ 01497 cleanup_stale_contexts(stringp, oldregcontext); 01498 /* Create contexts if they don't exist already */ 01499 while ((context = strsep(&stringp, "&"))) { 01500 if (!ast_context_find(context)) 01501 ast_context_create(NULL, context, "SIP"); 01502 } 01503 ast_copy_string(global.regcontext, v->value, sizeof(global.regcontext)); 01504 break; 01505 case SIP_CONF_CALLERID: 01506 ast_copy_string(global.default_callerid, v->value, sizeof(global.default_callerid)); 01507 break; 01508 case SIP_CONF_FROMDOMAIN: 01509 ast_copy_string(global.default_fromdomain, v->value, sizeof(global.default_fromdomain)); 01510 break; 01511 case SIP_CONF_OUTBOUNDPROXY: 01512 /* Save name for re-resolution */ 01513 ast_copy_string(sipnet.outboundproxy, v->value, sizeof(sipnet.outboundproxy)); 01514 /* Try to resolve name now */ 01515 if (ast_get_ip_or_srv(&sipnet.outboundproxyip, v->value, global.srvlookup ? "_sip._udp" : NULL) < 0) { 01516 ast_log(LOG_WARNING, "Unable to locate host '%s'\n", v->value); 01517 error++; 01518 }; 01519 break; 01520 case SIP_CONF_OBPROXYPORT: 01521 /* Port needs to be after IP */ 01522 sscanf(v->value, "%d", &format); 01523 sipnet.outboundproxyip.sin_port = htons(format); 01524 break; 01525 case SIP_CONF_AUTOCREATEPEER: 01526 global.autocreatepeer = ast_true(v->value); 01527 break; 01528 case SIP_CONF_SRVLOOKUP: 01529 global.srvlookup = ast_true(v->value); 01530 break; 01531 case SIP_CONF_EXPIRYMAX: 01532 expiry.max_expiry = atoi(v->value); 01533 if (expiry.max_expiry < 1) { 01534 ast_log(LOG_WARNING, "Bad setting for maxexpiry (%d). Resetting to default %d.\n", expiry.max_expiry, DEFAULT_MAX_EXPIRY); 01535 expiry.max_expiry = DEFAULT_MAX_EXPIRY; 01536 error++; 01537 } 01538 break; 01539 case SIP_CONF_EXPIRYMIN: 01540 expiry.min_expiry = atoi(v->value); 01541 if (expiry.min_expiry < 1) { 01542 ast_log(LOG_WARNING, "Bad setting for minexpiry (%d). Resetting to default %d.\n", expiry.min_expiry, DEFAULT_MAX_EXPIRY); 01543 expiry.min_expiry = DEFAULT_MIN_EXPIRY; 01544 error++; 01545 } 01546 break; 01547 case SIP_CONF_EXPIRYDEFAULT: 01548 expiry.default_expiry = atoi(v->value); 01549 if (expiry.default_expiry < 1) { 01550 ast_log(LOG_WARNING, "Bad setting for defaultexpiry (%d). Resetting to default %d.\n", expiry.default_expiry, DEFAULT_DEFAULT_EXPIRY); 01551 expiry.default_expiry = DEFAULT_DEFAULT_EXPIRY; 01552 error++; 01553 } 01554 break; 01555 case SIP_CONF_SIPDEBUG: 01556 if (ast_true(v->value)) 01557 ast_set_flag(&global.flags[1], SIP_PAGE2_DEBUG_CONFIG); 01558 break; 01559 case SIP_CONF_SIPDEBUGLEVEL: 01560 if (!strcasecmp(v->value, "ALL")) { 01561 global.debuglevel = SIPDEBUG_ALL; 01562 } else if (!strcasecmp(v->value, "CALLS")) { 01563 global.debuglevel = SIPDEBUG_CALLS; 01564 } else if (!strcasecmp(v->value, "NO-OPTIONS")) { 01565 global.debuglevel = SIPDEBUG_NOPOKE; 01566 } else { 01567 error++; 01568 ast_log(LOG_WARNING, "Bad setting for sipdebuglevel (%s). Resetting to default.\n", v->value); 01569 global.debuglevel = SIPDEBUG_ALL; 01570 } 01571 break; 01572 case SIP_CONF_HISTORYDUMP: 01573 global.dumphistory = ast_true(v->value); 01574 break; 01575 case SIP_CONF_HISTORYRECORD: 01576 global.recordhistory = ast_true(v->value); 01577 break; 01578 case SIP_CONF_REGISTERTIMEOUT: 01579 global.reg_timeout = atoi(v->value); 01580 if (global.reg_timeout < 1) { 01581 ast_log(LOG_WARNING, "Bad setting for registertimeout (%d). Resetting to default %d.\n", global.reg_timeout, DEFAULT_REGISTRATION_TIMEOUT); 01582 global.reg_timeout = DEFAULT_REGISTRATION_TIMEOUT; 01583 error++; 01584 }; 01585 break; 01586 case SIP_CONF_REGISTERATTEMPTS: 01587 global.regattempts_max = atoi(v->value); 01588 if (global.regattempts_max < 1) { 01589 ast_log(LOG_WARNING, "Bad setting for registerattempts (%d). Resetting to default %d.\n", global.regattempts_max, 0); 01590 global.regattempts_max = 0; 01591 error++; 01592 }; 01593 break; 01594 case SIP_CONF_BINDADDR: 01595 if (!(hp = ast_gethostbyname(v->value, &ahp))) { 01596 ast_log(LOG_WARNING, "Invalid bind address: %s\n", v->value); 01597 error++; 01598 } else 01599 memcpy(&sipnet.bindaddr.sin_addr, hp->h_addr, sizeof(sipnet.bindaddr.sin_addr)); 01600 break; 01601 case SIP_CONF_BINDPORT: 01602 { 01603 int port; 01604 if (sscanf(v->value, "%d", &port) == 1) { 01605 sipnet_ourport_set(&sipnet, port); 01606 sipnet.bindaddr.sin_port = htons(sipnet_ourport(&sipnet)); 01607 } else { 01608 ast_log(LOG_WARNING, "Invalid port number '%s' at line %d of %s\n", v->value, v->lineno, config); 01609 error++; 01610 } 01611 } 01612 break; 01613 case SIP_CONF_LOCALNET: 01614 { 01615 struct ast_ha *na; 01616 int ha_error = 0; 01617 01618 na = ast_append_ha("d", v->value, sipnet.localaddr, &ha_error); 01619 if (ha_error) { 01620 ast_log(LOG_WARNING, "Invalid localnet value: %s\n", v->value); 01621 error++; 01622 } else 01623 sipnet.localaddr = na; 01624 } 01625 break; 01626 case SIP_CONF_EXTERNIP: 01627 if (!(hp = ast_gethostbyname(v->value, &ahp))) { 01628 ast_log(LOG_WARNING, "Invalid address for externip keyword: %s\n", v->value); 01629 error++; 01630 } else 01631 memcpy(&sipnet.externip.sin_addr, hp->h_addr, sizeof(sipnet.externip.sin_addr)); 01632 sipnet.externexpire = 0; 01633 break; 01634 case SIP_CONF_EXTERNHOST: 01635 ast_copy_string(sipnet.externhost, v->value, sizeof(sipnet.externhost)); 01636 if (!(hp = ast_gethostbyname(sipnet.externhost, &ahp))) { 01637 ast_log(LOG_WARNING, "Invalid address for externhost keyword: %s\n", sipnet.externhost); 01638 error++; 01639 } else 01640 memcpy(&sipnet.externip.sin_addr, hp->h_addr, sizeof(sipnet.externip.sin_addr)); 01641 sipnet.externexpire = time(NULL); 01642 break; 01643 case SIP_CONF_EXTERNREFRESH: 01644 if (sscanf(v->value, "%d", &sipnet.externrefresh) != 1) { 01645 ast_log(LOG_WARNING, "Invalid externrefresh value '%s', must be an integer > 0 at line %d. Resetting to default %d\n", v->value, v->lineno, DEFAULT_EXTERNREFRESH); 01646 sipnet.externrefresh = DEFAULT_EXTERNREFRESH; 01647 error++; 01648 } 01649 break; 01650 case SIP_CONF_ALLOW: 01651 error += ast_parse_allow_disallow(&global.default_prefs, &global.capability, v->value, TRUE); 01652 break; 01653 case SIP_CONF_DISALLOW: 01654 error += ast_parse_allow_disallow(&global.default_prefs, &global.capability, v->value, FALSE); 01655 break; 01656 case SIP_CONF_AUTOFRAMING: 01657 global.autoframing = ast_true(v->value); 01658 break; 01659 case SIP_CONF_ALLOWEXTERNALDOMAINS: 01660 global.allow_external_domains = ast_true(v->value); 01661 break; 01662 case SIP_CONF_AUTODOMAIN: 01663 auto_sip_domains = ast_true(v->value); 01664 break; 01665 case SIP_CONF_DOMAIN: 01666 { 01667 char *domain = ast_strdupa(v->value); 01668 char *context = strchr(domain, ','); 01669 01670 if (context) 01671 *context++ = '\0'; 01672 01673 if (option_debug && ast_strlen_zero(context)) 01674 ast_log(LOG_DEBUG, "No context specified at line %d for domain '%s'\n", v->lineno, domain); 01675 if (ast_strlen_zero(domain)) { 01676 ast_log(LOG_WARNING, "Empty domain specified at line %d\n", v->lineno); 01677 error++; 01678 } else 01679 add_sip_domain(ast_strip(domain), SIP_DOMAIN_CONFIG, context ? ast_strip(context) : ""); 01680 } 01681 break; 01682 case SIP_CONF_REGISTER: 01683 if (sip_register(v->value, v->lineno, NULL) == 0) 01684 registry_count++; 01685 else { 01686 error++; 01687 } 01688 break; 01689 case SIP_CONF_TOS_SIP: 01690 if (ast_str2tos(v->value, &global.tos_sip)) { 01691 ast_log(LOG_WARNING, "Invalid tos_sip value %s at line %d, recommended value is 'cs3'. See doc/ip-tos.txt.\n", v->value, v->lineno); 01692 error++; 01693 } 01694 break; 01695 case SIP_CONF_TOS_AUDIO: 01696 if (ast_str2tos(v->value, &global.tos_audio)) { 01697 ast_log(LOG_WARNING, "Invalid tos_audio value at line %d, recommended value is 'ef'. See doc/ip-tos.txt.\n", v->lineno); 01698 error++; 01699 } 01700 break; 01701 case SIP_CONF_TOS_VIDEO: 01702 if (ast_str2tos(v->value, &global.tos_video)) { 01703 ast_log(LOG_WARNING, "Invalid tos_video value at line %d, recommended value is 'af41'. See doc/ip-tos.txt.\n", v->lineno); 01704 error++; 01705 } 01706 break; 01707 case SIP_CONF_TOS_PRESENSE: 01708 if (ast_str2tos(v->value, &global.tos_presense)) { 01709 ast_log(LOG_WARNING, "Invalid tos_presence value at line %d, recommended value is 'cs3'. See doc/ip-tos.txt.\n", v->lineno); 01710 error++; 01711 } 01712 break; 01713 case SIP_CONF_QUALIFY: 01714 if (ast_false(v->value)) 01715 global.default_qualify = 0; 01716 else if (ast_true(v->value)) { 01717 global.default_qualify = DEFAULT_QUALIFY_MAXMS; 01718 } else if (sscanf(v->value, "%d", &global.default_qualify) != 1 ||global.default_qualify < 10) { 01719 ast_log(LOG_WARNING, "Qualification default should be 'yes', 'no', or a number of milliseconds > 10 at line %d of sip.conf\n", v->lineno); 01720 error++; 01721 global.default_qualify = 0; 01722 } 01723 break; 01724 case SIP_CONF_QUALIFY_TIMER_OK: 01725 { 01726 int freq; 01727 if(sscanf(v->value, "%d", &freq) != 1) { 01728 if (freq) 01729 global.default_qualifycheck_ok = freq; 01730 else { 01731 error++; 01732 ast_log(LOG_WARNING, "Bad value for qualify ok timer: %s. Using default value\n", v->value); 01733 } 01734 } 01735 } 01736 break; 01737 case SIP_CONF_QUALIFY_TIMER_NOT_OK: 01738 { 01739 int freq; 01740 if(sscanf(v->value, "%d", &freq) != 1) { 01741 if (freq) 01742 global.default_qualifycheck_notok = freq; 01743 else { 01744 error++; 01745 ast_log(LOG_WARNING, "Bad value for qualify not ok timer: %s. Using default value\n", v->value); 01746 } 01747 } 01748 } 01749 break; 01750 case SIP_CONF_CALLEVENTS: 01751 global.callevents = ast_true(v->value); 01752 break; 01753 case SIP_CONF_MAXCALLBITRATE: 01754 global.default_maxcallbitrate = atoi(v->value); 01755 if (global.default_maxcallbitrate < 0) { 01756 global.default_maxcallbitrate = DEFAULT_MAX_CALL_BITRATE; 01757 error++; 01758 ast_log(LOG_WARNING, "Bad value for max call bitrate: %s, resetting to default %d\n", v->value, DEFAULT_MAX_CALL_BITRATE); 01759 } 01760 break; 01761 case SIP_CONF_NONE: 01762 case SIP_CONF_NOT_VALID_FOR_OBJECT: 01763 case SIP_CONF_NOT_FOUND: 01764 ast_log(LOG_ERROR, "This configuration option is not valid here: %s (line %d)\n", v->name, v->lineno); 01765 break; 01766 default: 01767 ast_log(LOG_ERROR, "This error message should not happen. Bad config error: %d\n", option); 01768 break; 01769 } 01770 } 01771 if (error) 01772 ast_log(LOG_WARNING, "--- Number of errors found in general config: %d\n", error); 01773 01774 if (!global.allow_external_domains && domains_configured()) { 01775 ast_log(LOG_WARNING, "To disallow external domains, you need to configure local SIP domains.\n"); 01776 global.allow_external_domains = 1; 01777 } 01778 01779 /* Build list of authentication to various SIP realms, i.e. service providers */ 01780 for (v = ast_variable_browse(cfg, "authentication"); v ; v = v->next) { 01781 /* Format for authentication is auth = username:password@realm */ 01782 if (!strcasecmp(v->name, "auth")) 01783 authl = add_realm_authentication(authl, v->value, v->lineno); 01784 } 01785 01786 /* Load peers, users and friends */ 01787 cat = NULL; 01788 while ( (cat = ast_category_browse(cfg, cat)) ) { 01789 const char *utype; 01790 01791 /* Skip general section, as well as authentication section */ 01792 if (!strcasecmp(cat, "general") || !strcasecmp(cat, "authentication")) 01793 continue; 01794 utype = ast_variable_retrieve(cfg, cat, "type"); 01795 if (!utype) { 01796 ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat); 01797 continue; 01798 } else { 01799 enum objecttype type; 01800 01801 if (!strcasecmp(utype, "phone") || !strcasecmp(utype, "peer") ) /* Keep "peer" for a short while */ 01802 type = SIP_PEER; 01803 else { 01804 ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, "sip.conf"); 01805 continue; 01806 } 01807 if (type & SIP_PEER) { 01808 device = build_device(cat, ast_variable_browse(cfg, cat), NULL, 0); 01809 if (device) { 01810 ASTOBJ_CONTAINER_LINK(&devicelist,device); 01811 device_unref(device); 01812 peer_count++; 01813 } 01814 } 01815 } 01816 } 01817 01818 /* Add default domains - host name, IP address and IP:port */ 01819 /* Only do this if user added any sip domain with "localdomains" */ 01820 /* In order to *not* break backwards compatibility */ 01821 /* Some phones address us at IP only, some with additional port number */ 01822 if (auto_sip_domains) { 01823 char temp[MAXHOSTNAMELEN]; 01824 01825 /* First our default IP address */ 01826 if (sipnet.bindaddr.sin_addr.s_addr) 01827 add_sip_domain(ast_inet_ntoa(sipnet.bindaddr.sin_addr), SIP_DOMAIN_AUTO, NULL); 01828 else 01829 ast_log(LOG_NOTICE, "Can't add wildcard IP address to domain list, please add IP address to domain manually.\n"); 01830 01831 /* Our extern IP address, if configured */ 01832 if (sipnet.externip.sin_addr.s_addr) 01833 add_sip_domain(ast_inet_ntoa(sipnet.externip.sin_addr), SIP_DOMAIN_AUTO, NULL); 01834 01835 /* Extern host name (NAT traversal support) */ 01836 if (!ast_strlen_zero(sipnet.externhost)) 01837 add_sip_domain(sipnet.externhost, SIP_DOMAIN_AUTO, NULL); 01838 01839 /* Our host name */ 01840 if (!gethostname(temp, sizeof(temp))) 01841 add_sip_domain(temp, SIP_DOMAIN_AUTO, NULL); 01842 } 01843 01844 /* Release configuration from memory */ 01845 ast_config_destroy(cfg); 01846 01847 /* Load the list of manual NOTIFY types to support */ 01848 if (notify_types) 01849 ast_config_destroy(notify_types); 01850 notify_types = ast_config_load(notify_config); 01851 01852 /* Done, tell the manager */ 01853 manager_event(EVENT_FLAG_SYSTEM, "ChannelReload", "Channel: SIP\r\nReloadReason: %s\r\nRegistry_Count: %d\r\nPeer_Count: %d\r\nUser_Count: %d\r\n\r\n", channelreloadreason2txt(reason), registry_count, peer_count, user_count); 01854 if (sipsock_init(&sipnet, &old_bindaddr) == -1) 01855 ast_log(LOG_WARNING, "Unable to get own IP address, SIP disabled\n"); 01856 01857 return 0; 01858 } 01859 01860 /*! \brief List configuration options for specific object */ 01861 static void sip_listconfighelper(int fd, enum sip_config_objects object) 01862 { 01863 int i; 01864 int max = sizeof(sip_config) / sizeof(struct sip_config_struct); 01865 int count = 0; 01866 01867 ast_cli(fd,"--------------------------------------------------------------------------------\n"); 01868 for (i=0; i < max; i++) { 01869 if (sip_config[i].valid & object) { 01870 ast_cli(fd, " %-18.18s %-80.80s\n", sip_config[i].label, sip_config[i].desc); 01871 count++; 01872 } 01873 } 01874 ast_cli(fd, " * %d configuration options\n", count); 01875 ast_cli(fd,"\n"); 01876 } 01877 01878 /*! \brief List all configuration options in sip.conf */ 01879 int sip_listconfigs(int fd) 01880 { 01881 ast_cli(fd, "\nSIP configuration options help page:\n"); 01882 ast_cli(fd,"\n"); 01883 ast_cli(fd,"Configuration options for the [general] section of sip.conf\n"); 01884 sip_listconfighelper(fd, SIP_CONFOBJ_GENERAL); 01885 ast_cli(fd,"Configuration options for type=phone\n"); 01886 sip_listconfighelper(fd, SIP_CONFOBJ_PHONE); 01887 ast_cli(fd,"Configuration options for type=trunk\n"); 01888 sip_listconfighelper(fd, SIP_CONFOBJ_TRUNK); 01889 ast_cli(fd,"Configuration options for type=service\n"); 01890 sip_listconfighelper(fd, SIP_CONFOBJ_SERVICE); 01891 ast_cli(fd, "\n---\n"); 01892 return RESULT_SUCCESS; 01893 01894 /* SIP_CONFOBJ_GENERAL General section 01895 SIP_CONFOBJ_PHONE Phone options 01896 SIP_CONFOBJ_SERVICE Service options 01897 SIP_CONFOBJ_TRUNK Trunk options 01898 SIP_CONFOBJ_DOMAIN Configurations valid for domains 01899 SIP_CONFOBJ_LINE Phone, service and trunk (macro) 01900 */ 01901 } 01902