549c9d7c9e030caf4096283d5673179396c98b65
[asterisk/asterisk.git] / channels / chan_sip.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  * \brief Implementation of Session Initiation Protocol
22  *
23  * \author Mark Spencer <markster@digium.com>
24  *
25  * See Also:
26  * \arg \ref AstCREDITS
27  *
28  * Implementation of RFC 3261 - without S/MIME, and experimental TCP and TLS support
29  * Configuration file \link Config_sip sip.conf \endlink
30  *
31  * ********** IMPORTANT *
32  * \note TCP/TLS support is EXPERIMENTAL and WILL CHANGE. This applies to configuration
33  *      settings, dialplan commands and dialplans apps/functions
34  * See \ref sip_tcp_tls
35  *
36  *
37  * ******** General TODO:s
38  * \todo Better support of forking
39  * \todo VIA branch tag transaction checking
40  * \todo Transaction support
41  *
42  * ******** Wishlist: Improvements
43  * - Support of SIP domains for devices, so that we match on username@domain in the From: header
44  * - Connect registrations with a specific device on the incoming call. It's not done
45  *   automatically in Asterisk
46  *
47  * \ingroup channel_drivers
48  *
49  * \par Overview of the handling of SIP sessions
50  * The SIP channel handles several types of SIP sessions, or dialogs,
51  * not all of them being "telephone calls".
52  * - Incoming calls that will be sent to the PBX core
53  * - Outgoing calls, generated by the PBX
54  * - SIP subscriptions and notifications of states and voicemail messages
55  * - SIP registrations, both inbound and outbound
56  * - SIP peer management (peerpoke, OPTIONS)
57  * - SIP text messages
58  *
59  * In the SIP channel, there's a list of active SIP dialogs, which includes
60  * all of these when they are active. "sip show channels" in the CLI will
61  * show most of these, excluding subscriptions which are shown by
62  * "sip show subscriptions"
63  *
64  * \par incoming packets
65  * Incoming packets are received in the monitoring thread, then handled by
66  * sipsock_read() for udp only. In tcp, packets are read by the tcp_helper thread.
67  * sipsock_read() function parses the packet and matches an existing
68  * dialog or starts a new SIP dialog.
69  *
70  * sipsock_read sends the packet to handle_incoming(), that parses a bit more.
71  * If it is a response to an outbound request, the packet is sent to handle_response().
72  * If it is a request, handle_incoming() sends it to one of a list of functions
73  * depending on the request type - INVITE, OPTIONS, REFER, BYE, CANCEL etc
74  * sipsock_read locks the ast_channel if it exists (an active call) and
75  * unlocks it after we have processed the SIP message.
76  *
77  * A new INVITE is sent to handle_request_invite(), that will end up
78  * starting a new channel in the PBX, the new channel after that executing
79  * in a separate channel thread. This is an incoming "call".
80  * When the call is answered, either by a bridged channel or the PBX itself
81  * the sip_answer() function is called.
82  *
83  * The actual media - Video or Audio - is mostly handled by the RTP subsystem
84  * in rtp.c
85  *
86  * \par Outbound calls
87  * Outbound calls are set up by the PBX through the sip_request_call()
88  * function. After that, they are activated by sip_call().
89  *
90  * \par Hanging up
91  * The PBX issues a hangup on both incoming and outgoing calls through
92  * the sip_hangup() function
93  */
94
95 /*!
96  * \page sip_tcp_tls SIP TCP and TLS support
97  *
98  * \par tcpfixes TCP implementation changes needed
99  * \todo Fix TCP/TLS handling in dialplan, SRV records, transfers and much more
100  * \todo Save TCP/TLS sessions in registry
101  *      If someone registers a SIPS uri, this forces us to set up a TLS connection back.
102  * \todo Add TCP/TLS information to function SIPPEER and SIPCHANINFO
103  * \todo If tcpenable=yes, we must open a TCP socket on the same address as the IP for UDP.
104  *      The tcpbindaddr config option should only be used to open ADDITIONAL ports
105  *      So we should propably go back to
106  *              bindaddr= the default address to bind to. If tcpenable=yes, then bind this to both udp and TCP
107  *                              if tlsenable=yes, open TLS port (provided we also have cert)
108  *              tcpbindaddr = extra address for additional TCP connections
109  *              tlsbindaddr = extra address for additional TCP/TLS connections
110  *              udpbindaddr = extra address for additional UDP connections
111  *                      These three options should take multiple IP/port pairs
112  *      Note: Since opening additional listen sockets is a *new* feature we do not have today
113  *              the XXXbindaddr options needs to be disabled until we have support for it
114  *
115  * \todo re-evaluate the transport= setting in sip.conf. This is right now not well
116  *      thought of. If a device in sip.conf contacts us via TCP, we should not switch transport,
117  *      even if udp is the configured first transport.
118  *
119  * \todo Be prepared for one outbound and another incoming socket per pvt. This applies
120  *       specially to communication with other peers (proxies).
121  * \todo We need to test TCP sessions with SIP proxies and in regards
122  *       to the SIP outbound specs.
123  * \todo ;transport=tls was deprecated in RFC3261 and should not be used at all. See section 26.2.2.
124  *
125  * \todo If the message is smaller than the given Content-length, the request should get a 400 Bad request
126  *       message. If it's a response, it should be dropped. (RFC 3261, Section 18.3)
127  * \todo Since we have had multidomain support in Asterisk for quite a while, we need to support
128  *       multiple domains in our TLS implementation, meaning one socket and one cert per domain
129  * \todo Selection of transport for a request needs to be done after we've parsed all route headers,
130  *       also considering outbound proxy options.
131  *              First request: Outboundproxy, routes, (reg contact or URI. If URI doesn't have port:  DNS naptr, srv, AAA)
132  *              Intermediate requests: Outboundproxy(only when forced), routes, contact/uri
133  *      DNS naptr support is crucial. A SIP uri might lead to a TLS connection.
134  *      Also note that due to outbound proxy settings, a SIPS uri might have to be sent on UDP (not to recommend though)
135  * \todo Default transports are set to UDP, which cause the wrong behaviour when contacting remote
136  *      devices directly from the dialplan. UDP is only a fallback if no other method works,
137  *      in order to be compatible with RFC2543 (SIP/1.0) devices. For transactions that exceed the
138  *      MTU (like INIVTE with video, audio and RTT)  TCP should be preferred.
139  *
140  *      When dialling unconfigured peers (with no port number)  or devices in external domains
141  *      NAPTR records MUST be consulted to find configured transport. If they are not found,
142  *      SRV records for both TCP and UDP should be checked. If there's a record for TCP, use that.
143  *      If there's no record for TCP, then use UDP as a last resort. If there's no SRV records,
144  *      \note this only applies if there's no outbound proxy configured for the session. If an outbound
145  *      proxy is configured, these procedures might apply for locating the proxy and determining
146  *      the transport to use for communication with the proxy.
147  * \par Other bugs to fix ----
148  * __set_address_from_contact(const char *fullcontact, struct sockaddr_in *sin, int tcp)
149  *      - sets TLS port as default for all TCP connections, unless other port is given in contact.
150  * parse_register_contact(struct sip_pvt *pvt, struct sip_peer *peer, struct sip_request *req)
151  *      - assumes that the contact the UA registers is using the same transport as the REGISTER request, which is
152  *        a bad guess.
153  *      - Does not save any information about TCP/TLS connected devices, which is a severe BUG, as discussed on the mailing list.
154  * get_destination(struct sip_pvt *p, struct sip_request *oreq)
155  *      - Doesn't store the information that we got an incoming SIPS request in the channel, so that
156  *        we can require a secure signalling path OUT of Asterisk (on SIP or IAX2). Possibly, the call should
157  *        fail on in-secure signalling paths if there's no override in our configuration. At least, provide a
158  *        channel variable in the dialplan.
159  * get_refer_info(struct sip_pvt *transferer, struct sip_request *outgoing_req)
160  *      - As above, if we have a SIPS: uri in the refer-to header
161  *      - Does not check transport in refer_to uri.
162  */
163
164 /*** MODULEINFO
165         <depend>chan_local</depend>
166  ***/
167
168 /*!  \page sip_session_timers SIP Session Timers in Asterisk Chan_sip
169
170         The SIP Session-Timers is an extension of the SIP protocol that allows end-points and proxies to
171         refresh a session periodically. The sessions are kept alive by sending a RE-INVITE or UPDATE
172         request at a negotiated interval. If a session refresh fails then all the entities that support Session-
173         Timers clear their internal session state. In addition, UAs generate a BYE request in order to clear
174         the state in the proxies and the remote UA (this is done for the benefit of SIP entities in the path
175         that do not support Session-Timers).
176
177         The Session-Timers can be configured on a system-wide, per-user, or per-peer basis. The peruser/
178         per-peer settings override the global settings. The following new parameters have been
179         added to the sip.conf file.
180                 session-timers=["accept", "originate", "refuse"]
181                 session-expires=[integer]
182                 session-minse=[integer]
183                 session-refresher=["uas", "uac"]
184
185         The session-timers parameter in sip.conf defines the mode of operation of SIP session-timers feature in
186         Asterisk. The Asterisk can be configured in one of the following three modes:
187
188         1. Accept :: In the "accept" mode, the Asterisk server honors session-timers requests
189                 made by remote end-points. A remote end-point can request Asterisk to engage
190                 session-timers by either sending it an INVITE request with a "Supported: timer"
191                 header in it or by responding to Asterisk's INVITE with a 200 OK that contains
192                 Session-Expires: header in it. In this mode, the Asterisk server does not
193                 request session-timers from remote end-points. This is the default mode.
194         2. Originate :: In the "originate" mode, the Asterisk server requests the remote
195                 end-points to activate session-timers in addition to honoring such requests
196                 made by the remote end-pints. In order to get as much protection as possible
197                 against hanging SIP channels due to network or end-point failures, Asterisk
198                 resends periodic re-INVITEs even if a remote end-point does not support
199                 the session-timers feature.
200         3. Refuse :: In the "refuse" mode, Asterisk acts as if it does not support session-
201                 timers for inbound or outbound requests. If a remote end-point requests
202                 session-timers in a dialog, then Asterisk ignores that request unless it's
203                 noted as a requirement (Require: header), in which case the INVITE is
204                 rejected with a 420 Bad Extension response.
205
206 */
207
208 #include "asterisk.h"
209
210 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
211
212 #include <signal.h>
213 #include <sys/signal.h>
214 #include <regex.h>
215 #include <inttypes.h>
216
217 #include "asterisk/network.h"
218 #include "asterisk/paths.h"     /* need ast_config_AST_SYSTEM_NAME */
219 /*
220    Uncomment the define below,  if you are having refcount related memory leaks.
221    With this uncommented, this module will generate a file, /tmp/refs, which contains
222    a history of the ao2_ref() calls. To be useful, all calls to ao2_* functions should
223    be modified to ao2_t_* calls, and include a tag describing what is happening with
224    enough detail, to make pairing up a reference count increment with its corresponding decrement.
225    The refcounter program in utils/ can be invaluable in highlighting objects that are not
226    balanced, along with the complete history for that object.
227    In normal operation, the macros defined will throw away the tags, so they do not
228    affect the speed of the program at all. They can be considered to be documentation.
229 */
230 /* #define  REF_DEBUG 1 */
231 #include "asterisk/lock.h"
232 #include "asterisk/config.h"
233 #include "asterisk/module.h"
234 #include "asterisk/pbx.h"
235 #include "asterisk/sched.h"
236 #include "asterisk/io.h"
237 #include "asterisk/rtp_engine.h"
238 #include "asterisk/udptl.h"
239 #include "asterisk/acl.h"
240 #include "asterisk/manager.h"
241 #include "asterisk/callerid.h"
242 #include "asterisk/cli.h"
243 #include "asterisk/musiconhold.h"
244 #include "asterisk/dsp.h"
245 #include "asterisk/features.h"
246 #include "asterisk/srv.h"
247 #include "asterisk/astdb.h"
248 #include "asterisk/causes.h"
249 #include "asterisk/utils.h"
250 #include "asterisk/file.h"
251 #include "asterisk/astobj2.h"
252 #include "asterisk/dnsmgr.h"
253 #include "asterisk/devicestate.h"
254 #include "asterisk/monitor.h"
255 #include "asterisk/netsock.h"
256 #include "asterisk/localtime.h"
257 #include "asterisk/abstract_jb.h"
258 #include "asterisk/threadstorage.h"
259 #include "asterisk/translate.h"
260 #include "asterisk/ast_version.h"
261 #include "asterisk/event.h"
262 #include "asterisk/stun.h"
263 #include "asterisk/cel.h"
264 #include "asterisk/aoc.h"
265 #include "sip/include/sip.h"
266 #include "sip/include/globals.h"
267 #include "sip/include/config_parser.h"
268 #include "sip/include/reqresp_parser.h"
269 #include "sip/include/sip_utils.h"
270 #include "sip/include/srtp.h"
271 #include "sip/include/sdp_crypto.h"
272 #include "asterisk/ccss.h"
273 #include "asterisk/xml.h"
274 #include "sip/include/dialog.h"
275 #include "sip/include/dialplan_functions.h"
276
277
278 /*** DOCUMENTATION
279         <application name="SIPDtmfMode" language="en_US">
280                 <synopsis>
281                         Change the dtmfmode for a SIP call.
282                 </synopsis>
283                 <syntax>
284                         <parameter name="mode" required="true">
285                                 <enumlist>
286                                         <enum name="inband" />
287                                         <enum name="info" />
288                                         <enum name="rfc2833" />
289                                 </enumlist>
290                         </parameter>
291                 </syntax>
292                 <description>
293                         <para>Changes the dtmfmode for a SIP call.</para>
294                 </description>
295         </application>
296         <application name="SIPAddHeader" language="en_US">
297                 <synopsis>
298                         Add a SIP header to the outbound call.
299                 </synopsis>
300                 <syntax argsep=":">
301                         <parameter name="Header" required="true" />
302                         <parameter name="Content" required="true" />
303                 </syntax>
304                 <description>
305                         <para>Adds a header to a SIP call placed with DIAL.</para>
306                         <para>Remember to use the X-header if you are adding non-standard SIP
307                         headers, like <literal>X-Asterisk-Accountcode:</literal>. Use this with care.
308                         Adding the wrong headers may jeopardize the SIP dialog.</para>
309                         <para>Always returns <literal>0</literal>.</para>
310                 </description>
311         </application>
312         <application name="SIPRemoveHeader" language="en_US">
313                 <synopsis>
314                         Remove SIP headers previously added with SIPAddHeader
315                 </synopsis>
316                 <syntax>
317                         <parameter name="Header" required="false" />
318                 </syntax>
319                 <description>
320                         <para>SIPRemoveHeader() allows you to remove headers which were previously
321                         added with SIPAddHeader(). If no parameter is supplied, all previously added
322                         headers will be removed. If a parameter is supplied, only the matching headers
323                         will be removed.</para>
324                         <para>For example you have added these 2 headers:</para>
325                         <para>SIPAddHeader(P-Asserted-Identity: sip:foo@bar);</para>
326                         <para>SIPAddHeader(P-Preferred-Identity: sip:bar@foo);</para>
327                         <para></para>
328                         <para>// remove all headers</para>
329                         <para>SIPRemoveHeader();</para>
330                         <para>// remove all P- headers</para>
331                         <para>SIPRemoveHeader(P-);</para>
332                         <para>// remove only the PAI header (note the : at the end)</para>
333                         <para>SIPRemoveHeader(P-Asserted-Identity:);</para>
334                         <para></para>
335                         <para>Always returns <literal>0</literal>.</para>
336                 </description>
337         </application>
338         <function name="SIP_HEADER" language="en_US">
339                 <synopsis>
340                         Gets the specified SIP header.
341                 </synopsis>
342                 <syntax>
343                         <parameter name="name" required="true" />
344                         <parameter name="number">
345                                 <para>If not specified, defaults to <literal>1</literal>.</para>
346                         </parameter>
347                 </syntax>
348                 <description>
349                         <para>Since there are several headers (such as Via) which can occur multiple
350                         times, SIP_HEADER takes an optional second argument to specify which header with
351                         that name to retrieve. Headers start at offset <literal>1</literal>.</para>
352                 </description>
353         </function>
354         <function name="SIPPEER" language="en_US">
355                 <synopsis>
356                         Gets SIP peer information.
357                 </synopsis>
358                 <syntax>
359                         <parameter name="peername" required="true" />
360                         <parameter name="item">
361                                 <enumlist>
362                                         <enum name="ip">
363                                                 <para>(default) The ip address.</para>
364                                         </enum>
365                                         <enum name="port">
366                                                 <para>The port number.</para>
367                                         </enum>
368                                         <enum name="mailbox">
369                                                 <para>The configured mailbox.</para>
370                                         </enum>
371                                         <enum name="context">
372                                                 <para>The configured context.</para>
373                                         </enum>
374                                         <enum name="expire">
375                                                 <para>The epoch time of the next expire.</para>
376                                         </enum>
377                                         <enum name="dynamic">
378                                                 <para>Is it dynamic? (yes/no).</para>
379                                         </enum>
380                                         <enum name="callerid_name">
381                                                 <para>The configured Caller ID name.</para>
382                                         </enum>
383                                         <enum name="callerid_num">
384                                                 <para>The configured Caller ID number.</para>
385                                         </enum>
386                                         <enum name="callgroup">
387                                                 <para>The configured Callgroup.</para>
388                                         </enum>
389                                         <enum name="pickupgroup">
390                                                 <para>The configured Pickupgroup.</para>
391                                         </enum>
392                                         <enum name="codecs">
393                                                 <para>The configured codecs.</para>
394                                         </enum>
395                                         <enum name="status">
396                                                 <para>Status (if qualify=yes).</para>
397                                         </enum>
398                                         <enum name="regexten">
399                                                 <para>Registration extension.</para>
400                                         </enum>
401                                         <enum name="limit">
402                                                 <para>Call limit (call-limit).</para>
403                                         </enum>
404                                         <enum name="busylevel">
405                                                 <para>Configured call level for signalling busy.</para>
406                                         </enum>
407                                         <enum name="curcalls">
408                                                 <para>Current amount of calls. Only available if call-limit is set.</para>
409                                         </enum>
410                                         <enum name="language">
411                                                 <para>Default language for peer.</para>
412                                         </enum>
413                                         <enum name="accountcode">
414                                                 <para>Account code for this peer.</para>
415                                         </enum>
416                                         <enum name="useragent">
417                                                 <para>Current user agent id for peer.</para>
418                                         </enum>
419                                         <enum name="chanvar[name]">
420                                                 <para>A channel variable configured with setvar for this peer.</para>
421                                         </enum>
422                                         <enum name="codec[x]">
423                                                 <para>Preferred codec index number <replaceable>x</replaceable> (beginning with zero).</para>
424                                         </enum>
425                                 </enumlist>
426                         </parameter>
427                 </syntax>
428                 <description />
429         </function>
430         <function name="SIPCHANINFO" language="en_US">
431                 <synopsis>
432                         Gets the specified SIP parameter from the current channel.
433                 </synopsis>
434                 <syntax>
435                         <parameter name="item" required="true">
436                                 <enumlist>
437                                         <enum name="peerip">
438                                                 <para>The IP address of the peer.</para>
439                                         </enum>
440                                         <enum name="recvip">
441                                                 <para>The source IP address of the peer.</para>
442                                         </enum>
443                                         <enum name="from">
444                                                 <para>The URI from the <literal>From:</literal> header.</para>
445                                         </enum>
446                                         <enum name="uri">
447                                                 <para>The URI from the <literal>Contact:</literal> header.</para>
448                                         </enum>
449                                         <enum name="useragent">
450                                                 <para>The useragent.</para>
451                                         </enum>
452                                         <enum name="peername">
453                                                 <para>The name of the peer.</para>
454                                         </enum>
455                                         <enum name="t38passthrough">
456                                                 <para><literal>1</literal> if T38 is offered or enabled in this channel,
457                                                 otherwise <literal>0</literal>.</para>
458                                         </enum>
459                                 </enumlist>
460                         </parameter>
461                 </syntax>
462                 <description />
463         </function>
464         <function name="CHECKSIPDOMAIN" language="en_US">
465                 <synopsis>
466                         Checks if domain is a local domain.
467                 </synopsis>
468                 <syntax>
469                         <parameter name="domain" required="true" />
470                 </syntax>
471                 <description>
472                         <para>This function checks if the <replaceable>domain</replaceable> in the argument is configured
473                         as a local SIP domain that this Asterisk server is configured to handle.
474                         Returns the domain name if it is locally handled, otherwise an empty string.
475                         Check the <literal>domain=</literal> configuration in <filename>sip.conf</filename>.</para>
476                 </description>
477         </function>
478         <manager name="SIPpeers" language="en_US">
479                 <synopsis>
480                         List SIP peers (text format).
481                 </synopsis>
482                 <syntax>
483                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
484                 </syntax>
485                 <description>
486                         <para>Lists SIP peers in text format with details on current status.
487                         Peerlist will follow as separate events, followed by a final event called
488                         PeerlistComplete.</para>
489                 </description>
490         </manager>
491         <manager name="SIPshowpeer" language="en_US">
492                 <synopsis>
493                         show SIP peer (text format).
494                 </synopsis>
495                 <syntax>
496                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
497                         <parameter name="Peer" required="true">
498                                 <para>The peer name you want to check.</para>
499                         </parameter>
500                 </syntax>
501                 <description>
502                         <para>Show one SIP peer with details on current status.</para>
503                 </description>
504         </manager>
505         <manager name="SIPqualifypeer" language="en_US">
506                 <synopsis>
507                         Qualify SIP peers.
508                 </synopsis>
509                 <syntax>
510                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
511                         <parameter name="Peer" required="true">
512                                 <para>The peer name you want to qualify.</para>
513                         </parameter>
514                 </syntax>
515                 <description>
516                         <para>Qualify a SIP peer.</para>
517                 </description>
518         </manager>
519         <manager name="SIPshowregistry" language="en_US">
520                 <synopsis>
521                         Show SIP registrations (text format).
522                 </synopsis>
523                 <syntax>
524                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
525                 </syntax>
526                 <description>
527                         <para>Lists all registration requests and status. Registrations will follow as separate
528                         events. followed by a final event called RegistrationsComplete.</para>
529                 </description>
530         </manager>
531         <manager name="SIPnotify" language="en_US">
532                 <synopsis>
533                         Send a SIP notify.
534                 </synopsis>
535                 <syntax>
536                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
537                         <parameter name="Channel" required="true">
538                                 <para>Peer to receive the notify.</para>
539                         </parameter>
540                         <parameter name="Variable" required="true">
541                                 <para>At least one variable pair must be specified.
542                                 <replaceable>name</replaceable>=<replaceable>value</replaceable></para>
543                         </parameter>
544                 </syntax>
545                 <description>
546                         <para>Sends a SIP Notify event.</para>
547                         <para>All parameters for this event must be specified in the body of this request
548                         via multiple Variable: name=value sequences.</para>
549                 </description>
550         </manager>
551  ***/
552
553 static int min_expiry = DEFAULT_MIN_EXPIRY;        /*!< Minimum accepted registration time */
554 static int max_expiry = DEFAULT_MAX_EXPIRY;        /*!< Maximum accepted registration time */
555 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
556 static int mwi_expiry = DEFAULT_MWI_EXPIRY;
557
558 /*! \brief Global jitterbuffer configuration - by default, jb is disabled */
559 static struct ast_jb_conf default_jbconf =
560 {
561         .flags = 0,
562         .max_size = -1,
563         .resync_threshold = -1,
564         .impl = "",
565         .target_extra = -1,
566 };
567 static struct ast_jb_conf global_jbconf;                /*!< Global jitterbuffer configuration */
568
569 static const char config[] = "sip.conf";                /*!< Main configuration file */
570 static const char notify_config[] = "sip_notify.conf";  /*!< Configuration file for sending Notify with CLI commands to reconfigure or reboot phones */
571
572 /*! \brief Readable descriptions of device states.
573  *  \note Should be aligned to above table as index */
574 static const struct invstate2stringtable {
575         const enum invitestates state;
576         const char *desc;
577 } invitestate2string[] = {
578         {INV_NONE,              "None"  },
579         {INV_CALLING,           "Calling (Trying)"},
580         {INV_PROCEEDING,        "Proceeding "},
581         {INV_EARLY_MEDIA,       "Early media"},
582         {INV_COMPLETED,         "Completed (done)"},
583         {INV_CONFIRMED,         "Confirmed (up)"},
584         {INV_TERMINATED,        "Done"},
585         {INV_CANCELLED,         "Cancelled"}
586 };
587
588 /*! \brief Subscription types that we support. We support
589  * - dialoginfo updates (really device status, not dialog info as was the original intent of the standard)
590  * - SIMPLE presence used for device status
591  * - Voicemail notification subscriptions
592  */
593 static const struct cfsubscription_types {
594         enum subscriptiontype type;
595         const char * const event;
596         const char * const mediatype;
597         const char * const text;
598 } subscription_types[] = {
599         { NONE,            "-",        "unknown",                    "unknown" },
600         /* RFC 4235: SIP Dialog event package */
601         { DIALOG_INFO_XML, "dialog",   "application/dialog-info+xml", "dialog-info+xml" },
602         { CPIM_PIDF_XML,   "presence", "application/cpim-pidf+xml",   "cpim-pidf+xml" },  /* RFC 3863 */
603         { PIDF_XML,        "presence", "application/pidf+xml",        "pidf+xml" },       /* RFC 3863 */
604         { XPIDF_XML,       "presence", "application/xpidf+xml",       "xpidf+xml" },       /* Pre-RFC 3863 with MS additions */
605         { MWI_NOTIFICATION,     "message-summary", "application/simple-message-summary", "mwi" } /* RFC 3842: Mailbox notification */
606 };
607
608 /*! \brief The core structure to setup dialogs. We parse incoming messages by using
609  *  structure and then route the messages according to the type.
610  *
611  *  \note Note that sip_methods[i].id == i must hold or the code breaks
612  */
613 static const struct  cfsip_methods {
614         enum sipmethod id;
615         int need_rtp;           /*!< when this is the 'primary' use for a pvt structure, does it need RTP? */
616         char * const text;
617         enum can_create_dialog can_create;
618 } sip_methods[] = {
619         { SIP_UNKNOWN,   RTP,    "-UNKNOWN-",CAN_CREATE_DIALOG },
620         { SIP_RESPONSE,  NO_RTP, "SIP/2.0",  CAN_NOT_CREATE_DIALOG },
621         { SIP_REGISTER,  NO_RTP, "REGISTER", CAN_CREATE_DIALOG },
622         { SIP_OPTIONS,   NO_RTP, "OPTIONS",  CAN_CREATE_DIALOG },
623         { SIP_NOTIFY,    NO_RTP, "NOTIFY",   CAN_CREATE_DIALOG },
624         { SIP_INVITE,    RTP,    "INVITE",   CAN_CREATE_DIALOG },
625         { SIP_ACK,       NO_RTP, "ACK",      CAN_NOT_CREATE_DIALOG },
626         { SIP_PRACK,     NO_RTP, "PRACK",    CAN_NOT_CREATE_DIALOG },
627         { SIP_BYE,       NO_RTP, "BYE",      CAN_NOT_CREATE_DIALOG },
628         { SIP_REFER,     NO_RTP, "REFER",    CAN_CREATE_DIALOG },
629         { SIP_SUBSCRIBE, NO_RTP, "SUBSCRIBE",CAN_CREATE_DIALOG },
630         { SIP_MESSAGE,   NO_RTP, "MESSAGE",  CAN_CREATE_DIALOG },
631         { SIP_UPDATE,    NO_RTP, "UPDATE",   CAN_NOT_CREATE_DIALOG },
632         { SIP_INFO,      NO_RTP, "INFO",     CAN_NOT_CREATE_DIALOG },
633         { SIP_CANCEL,    NO_RTP, "CANCEL",   CAN_NOT_CREATE_DIALOG },
634         { SIP_PUBLISH,   NO_RTP, "PUBLISH",  CAN_CREATE_DIALOG },
635         { SIP_PING,      NO_RTP, "PING",     CAN_CREATE_DIALOG_UNSUPPORTED_METHOD }
636 };
637
638 /*! \brief Diversion header reasons
639  *
640  * The core defines a bunch of constants used to define
641  * redirecting reasons. This provides a translation table
642  * between those and the strings which may be present in
643  * a SIP Diversion header
644  */
645 static const struct sip_reasons {
646         enum AST_REDIRECTING_REASON code;
647         char * const text;
648 } sip_reason_table[] = {
649         { AST_REDIRECTING_REASON_UNKNOWN, "unknown" },
650         { AST_REDIRECTING_REASON_USER_BUSY, "user-busy" },
651         { AST_REDIRECTING_REASON_NO_ANSWER, "no-answer" },
652         { AST_REDIRECTING_REASON_UNAVAILABLE, "unavailable" },
653         { AST_REDIRECTING_REASON_UNCONDITIONAL, "unconditional" },
654         { AST_REDIRECTING_REASON_TIME_OF_DAY, "time-of-day" },
655         { AST_REDIRECTING_REASON_DO_NOT_DISTURB, "do-not-disturb" },
656         { AST_REDIRECTING_REASON_DEFLECTION, "deflection" },
657         { AST_REDIRECTING_REASON_FOLLOW_ME, "follow-me" },
658         { AST_REDIRECTING_REASON_OUT_OF_ORDER, "out-of-service" },
659         { AST_REDIRECTING_REASON_AWAY, "away" },
660         { AST_REDIRECTING_REASON_CALL_FWD_DTE, "unknown"}
661 };
662
663
664 /*! \name DefaultSettings
665         Default setttings are used as a channel setting and as a default when
666         configuring devices
667 */
668 /*@{*/
669 static char default_language[MAX_LANGUAGE];      /*!< Default language setting for new channels */
670 static char default_callerid[AST_MAX_EXTENSION]; /*!< Default caller ID for sip messages */
671 static char default_mwi_from[80];                /*!< Default caller ID for MWI updates */
672 static char default_fromdomain[AST_MAX_EXTENSION]; /*!< Default domain on outound messages */
673 static int default_fromdomainport;                 /*!< Default domain port on outbound messages */
674 static char default_notifymime[AST_MAX_EXTENSION]; /*!< Default MIME media type for MWI notify messages */
675 static char default_vmexten[AST_MAX_EXTENSION];    /*!< Default From Username on MWI updates */
676 static int default_qualify;                        /*!< Default Qualify= setting */
677 static char default_mohinterpret[MAX_MUSICCLASS];  /*!< Global setting for moh class to use when put on hold */
678 static char default_mohsuggest[MAX_MUSICCLASS];    /*!< Global setting for moh class to suggest when putting
679                                                     *   a bridged channel on hold */
680 static char default_parkinglot[AST_MAX_CONTEXT];   /*!< Parkinglot */
681 static char default_engine[256];                   /*!< Default RTP engine */
682 static int default_maxcallbitrate;                 /*!< Maximum bitrate for call */
683 static struct ast_codec_pref default_prefs;        /*!< Default codec prefs */
684 static unsigned int default_transports;            /*!< Default Transports (enum sip_transport) that are acceptable */
685 static unsigned int default_primary_transport;     /*!< Default primary Transport (enum sip_transport) for outbound connections to devices */
686 /*@}*/
687
688 static struct sip_settings sip_cfg;             /*!< SIP configuration data.
689                                         \note in the future we could have multiple of these (per domain, per device group etc) */
690
691 /*!< use this macro when ast_uri_decode is dependent on pedantic checking to be on. */
692 #define SIP_PEDANTIC_DECODE(str)        \
693         if (sip_cfg.pedanticsipchecking && !ast_strlen_zero(str)) {     \
694                 ast_uri_decode(str);    \
695         }       \
696
697 static unsigned int chan_idx;       /*!< used in naming sip channel */
698 static int global_match_auth_username;    /*!< Match auth username if available instead of From: Default off. */
699
700 static int global_relaxdtmf;        /*!< Relax DTMF */
701 static int global_prematuremediafilter;   /*!< Enable/disable premature frames in a call (causing 183 early media) */
702 static int global_rtptimeout;       /*!< Time out call if no RTP */
703 static int global_rtpholdtimeout;   /*!< Time out call if no RTP during hold */
704 static int global_rtpkeepalive;     /*!< Send RTP keepalives */
705 static int global_reg_timeout;      /*!< Global time between attempts for outbound registrations */
706 static int global_regattempts_max;  /*!< Registration attempts before giving up */
707 static int global_shrinkcallerid;   /*!< enable or disable shrinking of caller id  */
708 static int global_callcounter;      /*!< Enable call counters for all devices. This is currently enabled by setting the peer
709                                      *   call-limit to INT_MAX. When we remove the call-limit from the code, we can make it
710                                      *   with just a boolean flag in the device structure */
711 static unsigned int global_tos_sip;      /*!< IP type of service for SIP packets */
712 static unsigned int global_tos_audio;    /*!< IP type of service for audio RTP packets */
713 static unsigned int global_tos_video;    /*!< IP type of service for video RTP packets */
714 static unsigned int global_tos_text;     /*!< IP type of service for text RTP packets */
715 static unsigned int global_cos_sip;      /*!< 802.1p class of service for SIP packets */
716 static unsigned int global_cos_audio;    /*!< 802.1p class of service for audio RTP packets */
717 static unsigned int global_cos_video;    /*!< 802.1p class of service for video RTP packets */
718 static unsigned int global_cos_text;     /*!< 802.1p class of service for text RTP packets */
719 static unsigned int recordhistory;       /*!< Record SIP history. Off by default */
720 static unsigned int dumphistory;         /*!< Dump history to verbose before destroying SIP dialog */
721 static char global_useragent[AST_MAX_EXTENSION];    /*!< Useragent for the SIP channel */
722 static char global_sdpsession[AST_MAX_EXTENSION];   /*!< SDP session name for the SIP channel */
723 static char global_sdpowner[AST_MAX_EXTENSION];     /*!< SDP owner name for the SIP channel */
724 static int global_authfailureevents;     /*!< Whether we send authentication failure manager events or not. Default no. */
725 static int global_t1;           /*!< T1 time */
726 static int global_t1min;        /*!< T1 roundtrip time minimum */
727 static int global_timer_b;      /*!< Timer B - RFC 3261 Section 17.1.1.2 */
728 static unsigned int global_autoframing; /*!< Turn autoframing on or off. */
729 static int global_qualifyfreq;          /*!< Qualify frequency */
730 static int global_qualify_gap;          /*!< Time between our group of peer pokes */
731 static int global_qualify_peers;        /*!< Number of peers to poke at a given time */
732
733 static enum st_mode global_st_mode;           /*!< Mode of operation for Session-Timers           */
734 static enum st_refresher global_st_refresher; /*!< Session-Timer refresher                        */
735 static int global_min_se;                     /*!< Lowest threshold for session refresh interval  */
736 static int global_max_se;                     /*!< Highest threshold for session refresh interval */
737
738 static int global_dynamic_exclude_static = 0; /*!< Exclude static peers from contact registrations */
739 /*@}*/
740
741 /*!
742  * We use libxml2 in order to parse XML that may appear in the body of a SIP message. Currently,
743  * the only usage is for parsing PIDF bodies of incoming PUBLISH requests in the call-completion
744  * event package. This variable is set at module load time and may be checked at runtime to determine
745  * if XML parsing support was found.
746  */
747 static int can_parse_xml;
748
749 /*! \name Object counters @{
750  *  \bug These counters are not handled in a thread-safe way ast_atomic_fetchadd_int()
751  *  should be used to modify these values. */
752 static int speerobjs = 0;     /*!< Static peers */
753 static int rpeerobjs = 0;     /*!< Realtime peers */
754 static int apeerobjs = 0;     /*!< Autocreated peer objects */
755 static int regobjs = 0;       /*!< Registry objects */
756 /* }@ */
757
758 static struct ast_flags global_flags[3] = {{0}};  /*!< global SIP_ flags */
759 static int global_t38_maxdatagram;                /*!< global T.38 FaxMaxDatagram override */
760
761 static char used_context[AST_MAX_CONTEXT];        /*!< name of automatically created context for unloading */
762
763 AST_MUTEX_DEFINE_STATIC(netlock);
764
765 /*! \brief Protect the monitoring thread, so only one process can kill or start it, and not
766    when it's doing something critical. */
767 AST_MUTEX_DEFINE_STATIC(monlock);
768
769 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
770
771 /*! \brief This is the thread for the monitor which checks for input on the channels
772    which are not currently in use.  */
773 static pthread_t monitor_thread = AST_PTHREADT_NULL;
774
775 static int sip_reloading = FALSE;                       /*!< Flag for avoiding multiple reloads at the same time */
776 static enum channelreloadreason sip_reloadreason;       /*!< Reason for last reload/load of configuration */
777
778 struct sched_context *sched;     /*!< The scheduling context */
779 static struct io_context *io;           /*!< The IO context */
780 static int *sipsock_read_id;            /*!< ID of IO entry for sipsock FD */
781 struct sip_pkt;
782 static AST_LIST_HEAD_STATIC(domain_list, domain);    /*!< The SIP domain list */
783
784 AST_LIST_HEAD_NOLOCK(sip_history_head, sip_history); /*!< history list, entry in sip_pvt */
785
786 static enum sip_debug_e sipdebug;
787
788 /*! \brief extra debugging for 'text' related events.
789  *  At the moment this is set together with sip_debug_console.
790  *  \note It should either go away or be implemented properly.
791  */
792 static int sipdebug_text;
793
794 static const struct _map_x_s referstatusstrings[] = {
795         { REFER_IDLE,      "<none>" },
796         { REFER_SENT,      "Request sent" },
797         { REFER_RECEIVED,  "Request received" },
798         { REFER_CONFIRMED, "Confirmed" },
799         { REFER_ACCEPTED,  "Accepted" },
800         { REFER_RINGING,   "Target ringing" },
801         { REFER_200OK,     "Done" },
802         { REFER_FAILED,    "Failed" },
803         { REFER_NOAUTH,    "Failed - auth failure" },
804         { -1,               NULL} /* terminator */
805 };
806
807 /* --- Hash tables of various objects --------*/
808 #ifdef LOW_MEMORY
809 static const int HASH_PEER_SIZE = 17;
810 static const int HASH_DIALOG_SIZE = 17;
811 #else
812 static const int HASH_PEER_SIZE = 563;  /*!< Size of peer hash table, prime number preferred! */
813 static const int HASH_DIALOG_SIZE = 563;
814 #endif
815
816 static const struct {
817         enum ast_cc_service_type service;
818         const char *service_string;
819 } sip_cc_service_map [] = {
820         [AST_CC_NONE] = { AST_CC_NONE, "" },
821         [AST_CC_CCBS] = { AST_CC_CCBS, "BS" },
822         [AST_CC_CCNR] = { AST_CC_CCNR, "NR" },
823         [AST_CC_CCNL] = { AST_CC_CCNL, "NL" },
824 };
825
826 static enum ast_cc_service_type service_string_to_service_type(const char * const service_string)
827 {
828         enum ast_cc_service_type service;
829         for (service = AST_CC_CCBS; service <= AST_CC_CCNL; ++service) {
830                 if (!strcasecmp(service_string, sip_cc_service_map[service].service_string)) {
831                         return service;
832                 }
833         }
834         return AST_CC_NONE;
835 }
836
837 static const struct {
838         enum sip_cc_notify_state state;
839         const char *state_string;
840 } sip_cc_notify_state_map [] = {
841         [CC_QUEUED] = {CC_QUEUED, "cc-state: queued"},
842         [CC_READY] = {CC_READY, "cc-state: ready"},
843 };
844
845 AST_LIST_HEAD_STATIC(epa_static_data_list, epa_backend);
846
847 static int sip_epa_register(const struct epa_static_data *static_data)
848 {
849         struct epa_backend *backend = ast_calloc(1, sizeof(*backend));
850
851         if (!backend) {
852                 return -1;
853         }
854
855         backend->static_data = static_data;
856
857         AST_LIST_LOCK(&epa_static_data_list);
858         AST_LIST_INSERT_TAIL(&epa_static_data_list, backend, next);
859         AST_LIST_UNLOCK(&epa_static_data_list);
860         return 0;
861 }
862
863 static void cc_handle_publish_error(struct sip_pvt *pvt, const int resp, struct sip_request *req, struct sip_epa_entry *epa_entry);
864
865 static void cc_epa_destructor(void *data)
866 {
867         struct sip_epa_entry *epa_entry = data;
868         struct cc_epa_entry *cc_entry = epa_entry->instance_data;
869         ast_free(cc_entry);
870 }
871
872 static const struct epa_static_data cc_epa_static_data  = {
873         .event = CALL_COMPLETION,
874         .name = "call-completion",
875         .handle_error = cc_handle_publish_error,
876         .destructor = cc_epa_destructor,
877 };
878
879 static const struct epa_static_data *find_static_data(const char * const event_package)
880 {
881         const struct epa_backend *backend = NULL;
882
883         AST_LIST_LOCK(&epa_static_data_list);
884         AST_LIST_TRAVERSE(&epa_static_data_list, backend, next) {
885                 if (!strcmp(backend->static_data->name, event_package)) {
886                         break;
887                 }
888         }
889         AST_LIST_UNLOCK(&epa_static_data_list);
890         return backend ? backend->static_data : NULL;
891 }
892
893 static struct sip_epa_entry *create_epa_entry (const char * const event_package, const char * const destination)
894 {
895         struct sip_epa_entry *epa_entry;
896         const struct epa_static_data *static_data;
897
898         if (!(static_data = find_static_data(event_package))) {
899                 return NULL;
900         }
901
902         if (!(epa_entry = ao2_t_alloc(sizeof(*epa_entry), static_data->destructor, "Allocate new EPA entry"))) {
903                 return NULL;
904         }
905
906         epa_entry->static_data = static_data;
907         ast_copy_string(epa_entry->destination, destination, sizeof(epa_entry->destination));
908         return epa_entry;
909 }
910
911 /*!
912  * Used to create new entity IDs by ESCs.
913  */
914 static int esc_etag_counter;
915 static const int DEFAULT_PUBLISH_EXPIRES = 3600;
916
917 #ifdef HAVE_LIBXML2
918 static int cc_esc_publish_handler(struct sip_pvt *pvt, struct sip_request *req, struct event_state_compositor *esc, struct sip_esc_entry *esc_entry);
919
920 static const struct sip_esc_publish_callbacks cc_esc_publish_callbacks = {
921         .initial_handler = cc_esc_publish_handler,
922         .modify_handler = cc_esc_publish_handler,
923 };
924 #endif
925
926 /*!
927  * \brief The Event State Compositors
928  *
929  * An Event State Compositor is an entity which
930  * accepts PUBLISH requests and acts appropriately
931  * based on these requests.
932  *
933  * The actual event_state_compositor structure is simply
934  * an ao2_container of sip_esc_entrys. When an incoming
935  * PUBLISH is received, we can match the appropriate sip_esc_entry
936  * using the entity ID of the incoming PUBLISH.
937  */
938 static struct event_state_compositor {
939         enum subscriptiontype event;
940         const char * name;
941         const struct sip_esc_publish_callbacks *callbacks;
942         struct ao2_container *compositor;
943 } event_state_compositors [] = {
944 #ifdef HAVE_LIBXML2
945         {CALL_COMPLETION, "call-completion", &cc_esc_publish_callbacks},
946 #endif
947 };
948
949 static const int ESC_MAX_BUCKETS = 37;
950
951 static void esc_entry_destructor(void *obj)
952 {
953         struct sip_esc_entry *esc_entry = obj;
954         if (esc_entry->sched_id > -1) {
955                 AST_SCHED_DEL(sched, esc_entry->sched_id);
956         }
957 }
958
959 static int esc_hash_fn(const void *obj, const int flags)
960 {
961         const struct sip_esc_entry *entry = obj;
962         return ast_str_hash(entry->entity_tag);
963 }
964
965 static int esc_cmp_fn(void *obj, void *arg, int flags)
966 {
967         struct sip_esc_entry *entry1 = obj;
968         struct sip_esc_entry *entry2 = arg;
969
970         return (!strcmp(entry1->entity_tag, entry2->entity_tag)) ? (CMP_MATCH | CMP_STOP) : 0;
971 }
972
973 static struct event_state_compositor *get_esc(const char * const event_package) {
974         int i;
975         for (i = 0; i < ARRAY_LEN(event_state_compositors); i++) {
976                 if (!strcasecmp(event_package, event_state_compositors[i].name)) {
977                         return &event_state_compositors[i];
978                 }
979         }
980         return NULL;
981 }
982
983 static struct sip_esc_entry *get_esc_entry(const char * entity_tag, struct event_state_compositor *esc) {
984         struct sip_esc_entry *entry;
985         struct sip_esc_entry finder;
986
987         ast_copy_string(finder.entity_tag, entity_tag, sizeof(finder.entity_tag));
988
989         entry = ao2_find(esc->compositor, &finder, OBJ_POINTER);
990
991         return entry;
992 }
993
994 static int publish_expire(const void *data)
995 {
996         struct sip_esc_entry *esc_entry = (struct sip_esc_entry *) data;
997         struct event_state_compositor *esc = get_esc(esc_entry->event);
998
999         ast_assert(esc != NULL);
1000
1001         ao2_unlink(esc->compositor, esc_entry);
1002         ao2_ref(esc_entry, -1);
1003         return 0;
1004 }
1005
1006 static void create_new_sip_etag(struct sip_esc_entry *esc_entry, int is_linked)
1007 {
1008         int new_etag = ast_atomic_fetchadd_int(&esc_etag_counter, +1);
1009         struct event_state_compositor *esc = get_esc(esc_entry->event);
1010
1011         ast_assert(esc != NULL);
1012         if (is_linked) {
1013                 ao2_unlink(esc->compositor, esc_entry);
1014         }
1015         snprintf(esc_entry->entity_tag, sizeof(esc_entry->entity_tag), "%d", new_etag);
1016         ao2_link(esc->compositor, esc_entry);
1017 }
1018
1019 static struct sip_esc_entry *create_esc_entry(struct event_state_compositor *esc, struct sip_request *req, const int expires)
1020 {
1021         struct sip_esc_entry *esc_entry;
1022         int expires_ms;
1023
1024         if (!(esc_entry = ao2_alloc(sizeof(*esc_entry), esc_entry_destructor))) {
1025                 return NULL;
1026         }
1027
1028         esc_entry->event = esc->name;
1029
1030         expires_ms = expires * 1000;
1031         /* Bump refcount for scheduler */
1032         ao2_ref(esc_entry, +1);
1033         esc_entry->sched_id = ast_sched_add(sched, expires_ms, publish_expire, esc_entry);
1034
1035         /* Note: This links the esc_entry into the ESC properly */
1036         create_new_sip_etag(esc_entry, 0);
1037
1038         return esc_entry;
1039 }
1040
1041 static int initialize_escs(void)
1042 {
1043         int i, res = 0;
1044         for (i = 0; i < ARRAY_LEN(event_state_compositors); i++) {
1045                 if (!((event_state_compositors[i].compositor) =
1046                                         ao2_container_alloc(ESC_MAX_BUCKETS, esc_hash_fn, esc_cmp_fn))) {
1047                         res = -1;
1048                 }
1049         }
1050         return res;
1051 }
1052
1053 static void destroy_escs(void)
1054 {
1055         int i;
1056         for (i = 0; i < ARRAY_LEN(event_state_compositors); i++) {
1057                 ao2_ref(event_state_compositors[i].compositor, -1);
1058         }
1059 }
1060
1061 /*! \brief
1062  * Here we implement the container for dialogs (sip_pvt), defining
1063  * generic wrapper functions to ease the transition from the current
1064  * implementation (a single linked list) to a different container.
1065  * In addition to a reference to the container, we need functions to lock/unlock
1066  * the container and individual items, and functions to add/remove
1067  * references to the individual items.
1068  */
1069 static struct ao2_container *dialogs;
1070 #define sip_pvt_lock(x) ao2_lock(x)
1071 #define sip_pvt_trylock(x) ao2_trylock(x)
1072 #define sip_pvt_unlock(x) ao2_unlock(x)
1073
1074 /*! \brief  The table of TCP threads */
1075 static struct ao2_container *threadt;
1076
1077 /*! \brief  The peer list: Users, Peers and Friends */
1078 static struct ao2_container *peers;
1079 static struct ao2_container *peers_by_ip;
1080
1081 /*! \brief  The register list: Other SIP proxies we register with and receive calls from */
1082 static struct ast_register_list {
1083         ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
1084         int recheck;
1085 } regl;
1086
1087 /*! \brief  The MWI subscription list */
1088 static struct ast_subscription_mwi_list {
1089         ASTOBJ_CONTAINER_COMPONENTS(struct sip_subscription_mwi);
1090 } submwil;
1091 static int temp_pvt_init(void *);
1092 static void temp_pvt_cleanup(void *);
1093
1094 /*! \brief A per-thread temporary pvt structure */
1095 AST_THREADSTORAGE_CUSTOM(ts_temp_pvt, temp_pvt_init, temp_pvt_cleanup);
1096
1097 /*! \brief Authentication list for realm authentication
1098  * \todo Move the sip_auth list to AST_LIST */
1099 static struct sip_auth *authl = NULL;
1100
1101 /* --- Sockets and networking --------------*/
1102
1103 /*! \brief Main socket for UDP SIP communication.
1104  *
1105  * sipsock is shared between the SIP manager thread (which handles reload
1106  * requests), the udp io handler (sipsock_read()) and the user routines that
1107  * issue udp writes (using __sip_xmit()).
1108  * The socket is -1 only when opening fails (this is a permanent condition),
1109  * or when we are handling a reload() that changes its address (this is
1110  * a transient situation during which we might have a harmless race, see
1111  * below). Because the conditions for the race to be possible are extremely
1112  * rare, we don't want to pay the cost of locking on every I/O.
1113  * Rather, we remember that when the race may occur, communication is
1114  * bound to fail anyways, so we just live with this event and let
1115  * the protocol handle this above us.
1116  */
1117 static int sipsock  = -1;
1118
1119 struct sockaddr_in bindaddr;    /*!< UDP: The address we bind to */
1120
1121 /*! \brief our (internal) default address/port to put in SIP/SDP messages
1122  *  internip is initialized picking a suitable address from one of the
1123  * interfaces, and the same port number we bind to. It is used as the
1124  * default address/port in SIP messages, and as the default address
1125  * (but not port) in SDP messages.
1126  */
1127 static struct sockaddr_in internip;
1128
1129 /*! \brief our external IP address/port for SIP sessions.
1130  * externip.sin_addr is only set when we know we might be behind
1131  * a NAT, and this is done using a variety of (mutually exclusive)
1132  * ways from the config file:
1133  *
1134  * + with "externip = host[:port]" we specify the address/port explicitly.
1135  *   The address is looked up only once when (re)loading the config file;
1136  *
1137  * + with "externhost = host[:port]" we do a similar thing, but the
1138  *   hostname is stored in externhost, and the hostname->IP mapping
1139  *   is refreshed every 'externrefresh' seconds;
1140  *
1141  * + with "stunaddr = host[:port]" we run queries every externrefresh seconds
1142  *   to the specified server, and store the result in externip.
1143  *
1144  * Other variables (externhost, externexpire, externrefresh) are used
1145  * to support the above functions.
1146  */
1147 static struct sockaddr_in externip;       /*!< External IP address if we are behind NAT */
1148 static struct sockaddr_in media_address;  /*!< External RTP IP address if we are behind NAT */
1149
1150 static char externhost[MAXHOSTNAMELEN];   /*!< External host name */
1151 static time_t externexpire;             /*!< Expiration counter for re-resolving external host name in dynamic DNS */
1152 static int externrefresh = 10;          /*!< Refresh timer for DNS-based external address (dyndns) */
1153 static struct sockaddr_in stunaddr;     /*!< stun server address */
1154 static uint16_t externtcpport;          /*!< external tcp port */ 
1155 static uint16_t externtlsport;          /*!< external tls port */
1156
1157 /*! \brief  List of local networks
1158  * We store "localnet" addresses from the config file into an access list,
1159  * marked as 'DENY', so the call to ast_apply_ha() will return
1160  * AST_SENSE_DENY for 'local' addresses, and AST_SENSE_ALLOW for 'non local'
1161  * (i.e. presumably public) addresses.
1162  */
1163 static struct ast_ha *localaddr;    /*!< List of local networks, on the same side of NAT as this Asterisk */
1164
1165 static int ourport_tcp;             /*!< The port used for TCP connections */
1166 static int ourport_tls;             /*!< The port used for TCP/TLS connections */
1167 static struct sockaddr_in debugaddr;
1168
1169 static struct ast_config *notify_types = NULL;    /*!< The list of manual NOTIFY types we know how to send */
1170
1171 /*! some list management macros. */
1172
1173 #define UNLINK(element, head, prev) do {        \
1174         if (prev)                               \
1175                 (prev)->next = (element)->next; \
1176         else                                    \
1177                 (head) = (element)->next;       \
1178         } while (0)
1179
1180 /*---------------------------- Forward declarations of functions in chan_sip.c */
1181 /* Note: This is added to help splitting up chan_sip.c into several files
1182         in coming releases. */
1183
1184 /*--- PBX interface functions */
1185 static struct ast_channel *sip_request_call(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause);
1186 static int sip_devicestate(void *data);
1187 static int sip_sendtext(struct ast_channel *ast, const char *text);
1188 static int sip_call(struct ast_channel *ast, char *dest, int timeout);
1189 static int sip_sendhtml(struct ast_channel *chan, int subclass, const char *data, int datalen);
1190 static int sip_hangup(struct ast_channel *ast);
1191 static int sip_answer(struct ast_channel *ast);
1192 static struct ast_frame *sip_read(struct ast_channel *ast);
1193 static int sip_write(struct ast_channel *ast, struct ast_frame *frame);
1194 static int sip_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
1195 static int sip_transfer(struct ast_channel *ast, const char *dest);
1196 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
1197 static int sip_senddigit_begin(struct ast_channel *ast, char digit);
1198 static int sip_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration);
1199 static int sip_setoption(struct ast_channel *chan, int option, void *data, int datalen);
1200 static int sip_queryoption(struct ast_channel *chan, int option, void *data, int *datalen);
1201 static const char *sip_get_callid(struct ast_channel *chan);
1202
1203 static int handle_request_do(struct sip_request *req, struct sockaddr_in *sin);
1204 static int sip_standard_port(enum sip_transport type, int port);
1205 static int sip_prepare_socket(struct sip_pvt *p);
1206
1207 /*--- Transmitting responses and requests */
1208 static int sipsock_read(int *id, int fd, short events, void *ignore);
1209 static int __sip_xmit(struct sip_pvt *p, struct ast_str *data, int len);
1210 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, struct ast_str *data, int len, int fatal, int sipmethod);
1211 static void add_cc_call_info_to_response(struct sip_pvt *p, struct sip_request *resp);
1212 static int __transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
1213 static int retrans_pkt(const void *data);
1214 static int transmit_response_using_temp(ast_string_field callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method, const struct sip_request *req, const char *msg);
1215 static int transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req);
1216 static int transmit_response_reliable(struct sip_pvt *p, const char *msg, const struct sip_request *req);
1217 static int transmit_response_with_date(struct sip_pvt *p, const char *msg, const struct sip_request *req);
1218 static int transmit_response_with_sdp(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable, int oldsdp, int rpid);
1219 static int transmit_response_with_unsupported(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *unsupported);
1220 static int transmit_response_with_auth(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *rand, enum xmittype reliable, const char *header, int stale);
1221 static int transmit_provisional_response(struct sip_pvt *p, const char *msg, const struct sip_request *req, int with_sdp);
1222 static int transmit_response_with_allow(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
1223 static void transmit_fake_auth_response(struct sip_pvt *p, int sipmethod, struct sip_request *req, enum xmittype reliable);
1224 static int transmit_request(struct sip_pvt *p, int sipmethod, int inc, enum xmittype reliable, int newbranch);
1225 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch);
1226 static int transmit_publish(struct sip_epa_entry *epa_entry, enum sip_publish_type publish_type, const char * const explicit_uri);
1227 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sdp, int init, const char * const explicit_uri);
1228 static int transmit_reinvite_with_sdp(struct sip_pvt *p, int t38version, int oldsdp);
1229 static int transmit_info_with_aoc(struct sip_pvt *p, struct ast_aoc_decoded *decoded);
1230 static int transmit_info_with_digit(struct sip_pvt *p, const char digit, unsigned int duration);
1231 static int transmit_info_with_vidupdate(struct sip_pvt *p);
1232 static int transmit_message_with_text(struct sip_pvt *p, const char *text);
1233 static int transmit_refer(struct sip_pvt *p, const char *dest);
1234 static int transmit_notify_with_mwi(struct sip_pvt *p, int newmsgs, int oldmsgs, const char *vmexten);
1235 static int transmit_notify_with_sipfrag(struct sip_pvt *p, int cseq, char *message, int terminate);
1236 static int transmit_cc_notify(struct ast_cc_agent *agent, struct sip_pvt *subscription, enum sip_cc_notify_state state);
1237 static int transmit_register(struct sip_registry *r, int sipmethod, const char *auth, const char *authheader);
1238 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno);
1239 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno);
1240 static void copy_request(struct sip_request *dst, const struct sip_request *src);
1241 static void receive_message(struct sip_pvt *p, struct sip_request *req);
1242 static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req, char **name, char **number, int set_call_forward);
1243 static int sip_send_mwi_to_peer(struct sip_peer *peer, const struct ast_event *event, int cache_only);
1244
1245 /* Misc dialog routines */
1246 static int __sip_autodestruct(const void *data);
1247 static void *registry_unref(struct sip_registry *reg, char *tag);
1248 static int update_call_counter(struct sip_pvt *fup, int event);
1249 static int auto_congest(const void *arg);
1250 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method);
1251 static void free_old_route(struct sip_route *route);
1252 static void list_route(struct sip_route *route);
1253 static void build_route(struct sip_pvt *p, struct sip_request *req, int backwards);
1254 static enum check_auth_result register_verify(struct sip_pvt *p, struct sockaddr_in *sin,
1255                                               struct sip_request *req, const char *uri);
1256 static struct sip_pvt *get_sip_pvt_byid_locked(const char *callid, const char *totag, const char *fromtag);
1257 static void check_pendings(struct sip_pvt *p);
1258 static void *sip_park_thread(void *stuff);
1259 static int sip_park(struct ast_channel *chan1, struct ast_channel *chan2, struct sip_request *req, int seqno);
1260 static int sip_sipredirect(struct sip_pvt *p, const char *dest);
1261 static int is_method_allowed(unsigned int *allowed_methods, enum sipmethod method);
1262
1263 /*--- Codec handling / SDP */
1264 static void try_suggested_sip_codec(struct sip_pvt *p);
1265 static const char *get_sdp_iterate(int* start, struct sip_request *req, const char *name);
1266 static char get_sdp_line(int *start, int stop, struct sip_request *req, const char **value);
1267 static int find_sdp(struct sip_request *req);
1268 static int process_sdp(struct sip_pvt *p, struct sip_request *req, int t38action);
1269 static int process_sdp_o(const char *o, struct sip_pvt *p);
1270 static int process_sdp_c(const char *c, struct ast_hostent *hp);
1271 static int process_sdp_a_sendonly(const char *a, int *sendonly);
1272 static int process_sdp_a_audio(const char *a, struct sip_pvt *p, struct ast_rtp_codecs *newaudiortp, int *last_rtpmap_codec);
1273 static int process_sdp_a_video(const char *a, struct sip_pvt *p, struct ast_rtp_codecs *newvideortp, int *last_rtpmap_codec);
1274 static int process_sdp_a_text(const char *a, struct sip_pvt *p, struct ast_rtp_codecs *newtextrtp, char *red_fmtp, int *red_num_gen, int *red_data_pt, int *last_rtpmap_codec);
1275 static int process_sdp_a_image(const char *a, struct sip_pvt *p);
1276 static void add_codec_to_sdp(const struct sip_pvt *p, format_t codec,
1277                              struct ast_str **m_buf, struct ast_str **a_buf,
1278                              int debug, int *min_packet_size);
1279 static void add_noncodec_to_sdp(const struct sip_pvt *p, int format,
1280                                 struct ast_str **m_buf, struct ast_str **a_buf,
1281                                 int debug);
1282 static enum sip_result add_sdp(struct sip_request *resp, struct sip_pvt *p, int oldsdp, int add_audio, int add_t38);
1283 static void do_setnat(struct sip_pvt *p);
1284 static void stop_media_flows(struct sip_pvt *p);
1285
1286 /*--- Authentication stuff */
1287 static int reply_digest(struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len);
1288 static int build_reply_digest(struct sip_pvt *p, int method, char *digest, int digest_len);
1289 static enum check_auth_result check_auth(struct sip_pvt *p, struct sip_request *req, const char *username,
1290                                          const char *secret, const char *md5secret, int sipmethod,
1291                                          const char *uri, enum xmittype reliable, int ignore);
1292 static enum check_auth_result check_user_full(struct sip_pvt *p, struct sip_request *req,
1293                                               int sipmethod, const char *uri, enum xmittype reliable,
1294                                               struct sockaddr_in *sin, struct sip_peer **authpeer);
1295 static int check_user(struct sip_pvt *p, struct sip_request *req, int sipmethod, const char *uri, enum xmittype reliable, struct sockaddr_in *sin);
1296
1297 /*--- Domain handling */
1298 static int check_sip_domain(const char *domain, char *context, size_t len); /* Check if domain is one of our local domains */
1299 static int add_sip_domain(const char *domain, const enum domain_mode mode, const char *context);
1300 static void clear_sip_domains(void);
1301
1302 /*--- SIP realm authentication */
1303 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, const char *configuration, int lineno);
1304 static int clear_realm_authentication(struct sip_auth *authlist);       /* Clear realm authentication list (at reload) */
1305 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, const char *realm);
1306
1307 /*--- Misc functions */
1308 static void check_rtp_timeout(struct sip_pvt *dialog, time_t t);
1309 static int sip_do_reload(enum channelreloadreason reason);
1310 static int reload_config(enum channelreloadreason reason);
1311 static int expire_register(const void *data);
1312 static void *do_monitor(void *data);
1313 static int restart_monitor(void);
1314 static void peer_mailboxes_to_str(struct ast_str **mailbox_str, struct sip_peer *peer);
1315 static struct ast_variable *copy_vars(struct ast_variable *src);
1316 /* static int sip_addrcmp(char *name, struct sockaddr_in *sin); Support for peer matching */
1317 static int sip_refer_allocate(struct sip_pvt *p);
1318 static int sip_notify_allocate(struct sip_pvt *p);
1319 static void ast_quiet_chan(struct ast_channel *chan);
1320 static int attempt_transfer(struct sip_dual *transferer, struct sip_dual *target);
1321 static int do_magic_pickup(struct ast_channel *channel, const char *extension, const char *context);
1322
1323 /*--- Device monitoring and Device/extension state/event handling */
1324 static int cb_extensionstate(char *context, char* exten, int state, void *data);
1325 static int sip_devicestate(void *data);
1326 static int sip_poke_noanswer(const void *data);
1327 static int sip_poke_peer(struct sip_peer *peer, int force);
1328 static void sip_poke_all_peers(void);
1329 static void sip_peer_hold(struct sip_pvt *p, int hold);
1330 static void mwi_event_cb(const struct ast_event *, void *);
1331
1332 /*--- Applications, functions, CLI and manager command helpers */
1333 static const char *sip_nat_mode(const struct sip_pvt *p);
1334 static char *sip_show_inuse(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1335 static char *transfermode2str(enum transfermodes mode) attribute_const;
1336 static int peer_status(struct sip_peer *peer, char *status, int statuslen);
1337 static char *sip_show_sched(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1338 static char * _sip_show_peers(int fd, int *total, struct mansession *s, const struct message *m, int argc, const char *argv[]);
1339 static char *sip_show_peers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1340 static char *sip_show_objects(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1341 static void  print_group(int fd, ast_group_t group, int crlf);
1342 static const char *dtmfmode2str(int mode) attribute_const;
1343 static int str2dtmfmode(const char *str) attribute_unused;
1344 static const char *insecure2str(int mode) attribute_const;
1345 static void cleanup_stale_contexts(char *new, char *old);
1346 static void print_codec_to_cli(int fd, struct ast_codec_pref *pref);
1347 static const char *domain_mode_to_text(const enum domain_mode mode);
1348 static char *sip_show_domains(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1349 static char *_sip_show_peer(int type, int fd, struct mansession *s, const struct message *m, int argc, const char *argv[]);
1350 static char *sip_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1351 static char *_sip_qualify_peer(int type, int fd, struct mansession *s, const struct message *m, int argc, const char *argv[]);
1352 static char *sip_qualify_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1353 static char *sip_show_registry(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1354 static char *sip_unregister(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1355 static char *sip_show_settings(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1356 static char *sip_show_mwi(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1357 static const char *subscription_type2str(enum subscriptiontype subtype) attribute_pure;
1358 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
1359 static char *complete_sip_peer(const char *word, int state, int flags2);
1360 static char *complete_sip_registered_peer(const char *word, int state, int flags2);
1361 static char *complete_sip_show_history(const char *line, const char *word, int pos, int state);
1362 static char *complete_sip_show_peer(const char *line, const char *word, int pos, int state);
1363 static char *complete_sip_unregister(const char *line, const char *word, int pos, int state);
1364 static char *complete_sipnotify(const char *line, const char *word, int pos, int state);
1365 static char *sip_show_channel(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1366 static char *sip_show_channelstats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1367 static char *sip_show_history(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1368 static char *sip_do_debug_ip(int fd, const char *arg);
1369 static char *sip_do_debug_peer(int fd, const char *arg);
1370 static char *sip_do_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1371 static char *sip_cli_notify(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1372 static char *sip_set_history(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1373 static int sip_dtmfmode(struct ast_channel *chan, const char *data);
1374 static int sip_addheader(struct ast_channel *chan, const char *data);
1375 static int sip_do_reload(enum channelreloadreason reason);
1376 static char *sip_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1377
1378 /*--- Debugging
1379         Functions for enabling debug per IP or fully, or enabling history logging for
1380         a SIP dialog
1381 */
1382 static void sip_dump_history(struct sip_pvt *dialog);   /* Dump history to debuglog at end of dialog, before destroying data */
1383 static inline int sip_debug_test_addr(const struct sockaddr_in *addr);
1384 static inline int sip_debug_test_pvt(struct sip_pvt *p);
1385 static void append_history_full(struct sip_pvt *p, const char *fmt, ...);
1386 static void sip_dump_history(struct sip_pvt *dialog);
1387
1388 /*--- Device object handling */
1389 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime, int devstate_only);
1390 static int update_call_counter(struct sip_pvt *fup, int event);
1391 static void sip_destroy_peer(struct sip_peer *peer);
1392 static void sip_destroy_peer_fn(void *peer);
1393 static void set_peer_defaults(struct sip_peer *peer);
1394 static struct sip_peer *temp_peer(const char *name);
1395 static void register_peer_exten(struct sip_peer *peer, int onoff);
1396 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime, int forcenamematch, int devstate_only, int transport);
1397 static int sip_poke_peer_s(const void *data);
1398 static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, struct sip_peer *p, struct sip_request *req);
1399 static void reg_source_db(struct sip_peer *peer);
1400 static void destroy_association(struct sip_peer *peer);
1401 static void set_insecure_flags(struct ast_flags *flags, const char *value, int lineno);
1402 static int handle_common_options(struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v);
1403 static void set_socket_transport(struct sip_socket *socket, int transport);
1404
1405 /* Realtime device support */
1406 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, const char *useragent, int expirey, unsigned short deprecated_username, int lastms);
1407 static void update_peer(struct sip_peer *p, int expire);
1408 static struct ast_variable *get_insecure_variable_from_config(struct ast_config *config);
1409 static const char *get_name_from_variable(struct ast_variable *var, const char *newpeername);
1410 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin, int devstate_only);
1411 static char *sip_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
1412
1413 /*--- Internal UA client handling (outbound registrations) */
1414 static void ast_sip_ouraddrfor(struct in_addr *them, struct sockaddr_in *us, struct sip_pvt *p);
1415 static void sip_registry_destroy(struct sip_registry *reg);
1416 static int sip_register(const char *value, int lineno);
1417 static const char *regstate2str(enum sipregistrystate regstate) attribute_const;
1418 static int sip_reregister(const void *data);
1419 static int __sip_do_register(struct sip_registry *r);
1420 static int sip_reg_timeout(const void *data);
1421 static void sip_send_all_registers(void);
1422 static int sip_reinvite_retry(const void *data);
1423
1424 /*--- Parsing SIP requests and responses */
1425 static void append_date(struct sip_request *req);       /* Append date to SIP packet */
1426 static int determine_firstline_parts(struct sip_request *req);
1427 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
1428 static const char *gettag(const struct sip_request *req, const char *header, char *tagbuf, int tagbufsize);
1429 static int find_sip_method(const char *msg);
1430 static unsigned int parse_allowed_methods(struct sip_request *req);
1431 static unsigned int set_pvt_allowed_methods(struct sip_pvt *pvt, struct sip_request *req);
1432 static int parse_request(struct sip_request *req);
1433 static const char *get_header(const struct sip_request *req, const char *name);
1434 static const char *referstatus2str(enum referstatus rstatus) attribute_pure;
1435 static int method_match(enum sipmethod id, const char *name);
1436 static void parse_copy(struct sip_request *dst, const struct sip_request *src);
1437 static const char *find_alias(const char *name, const char *_default);
1438 static const char *__get_header(const struct sip_request *req, const char *name, int *start);
1439 static int lws2sws(char *msgbuf, int len);
1440 static void extract_uri(struct sip_pvt *p, struct sip_request *req);
1441 static char *remove_uri_parameters(char *uri);
1442 static int get_refer_info(struct sip_pvt *transferer, struct sip_request *outgoing_req);
1443 static int get_also_info(struct sip_pvt *p, struct sip_request *oreq);
1444 static int parse_ok_contact(struct sip_pvt *pvt, struct sip_request *req);
1445 static int set_address_from_contact(struct sip_pvt *pvt);
1446 static void check_via(struct sip_pvt *p, struct sip_request *req);
1447 static int get_rpid(struct sip_pvt *p, struct sip_request *oreq);
1448 static int get_rdnis(struct sip_pvt *p, struct sip_request *oreq, char **name, char **number, int *reason);
1449 static enum sip_get_dest_result get_destination(struct sip_pvt *p, struct sip_request *oreq, int *cc_recall_core_id);
1450 static int get_msg_text(char *buf, int len, struct sip_request *req, int addnewline);
1451 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int timeout);
1452 static void update_connectedline(struct sip_pvt *p, const void *data, size_t datalen);
1453 static void update_redirecting(struct sip_pvt *p, const void *data, size_t datalen);
1454 static void change_redirecting_information(struct sip_pvt *p, struct sip_request *req, struct ast_party_redirecting *redirecting, int set_call_forward);
1455 static int get_domain(const char *str, char *domain, int len);
1456 static void get_realm(struct sip_pvt *p, const struct sip_request *req);
1457
1458 /*-- TCP connection handling ---*/
1459 static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_session_instance *tcptls_session);
1460 static void *sip_tcp_worker_fn(void *);
1461
1462 /*--- Constructing requests and responses */
1463 static void initialize_initreq(struct sip_pvt *p, struct sip_request *req);
1464 static int init_req(struct sip_request *req, int sipmethod, const char *recip);
1465 static void deinit_req(struct sip_request *req);
1466 static int reqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, int seqno, int newbranch);
1467 static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, const char * const explicit_uri);
1468 static int init_resp(struct sip_request *resp, const char *msg);
1469 static inline int resp_needs_contact(const char *msg, enum sipmethod method);
1470 static int respprep(struct sip_request *resp, struct sip_pvt *p, const char *msg, const struct sip_request *req);
1471 static const struct sockaddr_in *sip_real_dst(const struct sip_pvt *p);
1472 static void build_via(struct sip_pvt *p);
1473 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer);
1474 static int create_addr(struct sip_pvt *dialog, const char *opeer, struct sockaddr_in *sin, int newdialog, struct sockaddr_in *remote_address);
1475 static char *generate_random_string(char *buf, size_t size);
1476 static void build_callid_pvt(struct sip_pvt *pvt);
1477 static void build_callid_registry(struct sip_registry *reg, struct in_addr ourip, const char *fromdomain);
1478 static void make_our_tag(char *tagbuf, size_t len);
1479 static int add_header(struct sip_request *req, const char *var, const char *value);
1480 static int add_content(struct sip_request *req, const char *line);
1481 static int finalize_content(struct sip_request *req);
1482 static int add_text(struct sip_request *req, const char *text);
1483 static int add_digit(struct sip_request *req, char digit, unsigned int duration, int mode);
1484 static int add_rpid(struct sip_request *req, struct sip_pvt *p);
1485 static int add_vidupdate(struct sip_request *req);
1486 static void add_route(struct sip_request *req, struct sip_route *route);
1487 static int copy_header(struct sip_request *req, const struct sip_request *orig, const char *field);
1488 static int copy_all_header(struct sip_request *req, const struct sip_request *orig, const char *field);
1489 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, const struct sip_request *orig, const char *field);
1490 static void set_destination(struct sip_pvt *p, char *uri);
1491 static void append_date(struct sip_request *req);
1492 static void build_contact(struct sip_pvt *p);
1493
1494 /*------Request handling functions */
1495 static int handle_incoming(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int *recount, int *nounlock);
1496 static int handle_request_update(struct sip_pvt *p, struct sip_request *req);
1497 static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct sockaddr_in *sin, int *recount, const char *e, int *nounlock);
1498 static int handle_request_refer(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, int *nounlock);
1499 static int handle_request_bye(struct sip_pvt *p, struct sip_request *req);
1500 static int handle_request_register(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, const char *e);
1501 static int handle_request_cancel(struct sip_pvt *p, struct sip_request *req);
1502 static int handle_request_message(struct sip_pvt *p, struct sip_request *req);
1503 static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, const char *e);
1504 static void handle_request_info(struct sip_pvt *p, struct sip_request *req);
1505 static int handle_request_options(struct sip_pvt *p, struct sip_request *req);
1506 static int handle_invite_replaces(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct sockaddr_in *sin, int *nounlock);
1507 static int handle_request_notify(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, const char *e);
1508 static int local_attended_transfer(struct sip_pvt *transferer, struct sip_dual *current, struct sip_request *req, int seqno, int *nounlock);
1509
1510 /*------Response handling functions */
1511 static void handle_response_publish(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
1512 static void handle_response_invite(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
1513 static void handle_response_notify(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
1514 static void handle_response_refer(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
1515 static void handle_response_subscribe(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
1516 static int handle_response_register(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
1517 static void handle_response(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
1518
1519 /*------ SRTP Support -------- */
1520 static int setup_srtp(struct sip_srtp **srtp);
1521 static int process_crypto(struct sip_pvt *p, struct ast_rtp_instance *rtp, struct sip_srtp **srtp, const char *a);
1522
1523 /*------ T38 Support --------- */
1524 static int transmit_response_with_t38_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
1525 static struct ast_udptl *sip_get_udptl_peer(struct ast_channel *chan);
1526 static int sip_set_udptl_peer(struct ast_channel *chan, struct ast_udptl *udptl);
1527 static void change_t38_state(struct sip_pvt *p, int state);
1528
1529 /*------ Session-Timers functions --------- */
1530 static void proc_422_rsp(struct sip_pvt *p, struct sip_request *rsp);
1531 static int  proc_session_timer(const void *vp);
1532 static void stop_session_timer(struct sip_pvt *p);
1533 static void start_session_timer(struct sip_pvt *p);
1534 static void restart_session_timer(struct sip_pvt *p);
1535 static const char *strefresher2str(enum st_refresher r);
1536 static int parse_session_expires(const char *p_hdrval, int *const p_interval, enum st_refresher *const p_ref);
1537 static int parse_minse(const char *p_hdrval, int *const p_interval);
1538 static int st_get_se(struct sip_pvt *, int max);
1539 static enum st_refresher st_get_refresher(struct sip_pvt *);
1540 static enum st_mode st_get_mode(struct sip_pvt *);
1541 static struct sip_st_dlg* sip_st_alloc(struct sip_pvt *const p);
1542
1543 /*------- RTP Glue functions -------- */
1544 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_rtp_instance *vinstance, struct ast_rtp_instance *tinstance, format_t codecs, int nat_active);
1545
1546 /*!--- SIP MWI Subscription support */
1547 static int sip_subscribe_mwi(const char *value, int lineno);
1548 static void sip_subscribe_mwi_destroy(struct sip_subscription_mwi *mwi);
1549 static void sip_send_all_mwi_subscriptions(void);
1550 static int sip_subscribe_mwi_do(const void *data);
1551 static int __sip_subscribe_mwi_do(struct sip_subscription_mwi *mwi);
1552
1553 /*! \brief Definition of this channel for PBX channel registration */
1554 const struct ast_channel_tech sip_tech = {
1555         .type = "SIP",
1556         .description = "Session Initiation Protocol (SIP)",
1557         .capabilities = AST_FORMAT_AUDIO_MASK,  /* all audio formats */
1558         .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER,
1559         .requester = sip_request_call,                  /* called with chan unlocked */
1560         .devicestate = sip_devicestate,                 /* called with chan unlocked (not chan-specific) */
1561         .call = sip_call,                       /* called with chan locked */
1562         .send_html = sip_sendhtml,
1563         .hangup = sip_hangup,                   /* called with chan locked */
1564         .answer = sip_answer,                   /* called with chan locked */
1565         .read = sip_read,                       /* called with chan locked */
1566         .write = sip_write,                     /* called with chan locked */
1567         .write_video = sip_write,               /* called with chan locked */
1568         .write_text = sip_write,
1569         .indicate = sip_indicate,               /* called with chan locked */
1570         .transfer = sip_transfer,               /* called with chan locked */
1571         .fixup = sip_fixup,                     /* called with chan locked */
1572         .send_digit_begin = sip_senddigit_begin,        /* called with chan unlocked */
1573         .send_digit_end = sip_senddigit_end,
1574         .bridge = ast_rtp_instance_bridge,                      /* XXX chan unlocked ? */
1575         .early_bridge = ast_rtp_instance_early_bridge,
1576         .send_text = sip_sendtext,              /* called with chan locked */
1577         .func_channel_read = sip_acf_channel_read,
1578         .setoption = sip_setoption,
1579         .queryoption = sip_queryoption,
1580         .get_pvt_uniqueid = sip_get_callid,
1581 };
1582
1583 /*! \brief This version of the sip channel tech has no send_digit_begin
1584  * callback so that the core knows that the channel does not want
1585  * DTMF BEGIN frames.
1586  * The struct is initialized just before registering the channel driver,
1587  * and is for use with channels using SIP INFO DTMF.
1588  */
1589 struct ast_channel_tech sip_tech_info;
1590
1591 static int sip_cc_agent_init(struct ast_cc_agent *agent, struct ast_channel *chan);
1592 static int sip_cc_agent_start_offer_timer(struct ast_cc_agent *agent);
1593 static int sip_cc_agent_stop_offer_timer(struct ast_cc_agent *agent);
1594 static void sip_cc_agent_ack(struct ast_cc_agent *agent);
1595 static int sip_cc_agent_status_request(struct ast_cc_agent *agent);
1596 static int sip_cc_agent_start_monitoring(struct ast_cc_agent *agent);
1597 static int sip_cc_agent_recall(struct ast_cc_agent *agent);
1598 static void sip_cc_agent_destructor(struct ast_cc_agent *agent);
1599
1600 static struct ast_cc_agent_callbacks sip_cc_agent_callbacks = {
1601         .type = "SIP",
1602         .init = sip_cc_agent_init,
1603         .start_offer_timer = sip_cc_agent_start_offer_timer,
1604         .stop_offer_timer = sip_cc_agent_stop_offer_timer,
1605         .ack = sip_cc_agent_ack,
1606         .status_request = sip_cc_agent_status_request,
1607         .start_monitoring = sip_cc_agent_start_monitoring,
1608         .callee_available = sip_cc_agent_recall,
1609         .destructor = sip_cc_agent_destructor,
1610 };
1611
1612 static int find_by_notify_uri_helper(void *obj, void *arg, int flags)
1613 {
1614         struct ast_cc_agent *agent = obj;
1615         struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
1616         const char *uri = arg;
1617
1618         return !strcmp(agent_pvt->notify_uri, uri) ? CMP_MATCH | CMP_STOP : 0;
1619 }
1620
1621 static struct ast_cc_agent *find_sip_cc_agent_by_notify_uri(const char * const uri)
1622 {
1623         struct ast_cc_agent *agent = ast_cc_agent_callback(0, find_by_notify_uri_helper, (char *)uri, "SIP");
1624         return agent;
1625 }
1626
1627 static int find_by_subscribe_uri_helper(void *obj, void *arg, int flags)
1628 {
1629         struct ast_cc_agent *agent = obj;
1630         struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
1631         const char *uri = arg;
1632
1633         return !strcmp(agent_pvt->subscribe_uri, uri) ? CMP_MATCH | CMP_STOP : 0;
1634 }
1635
1636 static struct ast_cc_agent *find_sip_cc_agent_by_subscribe_uri(const char * const uri)
1637 {
1638         struct ast_cc_agent *agent = ast_cc_agent_callback(0, find_by_subscribe_uri_helper, (char *)uri, "SIP");
1639         return agent;
1640 }
1641
1642 static int find_by_callid_helper(void *obj, void *arg, int flags)
1643 {
1644         struct ast_cc_agent *agent = obj;
1645         struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
1646         struct sip_pvt *call_pvt = arg;
1647
1648         return !strcmp(agent_pvt->original_callid, call_pvt->callid) ? CMP_MATCH | CMP_STOP : 0;
1649 }
1650
1651 static struct ast_cc_agent *find_sip_cc_agent_by_original_callid(struct sip_pvt *pvt)
1652 {
1653         struct ast_cc_agent *agent = ast_cc_agent_callback(0, find_by_callid_helper, pvt, "SIP");
1654         return agent;
1655 }
1656
1657 static int sip_cc_agent_init(struct ast_cc_agent *agent, struct ast_channel *chan)
1658 {
1659         struct sip_cc_agent_pvt *agent_pvt = ast_calloc(1, sizeof(*agent_pvt));
1660         struct sip_pvt *call_pvt = chan->tech_pvt;
1661
1662         if (!agent_pvt) {
1663                 return -1;
1664         }
1665
1666         ast_assert(!strcmp(chan->tech->type, "SIP"));
1667
1668         ast_copy_string(agent_pvt->original_callid, call_pvt->callid, sizeof(agent_pvt->original_callid));
1669         ast_copy_string(agent_pvt->original_exten, call_pvt->exten, sizeof(agent_pvt->original_exten));
1670         agent_pvt->offer_timer_id = -1;
1671         agent->private_data = agent_pvt;
1672         sip_pvt_lock(call_pvt);
1673         ast_set_flag(&call_pvt->flags[0], SIP_OFFER_CC);
1674         sip_pvt_unlock(call_pvt);
1675         return 0;
1676 }
1677
1678 static int sip_offer_timer_expire(const void *data)
1679 {
1680         struct ast_cc_agent *agent = (struct ast_cc_agent *) data;
1681         struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
1682
1683         agent_pvt->offer_timer_id = -1;
1684
1685         return ast_cc_failed(agent->core_id, "SIP agent %s's offer timer expired", agent->device_name);
1686 }
1687
1688 static int sip_cc_agent_start_offer_timer(struct ast_cc_agent *agent)
1689 {
1690         struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
1691         int when;
1692
1693         when = ast_get_cc_offer_timer(agent->cc_params) * 1000;
1694         agent_pvt->offer_timer_id = ast_sched_add(sched, when, sip_offer_timer_expire, agent);
1695         return 0;
1696 }
1697
1698 static int sip_cc_agent_stop_offer_timer(struct ast_cc_agent *agent)
1699 {
1700         struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
1701
1702         AST_SCHED_DEL(sched, agent_pvt->offer_timer_id);
1703         return 0;
1704 }
1705
1706 static void sip_cc_agent_ack(struct ast_cc_agent *agent)
1707 {
1708         struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
1709
1710         sip_pvt_lock(agent_pvt->subscribe_pvt);
1711         ast_set_flag(&agent_pvt->subscribe_pvt->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
1712         transmit_response(agent_pvt->subscribe_pvt, "200 OK", &agent_pvt->subscribe_pvt->initreq);
1713         transmit_cc_notify(agent, agent_pvt->subscribe_pvt, CC_QUEUED);
1714         sip_pvt_unlock(agent_pvt->subscribe_pvt);
1715         agent_pvt->is_available = TRUE;
1716 }
1717
1718 static int sip_cc_agent_status_request(struct ast_cc_agent *agent)
1719 {
1720         struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
1721         enum ast_device_state state = agent_pvt->is_available ? AST_DEVICE_NOT_INUSE : AST_DEVICE_INUSE;
1722         return ast_cc_agent_status_response(agent->core_id, state);
1723 }
1724
1725 static int sip_cc_agent_start_monitoring(struct ast_cc_agent *agent)
1726 {
1727         /* To start monitoring just means to wait for an incoming PUBLISH
1728          * to tell us that the caller has become available again. No special
1729          * action is needed
1730          */
1731         return 0;
1732 }
1733
1734 static int sip_cc_agent_recall(struct ast_cc_agent *agent)
1735 {
1736         struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
1737         /* If we have received a PUBLISH beforehand stating that the caller in question
1738          * is not available, we can save ourself a bit of effort here and just report
1739          * the caller as busy
1740          */
1741         if (!agent_pvt->is_available) {
1742                 return ast_cc_agent_caller_busy(agent->core_id, "Caller %s is busy, reporting to the core",
1743                                 agent->device_name);
1744         }
1745         /* Otherwise, we transmit a NOTIFY to the caller and await either
1746          * a PUBLISH or an INVITE
1747          */
1748         sip_pvt_lock(agent_pvt->subscribe_pvt);
1749         transmit_cc_notify(agent, agent_pvt->subscribe_pvt, CC_READY);
1750         sip_pvt_unlock(agent_pvt->subscribe_pvt);
1751         return 0;
1752 }
1753
1754 static void sip_cc_agent_destructor(struct ast_cc_agent *agent)
1755 {
1756         struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
1757
1758         if (!agent_pvt) {
1759                 /* The agent constructor probably failed. */
1760                 return;
1761         }
1762
1763         sip_cc_agent_stop_offer_timer(agent);
1764         if (agent_pvt->subscribe_pvt) {
1765                 sip_pvt_lock(agent_pvt->subscribe_pvt);
1766                 if (!ast_test_flag(&agent_pvt->subscribe_pvt->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED)) {
1767                         /* If we haven't sent a 200 OK for the SUBSCRIBE dialog yet, then we need to send a response letting
1768                          * the subscriber know something went wrong
1769                          */
1770                         transmit_response(agent_pvt->subscribe_pvt, "500 Internal Server Error", &agent_pvt->subscribe_pvt->initreq);
1771                 }
1772                 sip_pvt_unlock(agent_pvt->subscribe_pvt);
1773                 agent_pvt->subscribe_pvt = dialog_unref(agent_pvt->subscribe_pvt, "SIP CC agent destructor: Remove ref to subscription");
1774         }
1775         ast_free(agent_pvt);
1776 }
1777
1778 struct ao2_container *sip_monitor_instances;
1779
1780 static int sip_monitor_instance_hash_fn(const void *obj, const int flags)
1781 {
1782         const struct sip_monitor_instance *monitor_instance = obj;
1783         return monitor_instance->core_id;
1784 }
1785
1786 static int sip_monitor_instance_cmp_fn(void *obj, void *arg, int flags)
1787 {
1788         struct sip_monitor_instance *monitor_instance1 = obj;
1789         struct sip_monitor_instance *monitor_instance2 = arg;
1790
1791         return monitor_instance1->core_id == monitor_instance2->core_id ? CMP_MATCH | CMP_STOP : 0;
1792 }
1793
1794 static void sip_monitor_instance_destructor(void *data)
1795 {
1796         struct sip_monitor_instance *monitor_instance = data;
1797         if (monitor_instance->subscription_pvt) {
1798                 sip_pvt_lock(monitor_instance->subscription_pvt);
1799                 monitor_instance->subscription_pvt->expiry = 0;
1800                 transmit_invite(monitor_instance->subscription_pvt, SIP_SUBSCRIBE, FALSE, 0, monitor_instance->subscribe_uri);
1801                 sip_pvt_unlock(monitor_instance->subscription_pvt);
1802                 dialog_unref(monitor_instance->subscription_pvt, "Unref monitor instance ref of subscription pvt");
1803         }
1804         if (monitor_instance->suspension_entry) {
1805                 monitor_instance->suspension_entry->body[0] = '\0';
1806                 transmit_publish(monitor_instance->suspension_entry, SIP_PUBLISH_REMOVE ,monitor_instance->notify_uri);
1807                 ao2_t_ref(monitor_instance->suspension_entry, -1, "Decrementing suspension entry refcount in sip_monitor_instance_destructor");
1808         }
1809         ast_string_field_free_memory(monitor_instance);
1810 }
1811
1812 static struct sip_monitor_instance *sip_monitor_instance_init(int core_id, const char * const subscribe_uri, const char * const peername, const char * const device_name)
1813 {
1814         struct sip_monitor_instance *monitor_instance = ao2_alloc(sizeof(*monitor_instance), sip_monitor_instance_destructor);
1815
1816         if (!monitor_instance) {
1817                 return NULL;
1818         }
1819
1820         if (ast_string_field_init(monitor_instance, 256)) {
1821                 ao2_ref(monitor_instance, -1);
1822                 return NULL;
1823         }
1824
1825         ast_string_field_set(monitor_instance, subscribe_uri, subscribe_uri);
1826         ast_string_field_set(monitor_instance, peername, peername);
1827         ast_string_field_set(monitor_instance, device_name, device_name);
1828         monitor_instance->core_id = core_id;
1829         ao2_link(sip_monitor_instances, monitor_instance);
1830         return monitor_instance;
1831 }
1832
1833 static int find_sip_monitor_instance_by_subscription_pvt(void *obj, void *arg, int flags)
1834 {
1835         struct sip_monitor_instance *monitor_instance = obj;
1836         return monitor_instance->subscription_pvt == arg ? CMP_MATCH | CMP_STOP : 0;
1837 }
1838
1839 static int find_sip_monitor_instance_by_suspension_entry(void *obj, void *arg, int flags)
1840 {
1841         struct sip_monitor_instance *monitor_instance = obj;
1842         return monitor_instance->suspension_entry == arg ? CMP_MATCH | CMP_STOP : 0;
1843 }
1844
1845 static int sip_cc_monitor_request_cc(struct ast_cc_monitor *monitor, int *available_timer_id);
1846 static int sip_cc_monitor_suspend(struct ast_cc_monitor *monitor);
1847 static int sip_cc_monitor_unsuspend(struct ast_cc_monitor *monitor);
1848 static int sip_cc_monitor_cancel_available_timer(struct ast_cc_monitor *monitor, int *sched_id);
1849 static void sip_cc_monitor_destructor(void *private_data);
1850
1851 static struct ast_cc_monitor_callbacks sip_cc_monitor_callbacks = {
1852         .type = "SIP",
1853         .request_cc = sip_cc_monitor_request_cc,
1854         .suspend = sip_cc_monitor_suspend,
1855         .unsuspend = sip_cc_monitor_unsuspend,
1856         .cancel_available_timer = sip_cc_monitor_cancel_available_timer,
1857         .destructor = sip_cc_monitor_destructor,
1858 };
1859
1860 static int sip_cc_monitor_request_cc(struct ast_cc_monitor *monitor, int *available_timer_id)
1861 {
1862         struct sip_monitor_instance *monitor_instance = monitor->private_data;
1863         enum ast_cc_service_type service = monitor->service_offered;
1864         int when;
1865
1866         if (!monitor_instance) {
1867                 return -1;
1868         }
1869
1870         if (!(monitor_instance->subscription_pvt = sip_alloc(NULL, NULL, 0, SIP_SUBSCRIBE, NULL))) {
1871                 return -1;
1872         }
1873
1874         when = service == AST_CC_CCBS ? ast_get_ccbs_available_timer(monitor->interface->config_params) :
1875                 ast_get_ccnr_available_timer(monitor->interface->config_params);
1876
1877         sip_pvt_lock(monitor_instance->subscription_pvt);
1878         create_addr(monitor_instance->subscription_pvt, monitor_instance->peername, 0, 1, NULL);
1879         ast_sip_ouraddrfor(&monitor_instance->subscription_pvt->sa.sin_addr, &monitor_instance->subscription_pvt->ourip, monitor_instance->subscription_pvt);
1880         monitor_instance->subscription_pvt->subscribed = CALL_COMPLETION;
1881         monitor_instance->subscription_pvt->expiry = when;
1882
1883         transmit_invite(monitor_instance->subscription_pvt, SIP_SUBSCRIBE, FALSE, 2, monitor_instance->subscribe_uri);
1884         sip_pvt_unlock(monitor_instance->subscription_pvt);
1885
1886         ao2_t_ref(monitor, +1, "Adding a ref to the monitor for the scheduler");
1887         *available_timer_id = ast_sched_add(sched, when * 1000, ast_cc_available_timer_expire, monitor);
1888         return 0;
1889 }
1890
1891 static int construct_pidf_body(enum sip_cc_publish_state state, char *pidf_body, size_t size, const char *presentity)
1892 {
1893         struct ast_str *body = ast_str_alloca(size);
1894         char tuple_id[32];
1895
1896         generate_random_string(tuple_id, sizeof(tuple_id));
1897
1898         /* We'll make this a bare-bones pidf body. In state_notify_build_xml, the PIDF
1899          * body gets a lot more extra junk that isn't necessary, so we'll leave it out here.
1900          */
1901         ast_str_append(&body, 0, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
1902         /* XXX The entity attribute is currently set to the peer name associated with the
1903          * dialog. This is because we currently only call this function for call-completion
1904          * PUBLISH bodies. In such cases, the entity is completely disregarded. For other
1905          * event packages, it may be crucial to have a proper URI as the presentity so this
1906          * should be revisited as support is expanded.
1907          */
1908         ast_str_append(&body, 0, "<presence xmlns=\"urn:ietf:params:xml:ns:pidf\" entity=\"%s\">\n", presentity);
1909         ast_str_append(&body, 0, "<tuple id=\"%s\">\n", tuple_id);
1910         ast_str_append(&body, 0, "<status><basic>%s</basic></status>\n", state == CC_OPEN ? "open" : "closed");
1911         ast_str_append(&body, 0, "</tuple>\n");
1912         ast_str_append(&body, 0, "</presence>\n");
1913         ast_copy_string(pidf_body, ast_str_buffer(body), size);
1914         return 0;
1915 }
1916
1917 static int sip_cc_monitor_suspend(struct ast_cc_monitor *monitor)
1918 {
1919         struct sip_monitor_instance *monitor_instance = monitor->private_data;
1920         enum sip_publish_type publish_type;
1921         struct cc_epa_entry *cc_entry;
1922
1923         if (!monitor_instance) {
1924                 return -1;
1925         }
1926
1927         if (!monitor_instance->suspension_entry) {
1928                 /* We haven't yet allocated the suspension entry, so let's give it a shot */
1929                 if (!(monitor_instance->suspension_entry = create_epa_entry("call-completion", monitor_instance->peername))) {
1930                         ast_log(LOG_WARNING, "Unable to allocate sip EPA entry for call-completion\n");
1931                         ao2_ref(monitor_instance, -1);
1932                         return -1;
1933                 }
1934                 if (!(cc_entry = ast_calloc(1, sizeof(*cc_entry)))) {
1935                         ast_log(LOG_WARNING, "Unable to allocate space for instance data of EPA entry for call-completion\n");
1936                         ao2_ref(monitor_instance, -1);
1937                         return -1;
1938                 }
1939                 cc_entry->core_id = monitor->core_id;
1940                 monitor_instance->suspension_entry->instance_data = cc_entry;
1941                 publish_type = SIP_PUBLISH_INITIAL;
1942         } else {
1943                 publish_type = SIP_PUBLISH_MODIFY;
1944                 cc_entry = monitor_instance->suspension_entry->instance_data;
1945         }
1946
1947         cc_entry->current_state = CC_CLOSED;
1948
1949         if (ast_strlen_zero(monitor_instance->notify_uri)) {
1950                 /* If we have no set notify_uri, then what this means is that we have
1951                  * not received a NOTIFY from this destination stating that he is
1952                  * currently available.
1953                  *
1954                  * This situation can arise when the core calls the suspend callbacks
1955                  * of multiple destinations. If one of the other destinations aside
1956                  * from this one notified Asterisk that he is available, then there
1957                  * is no reason to take any suspension action on this device. Rather,
1958                  * we should return now and if we receive a NOTIFY while monitoring
1959                  * is still "suspended" then we can immediately respond with the
1960                  * proper PUBLISH to let this endpoint know what is going on.
1961                  */
1962                 return 0;
1963         }
1964         construct_pidf_body(CC_CLOSED, monitor_instance->suspension_entry->body, sizeof(monitor_instance->suspension_entry->body), monitor_instance->peername);
1965         return transmit_publish(monitor_instance->suspension_entry, publish_type, monitor_instance->notify_uri);
1966 }
1967
1968 static int sip_cc_monitor_unsuspend(struct ast_cc_monitor *monitor)
1969 {
1970         struct sip_monitor_instance *monitor_instance = monitor->private_data;
1971         struct cc_epa_entry *cc_entry;
1972
1973         if (!monitor_instance) {
1974                 return -1;
1975         }
1976
1977         ast_assert(monitor_instance->suspension_entry != NULL);
1978
1979         cc_entry = monitor_instance->suspension_entry->instance_data;
1980         cc_entry->current_state = CC_OPEN;
1981         if (ast_strlen_zero(monitor_instance->notify_uri)) {
1982                 /* This means we are being asked to unsuspend a call leg we never
1983                  * sent a PUBLISH on. As such, there is no reason to send another
1984                  * PUBLISH at this point either. We can just return instead.
1985                  */
1986                 return 0;
1987         }
1988         construct_pidf_body(CC_OPEN, monitor_instance->suspension_entry->body, sizeof(monitor_instance->suspension_entry->body), monitor_instance->peername);
1989         return transmit_publish(monitor_instance->suspension_entry, SIP_PUBLISH_MODIFY, monitor_instance->notify_uri);
1990 }
1991
1992 static int sip_cc_monitor_cancel_available_timer(struct ast_cc_monitor *monitor, int *sched_id)
1993 {
1994         if (*sched_id != -1) {
1995                 AST_SCHED_DEL(sched, *sched_id);
1996                 ao2_t_ref(monitor, -1, "Removing scheduler's reference to the monitor");
1997         }
1998         return 0;
1999 }
2000
2001 static void sip_cc_monitor_destructor(void *private_data)
2002 {
2003         struct sip_monitor_instance *monitor_instance = private_data;
2004         ao2_unlink(sip_monitor_instances, monitor_instance);
2005         ast_module_unref(ast_module_info->self);
2006 }
2007
2008 static int sip_get_cc_information(struct sip_request *req, char *subscribe_uri, size_t size, enum ast_cc_service_type *service)
2009 {
2010         char *call_info = ast_strdupa(get_header(req, "Call-Info"));
2011         char *uri;
2012         char *purpose;
2013         char *service_str;
2014         static const char cc_purpose[] = "purpose=call-completion";
2015         static const int cc_purpose_len = sizeof(cc_purpose) - 1;
2016
2017         if (ast_strlen_zero(call_info)) {
2018                 /* No Call-Info present. Definitely no CC offer */
2019                 return -1;
2020         }
2021
2022         uri = strsep(&call_info, ";");
2023
2024         while ((purpose = strsep(&call_info, ";"))) {
2025                 if (!strncmp(purpose, cc_purpose, cc_purpose_len)) {
2026                         break;
2027                 }
2028         }
2029         if (!purpose) {
2030                 /* We didn't find the appropriate purpose= parameter. Oh well */
2031                 return -1;
2032         }
2033
2034         /* Okay, call-completion has been offered. Let's figure out what type of service this is */
2035         while ((service_str = strsep(&call_info, ";"))) {
2036                 if (!strncmp(service_str, "m=", 2)) {
2037                         break;
2038                 }
2039         }
2040         if (!service_str) {
2041                 /* So they didn't offer a particular service, We'll just go with CCBS since it really
2042                  * doesn't matter anyway
2043                  */
2044                 service_str = "BS";
2045         } else {
2046                 /* We already determined that there is an "m=" so no need to check
2047                  * the result of this strsep
2048                  */
2049                 strsep(&service_str, "=");
2050         }
2051
2052         if ((*service = service_string_to_service_type(service_str)) == AST_CC_NONE) {
2053                 /* Invalid service offered */
2054                 return -1;
2055         }
2056
2057         ast_copy_string(subscribe_uri, get_in_brackets(uri), size);
2058
2059         return 0;
2060 }
2061
2062 /*
2063  * \brief Determine what, if any, CC has been offered and queue a CC frame if possible
2064  *
2065  * After taking care of some formalities to be sure that this call is eligible for CC,
2066  * we first try to see if we can make use of native CC. We grab the information from
2067  * the passed-in sip_request (which is always a response to an INVITE). If we can
2068  * use native CC monitoring for the call, then so be it.
2069  *
2070  * If native cc monitoring is not possible or not supported, then we will instead attempt
2071  * to use generic monitoring. Falling back to generic from a failed attempt at using native
2072  * monitoring will only work if the monitor policy of the endpoint is "always"
2073  *
2074  * \param pvt The current dialog. Contains CC parameters for the endpoint
2075  * \param req The response to the INVITE we want to inspect
2076  * \param service The service to use if generic monitoring is to be used. For native
2077  * monitoring, we get the service from the SIP response itself
2078  */
2079 static void sip_handle_cc(struct sip_pvt *pvt, struct sip_request *req, enum ast_cc_service_type service)
2080 {
2081         enum ast_cc_monitor_policies monitor_policy = ast_get_cc_monitor_policy(pvt->cc_params);
2082         int core_id;
2083         char interface_name[AST_CHANNEL_NAME];
2084
2085         if (monitor_policy == AST_CC_MONITOR_NEVER) {
2086                 /* Don't bother, just return */
2087                 return;
2088         }
2089
2090         if ((core_id = ast_cc_get_current_core_id(pvt->owner)) == -1) {
2091                 /* For some reason, CC is invalid, so don't try it! */
2092                 return;
2093         }
2094
2095         ast_channel_get_device_name(pvt->owner, interface_name, sizeof(interface_name));
2096
2097         if (monitor_policy == AST_CC_MONITOR_ALWAYS || monitor_policy == AST_CC_MONITOR_NATIVE) {
2098                 char subscribe_uri[SIPBUFSIZE];
2099                 char device_name[AST_CHANNEL_NAME];
2100                 enum ast_cc_service_type offered_service;
2101                 struct sip_monitor_instance *monitor_instance;
2102                 if (sip_get_cc_information(req, subscribe_uri, sizeof(subscribe_uri), &offered_service)) {
2103                         /* If CC isn't being offered to us, or for some reason the CC offer is
2104                          * not formatted correctly, then it may still be possible to use generic
2105                          * call completion since the monitor policy may be "always"
2106                          */
2107                         goto generic;
2108                 }
2109                 ast_channel_get_device_name(pvt->owner, device_name, sizeof(device_name));
2110                 if (!(monitor_instance = sip_monitor_instance_init(core_id, subscribe_uri, pvt->peername, device_name))) {
2111                         /* Same deal. We can try using generic still */
2112                         goto generic;
2113                 }
2114                 /* We bump the refcount of chan_sip because once we queue this frame, the CC core
2115                  * will have a reference to callbacks in this module. We decrement the module
2116                  * refcount once the monitor destructor is called
2117                  */
2118                 ast_module_ref(ast_module_info->self);
2119                 ast_queue_cc_frame(pvt->owner, "SIP", pvt->dialstring, offered_service, monitor_instance);
2120                 ao2_ref(monitor_instance, -1);
2121                 return;
2122         }
2123
2124 generic:
2125         if (monitor_policy == AST_CC_MONITOR_GENERIC || monitor_policy == AST_CC_MONITOR_ALWAYS) {
2126                 ast_queue_cc_frame(pvt->owner, AST_CC_GENERIC_MONITOR_TYPE, interface_name, service, NULL);
2127         }
2128 }
2129
2130 /*! \brief Working TLS connection configuration */
2131 static struct ast_tls_config sip_tls_cfg;
2132
2133 /*! \brief Default TLS connection configuration */
2134 static struct ast_tls_config default_tls_cfg;
2135
2136 /*! \brief The TCP server definition */
2137 static struct ast_tcptls_session_args sip_tcp_desc = {
2138         .accept_fd = -1,
2139         .master = AST_PTHREADT_NULL,
2140         .tls_cfg = NULL,
2141         .poll_timeout = -1,
2142         .name = "SIP TCP server",
2143         .accept_fn = ast_tcptls_server_root,
2144         .worker_fn = sip_tcp_worker_fn,
2145 };
2146
2147 /*! \brief The TCP/TLS server definition */
2148 static struct ast_tcptls_session_args sip_tls_desc = {
2149         .accept_fd = -1,
2150         .master = AST_PTHREADT_NULL,
2151         .tls_cfg = &sip_tls_cfg,
2152         .poll_timeout = -1,
2153         .name = "SIP TLS server",
2154         .accept_fn = ast_tcptls_server_root,
2155         .worker_fn = sip_tcp_worker_fn,
2156 };
2157
2158 /*! \brief Append to SIP dialog history
2159         \return Always returns 0 */
2160 #define append_history(p, event, fmt , args... )        append_history_full(p, "%-15s " fmt, event, ## args)
2161
2162 struct sip_pvt *dialog_ref_debug(struct sip_pvt *p, char *tag, char *file, int line, const char *func)
2163 {
2164         if (p)
2165 #ifdef REF_DEBUG
2166                 __ao2_ref_debug(p, 1, tag, file, line, func);
2167 #else
2168                 ao2_ref(p, 1);
2169 #endif
2170         else
2171                 ast_log(LOG_ERROR, "Attempt to Ref a null pointer\n");
2172         return p;
2173 }
2174
2175 struct sip_pvt *dialog_unref_debug(struct sip_pvt *p, char *tag, char *file, int line, const char *func)
2176 {
2177         if (p)
2178 #ifdef REF_DEBUG
2179                 __ao2_ref_debug(p, -1, tag, file, line, func);
2180 #else
2181                 ao2_ref(p, -1);
2182 #endif
2183         return NULL;
2184 }
2185
2186 /*! \brief map from an integer value to a string.
2187  * If no match is found, return errorstring
2188  */
2189 static const char *map_x_s(const struct _map_x_s *table, int x, const char *errorstring)
2190 {
2191         const struct _map_x_s *cur;
2192
2193         for (cur = table; cur->s; cur++)
2194                 if (cur->x == x)
2195                         return cur->s;
2196         return errorstring;
2197 }
2198
2199 /*! \brief map from a string to an integer value, case insensitive.
2200  * If no match is found, return errorvalue.
2201  */
2202 static int map_s_x(const struct _map_x_s *table, const char *s, int errorvalue)
2203 {
2204         const struct _map_x_s *cur;
2205
2206         for (cur = table; cur->s; cur++)
2207                 if (!strcasecmp(cur->s, s))
2208                         return cur->x;
2209         return errorvalue;
2210 }
2211
2212 static enum AST_REDIRECTING_REASON sip_reason_str_to_code(const char *text)
2213 {
2214         enum AST_REDIRECTING_REASON ast = AST_REDIRECTING_REASON_UNKNOWN;
2215         int i;
2216
2217         for (i = 0; i < ARRAY_LEN(sip_reason_table); ++i) {
2218                 if (!strcasecmp(text, sip_reason_table[i].text)) {
2219                         ast = sip_reason_table[i].code;
2220                         break;
2221                 }
2222         }
2223
2224         return ast;
2225 }
2226
2227 static const char *sip_reason_code_to_str(enum AST_REDIRECTING_REASON code)
2228 {
2229         if (code >= 0 && code < ARRAY_LEN(sip_reason_table)) {
2230                 return sip_reason_table[code].text;
2231         }
2232
2233         return "unknown";
2234 }
2235
2236 /*!
2237  * \brief generic function for determining if a correct transport is being
2238  * used to contact a peer
2239  *
2240  * this is done as a macro so that the "tmpl" var can be passed either a
2241  * sip_request or a sip_peer
2242  */
2243 #define check_request_transport(peer, tmpl) ({ \
2244         int ret = 0; \
2245         if (peer->socket.type == tmpl->socket.type) \
2246                 ; \
2247         else if (!(peer->transports & tmpl->socket.type)) {\
2248                 ast_log(LOG_ERROR, \
2249                         "'%s' is not a valid transport for '%s'. we only use '%s'! ending call.\n", \
2250                         get_transport(tmpl->socket.type), peer->name, get_transport_list(peer->transports) \
2251                         ); \
2252                 ret = 1; \
2253         } else if (peer->socket.type & SIP_TRANSPORT_TLS) { \
2254                 ast_log(LOG_WARNING, \
2255                         "peer '%s' HAS NOT USED (OR SWITCHED TO) TLS in favor of '%s' (but this was allowed in sip.conf)!\n", \
2256                         peer->name, get_transport(tmpl->socket.type) \
2257                 ); \
2258         } else { \
2259                 ast_debug(1, \
2260                         "peer '%s' has contacted us over %s even though we prefer %s.\n", \
2261                         peer->name, get_transport(tmpl->socket.type), get_transport(peer->socket.type) \
2262                 ); \
2263         }\
2264         (ret); \
2265 })
2266
2267 /*! \brief
2268  * duplicate a list of channel variables, \return the copy.
2269  */
2270 static struct ast_variable *copy_vars(struct ast_variable *src)
2271 {
2272         struct ast_variable *res = NULL, *tmp, *v = NULL;
2273
2274         for (v = src ; v ; v = v->next) {
2275                 if ((tmp = ast_variable_new(v->name, v->value, v->file))) {
2276                         tmp->next = res;
2277                         res = tmp;
2278                 }
2279         }
2280         return res;
2281 }
2282
2283 static void tcptls_packet_destructor(void *obj)
2284 {
2285         struct tcptls_packet *packet = obj;
2286
2287         ast_free(packet->data);
2288 }
2289
2290 static void sip_tcptls_client_args_destructor(void *obj)
2291 {
2292         struct ast_tcptls_session_args *args = obj;
2293         if (args->tls_cfg) {
2294                 ast_free(args->tls_cfg->certfile);
2295                 ast_free(args->tls_cfg->pvtfile);
2296                 ast_free(args->tls_cfg->cipher);
2297                 ast_free(args->tls_cfg->cafile);
2298                 ast_free(args->tls_cfg->capath);
2299         }
2300         ast_free(args->tls_cfg);
2301         ast_free((char *) args->name);
2302 }
2303
2304 static void sip_threadinfo_destructor(void *obj)
2305 {
2306         struct sip_threadinfo *th = obj;
2307         struct tcptls_packet *packet;
2308         if (th->alert_pipe[1] > -1) {
2309                 close(th->alert_pipe[0]);
2310         }
2311         if (th->alert_pipe[1] > -1) {
2312                 close(th->alert_pipe[1]);
2313         }
2314         th->alert_pipe[0] = th->alert_pipe[1] = -1;
2315
2316         while ((packet = AST_LIST_REMOVE_HEAD(&th->packet_q, entry))) {
2317                 ao2_t_ref(packet, -1, "thread destruction, removing packet from frame queue");
2318         }
2319
2320         if (th->tcptls_session) {
2321                 ao2_t_ref(th->tcptls_session, -1, "remove tcptls_session for sip_threadinfo object");
2322         }
2323 }
2324
2325 /*! \brief creates a sip_threadinfo object and links it into the threadt table. */
2326 static struct sip_threadinfo *sip_threadinfo_create(struct ast_tcptls_session_instance *tcptls_session, int transport)
2327 {
2328         struct sip_threadinfo *th;
2329
2330         if (!tcptls_session || !(th = ao2_alloc(sizeof(*th), sip_threadinfo_destructor))) {
2331                 return NULL;
2332         }
2333
2334         th->alert_pipe[0] = th->alert_pipe[1] = -1;
2335
2336         if (pipe(th->alert_pipe) == -1) {
2337                 ao2_t_ref(th, -1, "Failed to open alert pipe on sip_threadinfo");
2338                 ast_log(LOG_ERROR, "Could not create sip alert pipe in tcptls thread, error %s\n", strerror(errno));
2339                 return NULL;
2340         }
2341         ao2_t_ref(tcptls_session, +1, "tcptls_session ref for sip_threadinfo object");
2342         th->tcptls_session = tcptls_session;
2343         th->type = transport ? transport : (tcptls_session->ssl ? SIP_TRANSPORT_TLS: SIP_TRANSPORT_TCP);
2344         ao2_t_link(threadt, th, "Adding new tcptls helper thread");
2345         ao2_t_ref(th, -1, "Decrementing threadinfo ref from alloc, only table ref remains");
2346         return th;
2347 }
2348
2349 /*! \brief used to indicate to a tcptls thread that data is ready to be written */
2350 static int sip_tcptls_write(struct ast_tcptls_session_instance *tcptls_session, const void *buf, size_t len)
2351 {
2352         int res = len;
2353         struct sip_threadinfo *th = NULL;
2354         struct tcptls_packet *packet = NULL;
2355         struct sip_threadinfo tmp = {
2356                 .tcptls_session = tcptls_session,
2357         };
2358         enum sip_tcptls_alert alert = TCPTLS_ALERT_DATA;
2359
2360         if (!tcptls_session) {
2361                 return XMIT_ERROR;
2362         }
2363
2364         ast_mutex_lock(&tcptls_session->lock);
2365
2366         if ((tcptls_session->fd == -1) ||
2367                 !(th = ao2_t_find(threadt, &tmp, OBJ_POINTER, "ao2_find, getting sip_threadinfo in tcp helper thread")) ||
2368                 !(packet = ao2_alloc(sizeof(*packet), tcptls_packet_destructor)) ||
2369                 !(packet->data = ast_str_create(len))) {
2370                 goto tcptls_write_setup_error;
2371         }
2372
2373         /* goto tcptls_write_error should _NOT_ be used beyond this point */
2374         ast_str_set(&packet->data, 0, "%s", (char *) buf);
2375         packet->len = len;
2376
2377         /* alert tcptls thread handler that there is a packet to be sent.
2378          * must lock the thread info object to guarantee control of the
2379          * packet queue */
2380         ao2_lock(th);
2381         if (write(th->alert_pipe[1], &alert, sizeof(alert)) == -1) {
2382                 ast_log(LOG_ERROR, "write() to alert pipe failed: %s\n", strerror(errno));
2383                 ao2_t_ref(packet, -1, "could not write to alert pipe, remove packet");
2384                 packet = NULL;
2385                 res = XMIT_ERROR;
2386         } else { /* it is safe to queue the frame after issuing the alert when we hold the threadinfo lock */
2387                 AST_LIST_INSERT_TAIL(&th->packet_q, packet, entry);
2388         }
2389         ao2_unlock(th);
2390
2391         ast_mutex_unlock(&tcptls_session->lock);
2392         ao2_t_ref(th, -1, "In sip_tcptls_write, unref threadinfo object after finding it");
2393         return res;
2394
2395 tcptls_write_setup_error:
2396         if (th) {
2397                 ao2_t_ref(th, -1, "In sip_tcptls_write, unref threadinfo obj, could not create packet");
2398         }
2399         if (packet) {
2400                 ao2_t_ref(packet, -1, "could not allocate packet's data");
2401         }
2402         ast_mutex_unlock(&tcptls_session->lock);
2403
2404         return XMIT_ERROR;
2405 }
2406
2407 /*! \brief SIP TCP connection handler */
2408 static void *sip_tcp_worker_fn(void *data)
2409 {
2410         struct ast_tcptls_session_instance *tcptls_session = data;
2411
2412         return _sip_tcp_helper_thread(NULL, tcptls_session);
2413 }
2414
2415 /*! \brief SIP TCP thread management function
2416         This function reads from the socket, parses the packet into a request
2417 */
2418 static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_session_instance *tcptls_session)
2419 {
2420         int res, cl;
2421         struct sip_request req = { 0, } , reqcpy = { 0, };
2422         struct sip_threadinfo *me = NULL;
2423         char buf[1024] = "";
2424         struct pollfd fds[2] = { { 0 }, { 0 }, };
2425         struct ast_tcptls_session_args *ca = NULL;
2426
2427         /* If this is a server session, then the connection has already been setup,
2428          * simply create the threadinfo object so we can access this thread for writing.
2429          * 
2430          * if this is a client connection more work must be done.
2431          * 1. We own the parent session args for a client connection.  This pointer needs
2432          *    to be held on to so we can decrement it's ref count on thread destruction.
2433          * 2. The threadinfo object was created before this thread was launched, however
2434          *    it must be found within the threadt table.
2435          * 3. Last, the tcptls_session must be started.
2436          */
2437         if (!tcptls_session->client) {
2438                 if (!(me = sip_threadinfo_create(tcptls_session, tcptls_session->ssl ? SIP_TRANSPORT_TLS : SIP_TRANSPORT_TCP))) {
2439                         goto cleanup;
2440                 }
2441                 ao2_t_ref(me, +1, "Adding threadinfo ref for tcp_helper_thread");
2442         } else {
2443                 struct sip_threadinfo tmp = {
2444                         .tcptls_session = tcptls_session,
2445                 };
2446
2447                 if ((!(ca = tcptls_session->parent)) ||
2448                         (!(me = ao2_t_find(threadt, &tmp, OBJ_POINTER, "ao2_find, getting sip_threadinfo in tcp helper thread"))) ||
2449                         (!(tcptls_session = ast_tcptls_client_start(tcptls_session)))) {
2450                         goto cleanup;
2451                 }
2452         }
2453
2454         me->threadid = pthread_self();
2455         ast_debug(2, "Starting thread for %s server\n", tcptls_session->ssl ? "SSL" : "TCP");
2456
2457         /* set up pollfd to watch for reads on both the socket and the alert_pipe */
2458         fds[0].fd = tcptls_session->fd;
2459         fds[1].fd = me->alert_pipe[0];
2460         fds[0].events = fds[1].events = POLLIN | POLLPRI;
2461
2462         if (!(req.data = ast_str_create(SIP_MIN_PACKET)))
2463                 goto cleanup;
2464         if (!(reqcpy.data = ast_str_create(SIP_MIN_PACKET)))
2465                 goto cleanup;
2466
2467         for (;;) {
2468                 struct ast_str *str_save;
2469
2470                 res = ast_poll(fds, 2, -1); /* polls for both socket and alert_pipe */
2471                 if (res < 0) {
2472                         ast_debug(2, "SIP %s server :: ast_wait_for_input returned %d\n", tcptls_session->ssl ? "SSL": "TCP", res);
2473                         goto cleanup;
2474                 }
2475
2476                 /* handle the socket event, check for both reads from the socket fd,
2477                  * and writes from alert_pipe fd */
2478                 if (fds[0].revents) { /* there is data on the socket to be read */
2479
2480                         fds[0].revents = 0;
2481
2482                         /* clear request structure */
2483                         str_save = req.data;
2484                         memset(&req, 0, sizeof(req));
2485                         req.data = str_save;
2486                         ast_str_reset(req.data);
2487
2488                         str_save = reqcpy.data;
2489                         memset(&reqcpy, 0, sizeof(reqcpy));
2490                         reqcpy.data = str_save;
2491                         ast_str_reset(reqcpy.data);
2492
2493                         memset(buf, 0, sizeof(buf));
2494
2495                         if (tcptls_session->ssl) {
2496                                 set_socket_transport(&req.socket, SIP_TRANSPORT_TLS);
2497                                 req.socket.port = htons(ourport_tls);
2498                         } else {
2499                                 set_socket_transport(&req.socket, SIP_TRANSPORT_TCP);
2500                                 req.socket.port = htons(ourport_tcp);
2501                         }
2502                         req.socket.fd = tcptls_session->fd;
2503
2504                         /* Read in headers one line at a time */
2505                         while (req.len < 4 || strncmp(REQ_OFFSET_TO_STR(&req, len - 4), "\r\n\r\n", 4)) {
2506                                 ast_mutex_lock(&tcptls_session->lock);
2507                                 if (!fgets(buf, sizeof(buf), tcptls_session->f)) {
2508                                         ast_mutex_unlock(&tcptls_session->lock);
2509                                         goto cleanup;
2510                                 }
2511                                 ast_mutex_unlock(&tcptls_session->lock);
2512                                 if (me->stop)
2513                                          goto cleanup;
2514                                 ast_str_append(&req.data, 0, "%s", buf);
2515                                 req.len = req.data->used;
2516                         }
2517                         copy_request(&reqcpy, &req);
2518                         parse_request(&reqcpy);
2519                         /* In order to know how much to read, we need the content-length header */
2520                         if (sscanf(get_header(&reqcpy, "Content-Length"), "%30d", &cl)) {
2521                                 while (cl > 0) {
2522                                         size_t bytes_read;
2523                                         ast_mutex_lock(&tcptls_session->lock);
2524                                         if (!(bytes_read = fread(buf, 1, MIN(sizeof(buf) - 1, cl), tcptls_session->f))) {
2525                                                 ast_mutex_unlock(&tcptls_session->lock);
2526                                                 goto cleanup;
2527                                         }
2528                                         buf[bytes_read] = '\0';
2529                                         ast_mutex_unlock(&tcptls_session->lock);
2530                                         if (me->stop)
2531                                                 goto cleanup;
2532                                         cl -= strlen(buf);
2533                                         ast_str_append(&req.data, 0, "%s", buf);
2534                                         req.len = req.data->used;
2535                                 }
2536                         }
2537                         /*! \todo XXX If there's no Content-Length or if the content-length and what
2538                                         we receive is not the same - we should generate an error */
2539
2540                         req.socket.tcptls_session = tcptls_session;
2541                         handle_request_do(&req, &tcptls_session->remote_address);
2542                 }
2543
2544                 if (fds[1].revents) { /* alert_pipe indicates there is data in the send queue to be sent */
2545                         enum sip_tcptls_alert alert;
2546                         struct tcptls_packet *packet;
2547
2548                         fds[1].revents = 0;
2549
2550                         if (read(me->alert_pipe[0], &alert, sizeof(alert)) == -1) {
2551                                 ast_log(LOG_ERROR, "read() failed: %s\n", strerror(errno));
2552                                 continue;
2553                         }
2554
2555                         switch (alert) {
2556                         case TCPTLS_ALERT_STOP:
2557                                 goto cleanup;
2558                         case TCPTLS_ALERT_DATA:
2559                                 ao2_lock(me);
2560                                 if (!(packet = AST_LIST_REMOVE_HEAD(&me->packet_q, entry))) {
2561                                         ast_log(LOG_WARNING, "TCPTLS thread alert_pipe indicated packet should be sent, but frame_q is empty");
2562                                 } else if (ast_tcptls_server_write(tcptls_session, ast_str_buffer(packet->data), packet->len) == -1) {
2563                                         ast_log(LOG_WARNING, "Failure to write to tcp/tls socket\n");
2564                                 }
2565
2566                                 if (packet) {
2567                                         ao2_t_ref(packet, -1, "tcptls packet sent, this is no longer needed");
2568                                 }
2569                                 ao2_unlock(me);
2570                                 break;
2571                         default:
2572                                 ast_log(LOG_ERROR, "Unknown tcptls thread alert '%d'\n", alert);
2573                         }
2574                 }
2575         }
2576
2577         ast_debug(2, "Shutting down thread for %s server\n", tcptls_session->ssl ? "SSL" : "TCP");
2578
2579 cleanup:
2580         if (me) {
2581                 ao2_t_unlink(threadt, me, "Removing tcptls helper thread, thread is closing");
2582                 ao2_t_ref(me, -1, "Removing tcp_helper_threads threadinfo ref");
2583         }
2584         deinit_req(&reqcpy);
2585         deinit_req(&req);
2586
2587         /* if client, we own the parent session arguments and must decrement ref */
2588         if (ca) {
2589                 ao2_t_ref(ca, -1, "closing tcptls thread, getting rid of client tcptls_session arguments");
2590         }
2591
2592         if (tcptls_session) {
2593                 ast_mutex_lock(&tcptls_session->lock);
2594                 if (tcptls_session->f) {
2595                         fclose(tcptls_session->f);
2596                         tcptls_session->f = NULL;
2597                 }
2598                 if (tcptls_session->fd != -1) {
2599                         close(tcptls_session->fd);
2600                         tcptls_session->fd = -1;
2601                 }
2602                 tcptls_session->parent = NULL;
2603                 ast_mutex_unlock(&tcptls_session->lock);
2604
2605                 ao2_ref(tcptls_session, -1);
2606                 tcptls_session = NULL;
2607         }
2608         return NULL;
2609 }
2610
2611
2612 /*!
2613  * helper functions to unreference various types of objects.
2614  * By handling them this way, we don't have to declare the
2615  * destructor on each call, which removes the chance of errors.
2616  */
2617 static void *unref_peer(struct sip_peer *peer, char *tag)
2618 {
2619         ao2_t_ref(peer, -1, tag);
2620         return NULL;
2621 }
2622
2623 static struct sip_peer *ref_peer(struct sip_peer *peer, char *tag)
2624 {
2625         ao2_t_ref(peer, 1, tag);
2626         return peer;
2627 }
2628
2629 /*! \brief maintain proper refcounts for a sip_pvt's outboundproxy
2630  *
2631  * This function sets pvt's outboundproxy pointer to the one referenced
2632  * by the proxy parameter. Because proxy may be a refcounted object, and
2633  * because pvt's old outboundproxy may also be a refcounted object, we need
2634  * to maintain the proper refcounts.
2635  *
2636  * \param pvt The sip_pvt for which we wish to set the outboundproxy
2637  * \param proxy The sip_proxy which we will point pvt towards.
2638  * \return Returns void
2639  */
2640 static void ref_proxy(struct sip_pvt *pvt, struct sip_proxy *proxy)
2641 {
2642         struct sip_proxy *old_obproxy = pvt->outboundproxy;
2643         /* The sip_cfg.outboundproxy is statically allocated, and so
2644          * we don't ever need to adjust refcounts for it
2645          */
2646         if (proxy && proxy != &sip_cfg.outboundproxy) {
2647                 ao2_ref(proxy, +1);
2648         }
2649         pvt->outboundproxy = proxy;
2650         if (old_obproxy && old_obproxy != &sip_cfg.outboundproxy) {
2651                 ao2_ref(old_obproxy, -1);
2652         }
2653 }
2654
2655 /*!
2656  * \brief Unlink a dialog from the dialogs container, as well as any other places
2657  * that it may be currently stored.
2658  *
2659  * \note A reference to the dialog must be held before calling this function, and this
2660  * function does not release that reference.
2661  */
2662 void *dialog_unlink_all(struct sip_pvt *dialog, int lockowner, int lockdialoglist)
2663 {
2664         struct sip_pkt *cp;
2665
2666         dialog_ref(dialog, "Let's bump the count in the unlink so it doesn't accidentally become dead before we are done");
2667
2668         ao2_t_unlink(dialogs, dialog, "unlinking dialog via ao2_unlink");
2669
2670         /* Unlink us from the owner (channel) if we have one */
2671         if (dialog->owner) {
2672                 if (lockowner)
2673                         ast_channel_lock(dialog->owner);
2674                 ast_debug(1, "Detaching from channel %s\n", dialog->owner->name);
2675                 dialog->owner->tech_pvt = dialog_unref(dialog->owner->tech_pvt, "resetting channel dialog ptr in unlink_all");
2676                 if (lockowner)
2677                         ast_channel_unlock(dialog->owner);
2678         }
2679         if (dialog->registry) {
2680                 if (dialog->registry->call == dialog)
2681                         dialog->registry->call = dialog_unref(dialog->registry->call, "nulling out the registry's call dialog field in unlink_all");
2682                 dialog->registry = registry_unref(dialog->registry, "delete dialog->registry");
2683         }
2684         if (dialog->stateid > -1) {
2685                 ast_extension_state_del(dialog->stateid, NULL);
2686                 dialog_unref(dialog, "removing extension_state, should unref the associated dialog ptr that was stored there.");
2687                 dialog->stateid = -1; /* shouldn't we 'zero' this out? */
2688         }
2689         /* Remove link from peer to subscription of MWI */
2690         if (dialog->relatedpeer && dialog->relatedpeer->mwipvt == dialog)
2691                 dialog->relatedpeer->mwipvt = dialog_unref(dialog->relatedpeer->mwipvt, "delete ->relatedpeer->mwipvt");
2692         if (dialog->relatedpeer && dialog->relatedpeer->call == dialog)
2693                 dialog->relatedpeer->call = dialog_unref(dialog->relatedpeer->call, "unset the relatedpeer->call field in tandem with relatedpeer field itself");
2694
2695         /* remove all current packets in this dialog */
2696         while((cp = dialog->packets)) {
2697                 dialog->packets = dialog->packets->next;
2698                 AST_SCHED_DEL(sched, cp->retransid);
2699                 dialog_unref(cp->owner, "remove all current packets in this dialog, and the pointer to the dialog too as part of __sip_destroy");
2700                 if (cp->data) {
2701                         ast_free(cp->data);
2702                 }
2703                 ast_free(cp);
2704         }
2705
2706         AST_SCHED_DEL_UNREF(sched, dialog->waitid, dialog_unref(dialog, "when you delete the waitid sched, you should dec the refcount for the stored dialog ptr"));
2707
2708         AST_SCHED_DEL_UNREF(sched, dialog->initid, dialog_unref(dialog, "when you delete the initid sched, you should dec the refcount for the stored dialog ptr"));
2709         
2710         if (dialog->autokillid > -1)
2711                 AST_SCHED_DEL_UNREF(sched, dialog->autokillid, dialog_unref(dialog, "when you delete the autokillid sched, you should dec the refcount for the stored dialog ptr"));
2712
2713         if (dialog->request_queue_sched_id > -1) {
2714                 AST_SCHED_DEL_UNREF(sched, dialog->request_queue_sched_id, dialog_unref(dialog, "when you delete the request_queue_sched_id sched, you should dec the refcount for the stored dialog ptr"));
2715         }
2716
2717         AST_SCHED_DEL_UNREF(sched, dialog->provisional_keepalive_sched_id, dialog_unref(dialog, "when you delete the provisional_keepalive_sched_id, you should dec the refcount for the stored dialog ptr"));
2718
2719         if (dialog->t38id > -1) {
2720                 AST_SCHED_DEL_UNREF(sched, dialog->t38id, dialog_unref(dialog, "when you delete the t38id sched, you should dec the refcount for the stored dialog ptr"));
2721         }
2722
2723         dialog_unref(dialog, "Let's unbump the count in the unlink so the poor pvt can disappear if it is time");
2724         return NULL;
2725 }
2726
2727 void *registry_unref(struct sip_registry *reg, char *tag)
2728 {
2729         ast_debug(3, "SIP Registry %s: refcount now %d\n", reg->hostname, reg->refcount - 1);
2730         ASTOBJ_UNREF(reg, sip_registry_destroy);
2731         return NULL;
2732 }
2733
2734 /*! \brief Add object reference to SIP registry */
2735 static struct sip_registry *registry_addref(struct sip_registry *reg, char *tag)
2736 {
2737         ast_debug(3, "SIP Registry %s: refcount now %d\n", reg->hostname, reg->refcount + 1);
2738         return ASTOBJ_REF(reg); /* Add pointer to registry in packet */
2739 }
2740
2741 /*! \brief Interface structure with callbacks used to connect to UDPTL module*/
2742 static struct ast_udptl_protocol sip_udptl = {
2743         type: "SIP",
2744         get_udptl_info: sip_get_udptl_peer,
2745         set_udptl_peer: sip_set_udptl_peer,
2746 };
2747
2748 static void append_history_full(struct sip_pvt *p, const char *fmt, ...)
2749         __attribute__((format(printf, 2, 3)));
2750
2751
2752 /*! \brief Convert transfer status to string */
2753 static const char *referstatus2str(enum referstatus rstatus)
2754 {
2755         return map_x_s(referstatusstrings, rstatus, "");
2756 }
2757
2758 static inline void pvt_set_needdestroy(struct sip_pvt *pvt, const char *reason)
2759 {
2760         if (pvt->final_destruction_scheduled) {
2761                 return; /* This is already scheduled for final destruction, let the scheduler take care of it. */
2762         }
2763         append_history(pvt, "NeedDestroy", "Setting needdestroy because %s", reason);
2764         pvt->needdestroy = 1;
2765 }
2766
2767 /*! \brief Initialize the initital request packet in the pvt structure.
2768         This packet is used for creating replies and future requests in
2769         a dialog */
2770 static void initialize_initreq(struct sip_pvt *p, struct sip_request *req)
2771 {
2772         if (p->initreq.headers)
2773                 ast_debug(1, "Initializing already initialized SIP dialog %s (presumably reinvite)\n", p->callid);
2774         else
2775                 ast_debug(1, "Initializing initreq for method %s - callid %s\n", sip_methods[req->method].text, p->callid);
2776         /* Use this as the basis */
2777         copy_request(&p->initreq, req);
2778         parse_request(&p->initreq);
2779         if (req->debug)
2780                 ast_verbose("Initreq: %d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
2781 }
2782
2783 /*! \brief Encapsulate setting of SIP_ALREADYGONE to be able to trace it with debugging */
2784 static void sip_alreadygone(struct sip_pvt *dialog)
2785 {
2786         ast_debug(3, "Setting SIP_ALREADYGONE on dialog %s\n", dialog->callid);
2787         dialog->alreadygone = 1;
2788 }
2789
2790 /*! Resolve DNS srv name or host name in a sip_proxy structure */
2791 static int proxy_update(struct sip_proxy *proxy)
2792 {
2793         /* if it's actually an IP address and not a name,
2794            there's no need for a managed lookup */
2795         if (!inet_aton(proxy->name, &proxy->ip.sin_addr)) {
2796                 /* Ok, not an IP address, then let's check if it's a domain or host */
2797                 /* XXX Todo - if we have proxy port, don't do SRV */
2798                 if (ast_get_ip_or_srv(&proxy->ip, proxy->name, sip_cfg.srvlookup ? "_sip._udp" : NULL) < 0) {
2799                         ast_log(LOG_WARNING, "Unable to locate host '%s'\n", proxy->name);
2800                         return FALSE;
2801                 }
2802         }
2803         proxy->last_dnsupdate = time(NULL);
2804         return TRUE;
2805 }
2806
2807 /*! \brief converts ascii port to int representation. If no
2808  *  pt buffer is provided or the pt has errors when being converted
2809  *  to an int value, the port provided as the standard is used.
2810  */
2811 unsigned int port_str2int(const char *pt, unsigned int standard)
2812 {
2813         int port = standard;
2814         if (ast_strlen_zero(pt) || (sscanf(pt, "%30d", &port) != 1) || (port < 1) || (port > 65535)) {
2815                 port = standard;
2816         }
2817
2818         return port;
2819 }
2820
2821 /*! \brief Allocate and initialize sip proxy */
2822 static struct sip_proxy *proxy_allocate(char *name, char *port, int force)
2823 {
2824         struct sip_proxy *proxy;
2825
2826         if (ast_strlen_zero(name)) {
2827                 return NULL;
2828         }
2829
2830         proxy = ao2_alloc(sizeof(*proxy), NULL);
2831         if (!proxy)
2832                 return NULL;
2833         proxy->force = force;
2834         ast_copy_string(proxy->name, name, sizeof(proxy->name));
2835         proxy->ip.sin_port = htons(port_str2int(port, STANDARD_SIP_PORT));
2836         proxy->ip.sin_family = AF_INET;
2837         proxy_update(proxy);
2838         return proxy;
2839 }
2840
2841 /*! \brief Get default outbound proxy or global proxy */
2842 static struct sip_proxy *obproxy_get(struct sip_pvt *dialog, struct sip_peer *peer)
2843 {
2844         if (peer && peer->outboundproxy) {
2845                 if (sipdebug)
2846                         ast_debug(1, "OBPROXY: Applying peer OBproxy to this call\n");
2847                 append_history(dialog, "OBproxy", "Using peer obproxy %s", peer->outboundproxy->name);
2848                 return peer->outboundproxy;
2849         }
2850         if (sip_cfg.outboundproxy.name[0]) {
2851                 if (sipdebug)
2852                         ast_debug(1, "OBPROXY: Applying global OBproxy to this call\n");
2853                 append_history(dialog, "OBproxy", "Using global obproxy %s", sip_cfg.outboundproxy.name);
2854                 return &sip_cfg.outboundproxy;
2855         }
2856         if (sipdebug)
2857                 ast_debug(1, "OBPROXY: Not applying OBproxy to this call\n");
2858         return NULL;
2859 }
2860
2861 /*! \brief returns true if 'name' (with optional trailing whitespace)
2862  * matches the sip method 'id'.
2863  * Strictly speaking, SIP methods are case SENSITIVE, but we do
2864  * a case-insensitive comparison to be more tolerant.
2865  * following Jon Postel's rule: Be gentle in what you accept, strict with what you send
2866  */
2867 static int method_match(enum sipmethod id, const char *name)
2868 {
2869         int len = strlen(sip_methods[id].text);
2870         int l_name = name ? strlen(name) : 0;
2871         /* true if the string is long enough, and ends with whitespace, and matches */
2872         return (l_name >= len && name[len] < 33 &&
2873                 !strncasecmp(sip_methods[id].text, name, len));
2874 }
2875
2876 /*! \brief  find_sip_method: Find SIP method from header */
2877 static int find_sip_method(const char *msg)
2878 {
2879         int i, res = 0;
2880         
2881         if (ast_strlen_zero(msg))
2882                 return 0;
2883         for (i = 1; i < ARRAY_LEN(sip_methods) && !res; i++) {
2884                 if (method_match(i, msg))
2885                         res = sip_methods[i].id;
2886         }
2887         return res;
2888 }
2889
2890 /*! \brief See if we pass debug IP filter */
2891 static inline int sip_debug_test_addr(const struct sockaddr_in *addr)
2892 {
2893         if (!sipdebug)
2894                 return 0;
2895         if (debugaddr.sin_addr.s_addr) {
2896                 if (((ntohs(debugaddr.sin_port) != 0)
2897                         && (debugaddr.sin_port != addr->sin_port))
2898                         || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
2899                         return 0;
2900         }
2901         return 1;
2902 }
2903
2904 /*! \brief The real destination address for a write */
2905 static const struct sockaddr_in *sip_real_dst(const struct sip_pvt *p)
2906 {
2907         if (p->outboundproxy)
2908                 return &p->outboundproxy->ip;
2909
2910         return ast_test_flag(&p->flags[0], SIP_NAT_FORCE_RPORT) || ast_test_flag(&p->flags[0], SIP_NAT_RPORT_PRESENT) ? &p->recv : &p->sa;
2911 }
2912
2913 /*! \brief Display SIP nat mode */
2914 static const char *sip_nat_mode(const struct sip_pvt *p)
2915 {
2916         return ast_test_flag(&p->flags[0], SIP_NAT_FORCE_RPORT) ? "NAT" : "no NAT";
2917 }
2918
2919 /*! \brief Test PVT for debugging output */
2920 static inline int sip_debug_test_pvt(struct sip_pvt *p)
2921 {
2922         if (!sipdebug)
2923                 return 0;
2924         return sip_debug_test_addr(sip_real_dst(p));
2925 }
2926
2927 /*! \brief Return int representing a bit field of transport types found in const char *transport */
2928 static int get_transport_str2enum(const char *transport)
2929 {
2930         int res = 0;
2931
2932         if (ast_strlen_zero(transport)) {
2933                 return res;
2934         }
2935
2936         if (!strcasecmp(transport, "udp")) {
2937                 res |= SIP_TRANSPORT_UDP;
2938         }
2939         if (!strcasecmp(transport, "tcp")) {
2940                 res |= SIP_TRANSPORT_TCP;
2941         }
2942         if (!strcasecmp(transport, "tls")) {
2943                 res |= SIP_TRANSPORT_TLS;
2944         }
2945
2946         return res;
2947 }
2948
2949 /*! \brief Return configuration of transports for a device */
2950 static inline const char *get_transport_list(unsigned int transports) {
2951         switch (transports) {
2952                 case SIP_TRANSPORT_UDP:
2953                         return "UDP";
2954                 case SIP_TRANSPORT_TCP:
2955                         return "TCP";
2956                 case SIP_TRANSPORT_TLS:
2957                         return "TLS";
2958                 case SIP_TRANSPORT_UDP | SIP_TRANSPORT_TCP:
2959                         return "TCP,UDP";
2960                 case SIP_TRANSPORT_UDP | SIP_TRANSPORT_TLS:
2961                         return "TLS,UDP";
2962                 case SIP_TRANSPORT_TCP | SIP_TRANSPORT_TLS:
2963                         return "TLS,TCP";
2964                 default:
2965                         return transports ?
2966                                 "TLS,TCP,UDP" : "UNKNOWN";      
2967         }
2968 }
2969
2970 /*! \brief Return transport as string */
2971 static inline const char *get_transport(enum sip_transport t)
2972 {
2973         switch (t) {
2974         case SIP_TRANSPORT_UDP:
2975                 return "UDP";
2976         case SIP_TRANSPORT_TCP:
2977                 return "TCP";
2978         case SIP_TRANSPORT_TLS:
2979                 return "TLS";
2980         }
2981
2982         return "UNKNOWN";
2983 }
2984
2985 /*! \brief Return transport of dialog.
2986         \note this is based on a false assumption. We don't always use the
2987         outbound proxy for all requests in a dialog. It depends on the
2988         "force" parameter. The FIRST request is always sent to the ob proxy.
2989         \todo Fix this function to work correctly
2990 */
2991 static inline const char *get_transport_pvt(struct sip_pvt *p)
2992 {
2993         if (p->outboundproxy && p->outboundproxy->transport) {
2994                 set_socket_transport(&p->socket, p->outboundproxy->transport);
2995         }
2996
2997         return get_transport(p->socket.type);
2998 }
2999
3000 /*! \brief Transmit SIP message
3001         Sends a SIP request or response on a given socket (in the pvt)
3002         Called by retrans_pkt, send_request, send_response and
3003         __sip_reliable_xmit
3004         \return length of transmitted message, XMIT_ERROR on known network failures -1 on other failures.
3005 */
3006 static int __sip_xmit(struct sip_pvt *p, struct ast_str *data, int len)
3007 {
3008         int res = 0;
3009         const struct sockaddr_in *dst = sip_real_dst(p);
3010
3011         ast_debug(2, "Trying to put '%.11s' onto %s socket destined for %s:%d\n", data->str, get_transport_pvt(p), ast_inet_ntoa(dst->sin_addr), htons(dst->sin_port));
3012
3013         if (sip_prepare_socket(p) < 0)
3014                 return XMIT_ERROR;
3015
3016         if (p->socket.type == SIP_TRANSPORT_UDP) {
3017                 res = sendto(p->socket.fd, data->str, len, 0, (const struct sockaddr *)dst, sizeof(struct sockaddr_in));
3018         } else if (p->socket.tcptls_session) {
3019                 res = sip_tcptls_write(p->socket.tcptls_session, data->str, len);
3020         } else {
3021                 ast_debug(2, "Socket type is TCP but no tcptls_session is present to write to\n");
3022                 return XMIT_ERROR;
3023         }
3024
3025         if (res == -1) {
3026                 switch (errno) {
3027                 case EBADF:             /* Bad file descriptor - seems like this is generated when the host exist, but doesn't accept the UDP packet */
3028                 case EHOSTUNREACH:      /* Host can't be reached */
3029                 case ENETDOWN:          /* Interface down */
3030                 case ENETUNREACH:       /* Network failure */
3031                 case ECONNREFUSED:      /* ICMP port unreachable */
3032                         res = XMIT_ERROR;       /* Don't bother with trying to transmit again */
3033                 }
3034         }
3035         if (res != len)
3036                 ast_log(LOG_WARNING, "sip_xmit of %p (len %d) to %s:%d returned %d: %s\n", data, len, ast_inet_ntoa(dst->sin_addr), ntohs(dst->sin_port), res, strerror(errno));
3037
3038         return res;
3039 }
3040
3041 /*! \brief Build a Via header for a request */
3042 static void build_via(struct sip_pvt *p)
3043 {
3044         /* Work around buggy UNIDEN UIP200 firmware */
3045         const char *rport = (ast_test_flag(&p->flags[0], SIP_NAT_FORCE_RPORT) || ast_test_flag(&p->flags[0], SIP_NAT_RPORT_PRESENT)) ? ";rport" : "";
3046
3047         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
3048         snprintf(p->via, sizeof(p->via), "SIP/2.0/%s %s:%d;branch=z9hG4bK%08x%s",
3049                  get_transport_pvt(p),
3050                  ast_inet_ntoa(p->ourip.sin_addr),
3051                  ntohs(p->ourip.sin_port), (int) p->branch, rport);
3052 }
3053
3054 /*! \brief NAT fix - decide which IP address to use for Asterisk server?
3055  *
3056  * Using the localaddr structure built up with localnet statements in sip.conf
3057  * apply it to their address to see if we need to substitute our
3058  * externip or can get away with our internal bindaddr
3059  * 'us' is always overwritten.
3060  */
3061 static void ast_sip_ouraddrfor(struct in_addr *them, struct sockaddr_in *us, struct sip_pvt *p)
3062 {
3063         struct sockaddr_in theirs;
3064         /* Set want_remap to non-zero if we want to remap 'us' to an externally
3065          * reachable IP address and port. This is done if:
3066          * 1. we have a localaddr list (containing 'internal' addresses marked
3067          *    as 'deny', so ast_apply_ha() will return AST_SENSE_DENY on them,
3068          *    and AST_SENSE_ALLOW on 'external' ones);
3069          * 2. either stunaddr or externip is set, so we know what to use as the
3070          *    externally visible address;
3071          * 3. the remote address, 'them', is external;
3072          * 4. the address returned by ast_ouraddrfor() is 'internal' (AST_SENSE_DENY
3073          *    when passed to ast_apply_ha() so it does need to be remapped.
3074          *    This fourth condition is checked later.
3075          */
3076         int want_remap;
3077
3078         *us = internip;         /* starting guess for the internal address */
3079         /* now ask the system what would it use to talk to 'them' */
3080         ast_ouraddrfor(them, &us->sin_addr);
3081         theirs.sin_addr = *them;
3082
3083         want_remap = localaddr &&
3084                 (externip.sin_addr.s_addr || stunaddr.sin_addr.s_addr) &&
3085                 ast_apply_ha(localaddr, &theirs) == AST_SENSE_ALLOW ;
3086
3087         if (want_remap &&
3088             (!sip_cfg.matchexterniplocally || !ast_apply_ha(localaddr, us)) ) {
3089                 /* if we used externhost or stun, see if it is time to refresh the info */
3090                 if (externexpire && time(NULL) >= externexpire) {
3091                         if (stunaddr.sin_addr.s_addr) {
3092                                 ast_stun_request(sipsock, &stunaddr, NULL, &externip);
3093                         } else {
3094                                 if (ast_parse_arg(externhost, PARSE_INADDR, &externip))
3095                                         ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
3096                         }
3097                         externexpire = time(NULL) + externrefresh;
3098                 }
3099                 if (externip.sin_addr.s_addr) {
3100                         *us = externip;
3101                         switch (p->socket.type) {
3102                         case SIP_TRANSPORT_TCP:
3103                                 us->sin_port = htons(externtcpport);
3104                                 break;
3105                         case SIP_TRANSPORT_TLS:
3106                                 us->sin_port = htons(externtlsport);
3107                                 break;
3108                         case SIP_TRANSPORT_UDP:
3109                                 break; /* fall through */
3110                         default:
3111                                 us->sin_port = htons(STANDARD_SIP_PORT); /* we should never get here */
3112                         }
3113                 }
3114                 else
3115                         ast_log(LOG_WARNING, "stun failed\n");
3116                 ast_debug(1, "Target address %s is not local, substituting externip\n",
3117                         ast_inet_ntoa(*(struct in_addr *)&them->s_addr));
3118         } else if (p) {
3119                 /* no remapping, but we bind to a specific address, so use it. */
3120                 switch (p->socket.type) {
3121                 case SIP_TRANSPORT_TCP:
3122                         if (sip_tcp_desc.local_address.sin_addr.s_addr) {
3123                                 *us = sip_tcp_desc.local_address;
3124                         } else {
3125                                 us->sin_port = sip_tcp_desc.local_address.sin_port;
3126                         }
3127                         break;
3128                 case SIP_TRANSPORT_TLS:
3129                         if (sip_tls_desc.local_address.sin_addr.s_addr) {
3130                                 *us = sip_tls_desc.local_address;
3131                         } else {
3132                                 us->sin_port = sip_tls_desc.local_address.sin_port;
3133                         }
3134                                 break;
3135                 case SIP_TRANSPORT_UDP:
3136                         /* fall through on purpose */
3137                 default:
3138                         if (bindaddr.sin_addr.s_addr) {
3139                                 *us = bindaddr;
3140                         }
3141                 }
3142         } else if (bindaddr.sin_addr.s_addr) {
3143                 *us = bindaddr;
3144         }
3145         ast_debug(3, "Setting SIP_TRANSPORT_%s with address %s:%d\n", get_transport(p->socket.type), ast_inet_ntoa(us->sin_addr), ntohs(us->sin_port));
3146 }
3147
3148 /*! \brief Append to SIP dialog history with arg list  */
3149 static __attribute__((format(printf, 2, 0))) void append_history_va(struct sip_pvt *p, const char *fmt, va_list ap)
3150 {
3151         char buf[80], *c = buf; /* max history length */
3152         struct sip_history *hist;
3153         int l;
3154
3155         vsnprintf(buf, sizeof(buf), fmt, ap);
3156         strsep(&c, "\r\n"); /* Trim up everything after \r or \n */
3157         l = strlen(buf) + 1;
3158         if (!(hist = ast_calloc(1, sizeof(*hist) + l)))
3159                 return;
3160         if (!p->history && !(p->history = ast_calloc(1, sizeof(*p->history)))) {
3161                 ast_free(hist);
3162                 return;
3163         }
3164         memcpy(hist->event, buf, l);
3165         if (p->history_entries == MAX_HISTORY_ENTRIES) {
3166                 struct sip_history *oldest;
3167                 oldest = AST_LIST_REMOVE_HEAD(p->history, list);
3168                 p->history_entries--;
3169                 ast_free(oldest);
3170         }
3171         AST_LIST_INSERT_TAIL(p->history, hist, list);
3172         p->history_entries++;
3173 }
3174
3175 /*! \brief Append to SIP dialog history with arg list  */
3176 static void append_history_full(struct sip_pvt *p, const char *fmt, ...)
3177 {
3178         va_list ap;
3179
3180         if (!p)
3181                 return;
3182
3183         if (!p->do_history && !recordhistory && !dumphistory)
3184                 return;
3185
3186         va_start(ap, fmt);
3187         append_history_va(p, fmt, ap);
3188         va_end(ap);
3189
3190         return;
3191 }
3192
3193 /*! \brief Retransmit SIP message if no answer (Called from scheduler) */
3194 static int retrans_pkt(const void *data)
3195 {
3196         struct sip_pkt *pkt = (struct sip_pkt *)data, *prev, *cur = NULL;
3197         int reschedule = DEFAULT_RETRANS;
3198         int xmitres = 0;
3199
3200         /* Lock channel PVT */
3201         sip_pvt_lock(pkt->owner);
3202
3203         if (pkt->retrans < MAX_RETRANS) {
3204                 pkt->retrans++;
3205                 if (!pkt->timer_t1) {   /* Re-schedule using timer_a and timer_t1 */
3206                         if (sipdebug) {
3207                                 ast_debug(4, "SIP TIMER: Not rescheduling id #%d:%s (Method %d) (No timer T1)\n", pkt->retransid, sip_methods[pkt->method].text, pkt->method);
3208                         }
3209                 } else {
3210                         int siptimer_a;
3211
3212                         if (sipdebug) {
3213                                 ast_debug(4, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n", pkt->retransid, pkt->retrans, sip_methods[pkt->method].text, pkt->method);
3214                         }
3215                         if (!pkt->timer_a) {
3216                                 pkt->timer_a = 2 ;
3217                         } else {
3218                                 pkt->timer_a = 2 * pkt->timer_a;
3219                         }
3220
3221                         /* For non-invites, a maximum of 4 secs */
3222                         siptimer_a = pkt->timer_t1 * pkt->timer_a;      /* Double each time */
3223                         if (pkt->method != SIP_INVITE && siptimer_a > 4000) {
3224                                 siptimer_a = 4000;
3225                         }
3226
3227                         /* Reschedule re-transmit */
3228                         reschedule = siptimer_a;
3229                         ast_debug(4, "** SIP timers: Rescheduling retransmission %d to %d ms (t1 %d ms (Retrans id #%d)) \n", pkt->retrans +1, siptimer_a, pkt->timer_t1, pkt->retransid);
3230                 }
3231
3232                 if (sip_debug_test_pvt(pkt->owner)) {
3233                         const struct sockaddr_in *dst = sip_real_dst(pkt->owner);
3234                         ast_verbose("Retransmitting #%d (%s) to %s:%d:\n%s\n---\n",
3235                                 pkt->retrans, sip_nat_mode(pkt->owner),
3236                                 ast_inet_ntoa(dst->sin_addr),
3237                                 ntohs(dst->sin_port), pkt->data->str);
3238                 }
3239
3240                 append_history(pkt->owner, "ReTx", "%d %s", reschedule, pkt->data->str);
3241                 xmitres = __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
3242                 sip_pvt_unlock(pkt->owner);
3243                 if (xmitres == XMIT_ERROR) {
3244                         ast_log(LOG_WARNING, "Network error on retransmit in dialog %s\n", pkt->owner->callid);
3245                 } else {
3246                         return  reschedule;
3247                 }
3248         }
3249
3250         /* Too many retries */
3251         if (pkt->owner && pkt->method != SIP_OPTIONS && xmitres == 0) {
3252                 if (pkt->is_fatal || sipdebug) {/* Tell us if it's critical or if we're debugging */
3253                         ast_log(LOG_WARNING, "Maximum retries exceeded on transmission %s for seqno %d (%s %s) -- See doc/sip-retransmit.txt.\n",
3254                                 pkt->owner->callid, pkt->seqno,
3255                                 pkt->is_fatal ? "Critical" : "Non-critical", pkt->is_resp ? "Response" : "Request");
3256                 }
3257         } else if (pkt->method == SIP_OPTIONS && sipdebug) {
3258                 ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s)  -- See doc/sip-retransmit.txt.\n", pkt->owner->callid);
3259         }
3260
3261         if (xmitres == XMIT_ERROR) {
3262                 ast_log(LOG_WARNING, "Transmit error :: Cancelling transmission on Call ID %s\n", pkt->owner->callid);
3263                 append_history(pkt->owner, "XmitErr", "%s", pkt->is_fatal ? "(Critical)" : "(Non-critical)");
3264         } else {
3265                 append_history(pkt->owner, "MaxRetries", "%s", pkt->is_fatal ? "(Critical)" : "(Non-critical)");
3266         }
3267
3268         pkt->retransid = -1;
3269
3270         if (pkt->is_fatal) {
3271                 while(pkt->owner->owner && ast_channel_trylock(pkt->owner->owner)) {
3272                         sip_pvt_unlock(pkt->owner);     /* SIP_PVT, not channel */
3273                         usleep(1);
3274                         sip_pvt_lock(pkt->owner);
3275                 }
3276                 if (pkt->owner->owner && !pkt->owner->owner->hangupcause) {
3277                         pkt->owner->owner->hangupcause = AST_CAUSE_NO_USER_RESPONSE;
3278                 }
3279                 if (pkt->owner->owner) {
3280                         sip_alreadygone(pkt->owner);
3281                         ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet (see doc/sip-retransmit.txt).\n", pkt->owner->callid);
3282                         ast_queue_hangup_with_cause(pkt->owner->owner, AST_CAUSE_PROTOCOL_ERROR);
3283                         ast_channel_unlock(pkt->owner->owner);
3284                 } else {
3285                         /* If no channel owner, destroy now */
3286
3287                         /* Let the peerpoke system expire packets when the timer expires for poke_noanswer */
3288                         if (pkt->method != SIP_OPTIONS && pkt->method != SIP_REGISTER) {
3289                                 pvt_set_needdestroy(pkt->owner, "no response to critical packet");
3290                                 sip_alreadygone(pkt->owner);
3291                                 append_history(pkt->owner, "DialogKill", "Killing this failed dialog immediately");
3292                         }
3293                 }
3294         }
3295
3296         if (pkt->method == SIP_BYE) {
3297                 /* We're not getting answers on SIP BYE's.  Tear down the call anyway. */
3298                 if (pkt->owner->owner)
3299                         ast_channel_unlock(pkt->owner->owner);
3300                 append_history(pkt->owner, "ByeFailure", "Remote peer doesn't respond to bye. Destroying call anyway.");
3301                 pvt_set_needdestroy(pkt->owner, "no response to BYE");
3302         }
3303
3304         /* Remove the packet */
3305         for (prev = NULL, cur = pkt->owner->packets; cur; prev = cur, cur = cur->next) {
3306                 if (cur == pkt) {
3307                         UNLINK(cur, pkt->owner->packets, prev);
3308                         sip_pvt_unlock(pkt->owner);
3309                         if (pkt->owner) {
3310                                 pkt->owner = dialog_unref(pkt->owner,"pkt is being freed, its dialog ref is dead now");
3311                         }
3312                         if (pkt->data) {
3313                                 ast_free(pkt->data);
3314                         }
3315                         pkt->data = NULL;
3316                         ast_free(pkt);
3317                         return 0;
3318                 }
3319         }
3320         /* error case */
3321         ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
3322         sip_pvt_unlock(pkt->owner);
3323         return 0;
3324 }
3325
3326 /*! \brief Transmit packet with retransmits
3327         \return 0 on success, -1 on failure to allocate packet
3328 */
3329 static enum sip_result __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, struct ast_str *data, int len, int fatal, int sipmethod)
3330 {
3331         struct sip_pkt *pkt = NULL;
3332         int siptimer_a = DEFAULT_RETRANS;
3333         int xmitres = 0;
3334         int respid;
3335
3336         if (sipmethod == SIP_INVITE) {
3337                 /* Note this is a pending invite */
3338                 p->pendinginvite = seqno;
3339         }
3340
3341         /* If the transport is something reliable (TCP or TLS) then don't really send this reliably */
3342         /* I removed the code from retrans_pkt that does the same thing so it doesn't get loaded into the scheduler */
3343         /*! \todo According to the RFC some packets need to be retransmitted even if its TCP, so this needs to get revisited */
3344         if (!(p->socket.type & SIP_TRANSPORT_UDP)) {
3345                 xmitres = __sip_xmit(p, data, len);     /* Send packet */
3346                 if (xmitres == XMIT_ERROR) {    /* Serious network trouble, no need to try again */
3347                         append_history(p, "XmitErr", "%s", fatal ? "(Critical)" : "(Non-critical)");
3348                         return AST_FAILURE;
3349                 } else {
3350                         return AST_SUCCESS;
3351                 }
3352         }
3353
3354         if (!(pkt = ast_calloc(1, sizeof(*pkt) + len + 1)))
3355                 return AST_FAILURE;
3356         /* copy data, add a terminator and save length */
3357         if (!(pkt->data = ast_str_create(len))) {
3358                 ast_free(pkt);
3359                 return AST_FAILURE;
3360         }
3361         ast_str_set(&pkt->data, 0, "%s%s", data->str, "\0");
3362         pkt->packetlen = len;
3363         /* copy other parameters from the caller */
3364         pkt->method = sipmethod;
3365         pkt->seqno = seqno;
3366         pkt->is_resp = resp;
3367         pkt->is_fatal = fatal;
3368         pkt->owner = dialog_ref(p, "__sip_reliable_xmit: setting pkt->owner");
3369         pkt->next = p->packets;
3370         p->packets = pkt;       /* Add it to the queue */
3371         if (resp) {
3372                 /* Parse out the response code */
3373                 if (sscanf(ast_str_buffer(pkt->data), "SIP/2.0 %30u", &respid) == 1) {
3374                         pkt->response_code = respid;
3375                 }
3376         }
3377         pkt->timer_t1 = p->timer_t1;    /* Set SIP timer T1 */
3378         pkt->retransid = -1;
3379         if (pkt->timer_t1)
3380                 siptimer_a = pkt->timer_t1;
3381
3382         /* Schedule retransmission */
3383         AST_SCHED_REPLACE_VARIABLE(pkt->retransid, sched, siptimer_a, retrans_pkt, pkt, 1);
3384         if (sipdebug)
3385                 ast_debug(4, "*** SIP TIMER: Initializing retransmit timer on packet: Id  #%d\n", pkt->retransid);
3386
3387         xmitres = __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);    /* Send packet */
3388
3389         if (xmitres == XMIT_ERROR) {    /* Serious network trouble, no need to try again */
3390                 append_history(pkt->owner, "XmitErr", "%s", pkt->is_fatal ? "(Critical)" : "(Non-critical)");
3391                 ast_log(LOG_ERROR, "Serious Network Trouble; __sip_xmit returns error for pkt data\n");
3392                 AST_SCHED_DEL(sched, pkt->retransid);
3393                 p->packets = pkt->next;
3394                 pkt->owner = dialog_unref(pkt->owner,"pkt is being freed, its dialog ref is dead now");
3395                 ast_free(pkt->data);
3396                 ast_free(pkt);
3397                 return AST_FAILURE;
3398         } else {
3399                 /* This is odd, but since the retrans timer starts at 500ms and the do_monitor thread
3400                  * only wakes up every 1000ms by default, we have to poke the thread here to make
3401                  * sure it successfully detects this must be retransmitted in less time than
3402                  * it usually sleeps for. Otherwise it might not retransmit this packet for 1000ms. */
3403                 pthread_kill(monitor_thread, SIGURG);
3404                 return AST_SUCCESS;
3405         }
3406 }
3407
3408 /*! \brief Kill a SIP dialog (called only by the scheduler)
3409  * The scheduler has a reference to this dialog when p->autokillid != -1,
3410  * and we are called using that reference. So if the event is not
3411  * rescheduled, we need to call dialog_unref().
3412  */
3413 static int __sip_autodestruct(const void *data)
3414 {
3415         struct sip_pvt *p = (struct sip_pvt *)data;
3416
3417         /* If this is a subscription, tell the phone that we got a timeout */
3418         if (p->subscribed && p->subscribed != MWI_NOTIFICATION && p->subscribed != CALL_COMPLETION) {
3419                 transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1, TRUE);   /* Send last notification */
3420                 p->subscribed = NONE;
3421                 append_history(p, "Subscribestatus", "timeout");
3422                 ast_debug(3, "Re-scheduled destruction of SIP subscription %s\n", p->callid ? p->callid : "<unknown>");
3423                 return 10000;   /* Reschedule this destruction so that we know that it's gone */
3424         }
3425
3426         /* If there are packets still waiting for delivery, delay the destruction */
3427         if (p->packets) {
3428                 if (!p->needdestroy) {
3429                         char method_str[31];
3430                         ast_debug(3, "Re-scheduled destruction of SIP call %s\n", p->callid ? p->callid : "<unknown>");
3431                         append_history(p, "ReliableXmit", "timeout");
3432                         if (sscanf(p->lastmsg, "Tx: %30s", method_str) == 1 || sscanf(p->lastmsg, "Rx: %30s", method_str) == 1) {
3433                                 if (method_match(SIP_CANCEL, method_str) || method_match(SIP_BYE, method_str)) {
3434                                         pvt_set_needdestroy(p, "autodestruct");
3435                                 }
3436                         }
3437                         return 10000;
3438                 } else {
3439                         /* They've had their chance to respond. Time to bail */
3440                         __sip_pretend_ack(p);
3441                 }
3442         }
3443
3444         if (p->subscribed == MWI_NOTIFICATION) {
3445                 if (p->relatedpeer) {
3446                         p->relatedpeer = unref_peer(p->relatedpeer, "__sip_autodestruct: unref peer p->relatedpeer");   /* Remove link to peer. If it's realtime, make sure it's gone from memory) */
3447                 }
3448         }
3449
3450         /* Reset schedule ID */
3451         p->autokillid = -1;
3452
3453         if (p->owner) {
3454                 ast_log(LOG_WARNING, "Autodestruct on dialog '%s' with owner in place (Method: %s)\n", p->callid, sip_methods[p->method].text);
3455                 ast_queue_hangup_with_cause(p->owner, AST_CAUSE_PROTOCOL_ERROR);
3456         } else if (p->refer && !p->alreadygone) {
3457                 ast_debug(3, "Finally hanging up channel after transfer: %s\n", p->callid);
3458                 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
3459                 append_history(p, "ReferBYE", "Sending BYE on transferer call leg %s", p->callid);
3460                 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
3461         } else {
3462                 append_history(p, "AutoDestroy", "%s", p->callid);
3463                 ast_debug(3, "Auto destroying SIP dialog '%s'\n", p->callid);
3464                 dialog_unlink_all(p, TRUE, TRUE); /* once it's unlinked and unrefd everywhere, it'll be freed automagically */
3465                 /* dialog_unref(p, "unref dialog-- no other matching conditions"); -- unlink all now should finish off the dialog's references and free it. */
3466                 /* sip_destroy(p); */           /* Go ahead and destroy dialog. All attempts to recover is done */
3467                 /* sip_destroy also absorbs the reference */
3468         }
3469         dialog_unref(p, "The ref to a dialog passed to this sched callback is going out of scope; unref it.");
3470         return 0;
3471 }
3472
3473 /*! \brief Schedule final destruction of SIP dialog.  This can not be canceled.
3474  *  This function is used to keep a dialog around for a period of time in order
3475  *  to properly respond to any retransmits. */
3476 void sip_scheddestroy_final(struct sip_pvt *p, int ms)
3477 {
3478         if (p->final_destruction_scheduled) {
3479                 return; /* already set final destruction */
3480         }
3481
3482         sip_scheddestroy(p, ms);
3483         if (p->autokillid != -1) {
3484                 p->final_destruction_scheduled = 1;
3485         }
3486 }
3487
3488 /*! \brief Schedule destruction of SIP dialog */
3489 void sip_scheddestroy(struct sip_pvt *p, int ms)
3490 {
3491         if (p->final_destruction_scheduled) {
3492                 return; /* already set final destruction */
3493         }
3494
3495         if (ms < 0) {
3496                 if (p->timer_t1 == 0) {
3497                         p->timer_t1 = global_t1;        /* Set timer T1 if not set (RFC 3261) */
3498                 }
3499                 if (p->timer_b == 0) {
3500                         p->timer_b = global_timer_b;  /* Set timer B if not set (RFC 3261) */
3501                 }
3502                 ms = p->timer_t1 * 64;
3503         }
3504         if (sip_debug_test_pvt(p))
3505                 ast_verbose("Scheduling destruction of SIP dialog '%s' in %d ms (Method: %s)\n", p->callid, ms, sip_methods[p->method].text);
3506         if (sip_cancel_destroy(p))
3507                 ast_log(LOG_WARNING, "Unable to cancel SIP destruction.  Expect bad things.\n");
3508
3509         if (p->do_history)
3510                 append_history(p, "SchedDestroy", "%d ms", ms);
3511         p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, dialog_ref(p, "setting ref as passing into ast_sched_add for __sip_autodestruct"));
3512
3513         if (p->stimer && p->stimer->st_active == TRUE && p->stimer->st_schedid > 0)
3514                 stop_session_timer(p);
3515 }
3516
3517 /*! \brief Cancel destruction of SIP dialog.
3518  * Be careful as this also absorbs the reference - if you call it
3519  * from within the scheduler, this might be the last reference.
3520  */
3521 int sip_cancel_destroy(struct sip_pvt *p)
3522 {
3523         int res = 0;
3524
3525         if (p->final_destruction_scheduled) {
3526                 return res;
3527         }
3528
3529         if (p->autokillid > -1) {
3530                 int res3;
3531
3532                 if (!(res3 = ast_sched_del(sched, p->autokillid))) {
3533                         append_history(p, "CancelDestroy", "");
3534                         p->autokillid = -1;
3535                         dialog_unref(p, "dialog unrefd because autokillid is de-sched'd");
3536                 }
3537         }
3538         return res;
3539 }
3540
3541 /*! \brief Acknowledges receipt of a packet and stops retransmission
3542  * called with p locked*/
3543 int __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
3544 {
3545         struct sip_pkt *cur, *prev = NULL;
3546         const char *msg = "Not Found";  /* used only for debugging */
3547         int res = FALSE;
3548
3549         /* If we have an outbound proxy for this dialog, then delete it now since
3550           the rest of the requests in this dialog needs to follow the routing.
3551           If obforcing is set, we will keep the outbound proxy during the whole
3552           dialog, regardless of what the SIP rfc says
3553         */
3554         if (p->outboundproxy && !p->outboundproxy->force){
3555                 ref_proxy(p, NULL);
3556         }
3557
3558         for (cur = p->packets; cur; prev = cur, cur = cur->next) {
3559                 if (cur->seqno != seqno || cur->is_resp != resp)
3560                         continue;
3561                 if (cur-&