d85f0f62dc52a9daaeae504e177a236f470cc9db
[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, TCP and TLS support
29  * Configuration file \link Config_sip sip.conf \endlink
30  *
31  *
32  * \todo SIP over TCP
33  * \todo SIP over TLS
34  * \todo Better support of forking
35  *
36  * \ingroup channel_drivers
37  *
38  * \par Overview of the handling of SIP sessions
39  * The SIP channel handles several types of SIP sessions, or dialogs,
40  * not all of them being "telephone calls".
41  * - Incoming calls that will be sent to the PBX core
42  * - Outgoing calls, generated by the PBX
43  * - SIP subscriptions and notifications of states and voicemail messages
44  * - SIP registrations, both inbound and outbound
45  * - SIP peer management (peerpoke, OPTIONS)
46  * - SIP text messages
47  *
48  * In the SIP channel, there's a list of active SIP dialogs, which includes
49  * all of these when they are active. "sip show channels" in the CLI will
50  * show most of these, excluding subscriptions which are shown by
51  * "sip show subscriptions"
52  *
53  * \par incoming packets
54  * Incoming packets are received in the monitoring thread, then handled by
55  * sipsock_read(). This function parses the packet and matches an existing
56  * dialog or starts a new SIP dialog.
57  * 
58  * sipsock_read sends the packet to handle_request(), that parses a bit more.
59  * if it's a response to an outbound request, it's sent to handle_response().
60  * If it is a request, handle_request sends it to one of a list of functions
61  * depending on the request type - INVITE, OPTIONS, REFER, BYE, CANCEL etc
62  *
63  * A new INVITE is sent to handle_request_invite(), that will end up
64  * starting a new channel in the PBX, the new channel after that executing
65  * in a separate channel thread. This is an incoming "call".
66  * When the call is answered, either by a bridged channel or the PBX itself
67  * the sip_answer() function is called.
68  *
69  * The actual media - Video or Audio - is mostly handled by the RTP subsystem
70  * in rtp.c 
71  * 
72  * \par Outbound calls
73  * Outbound calls are set up by the PBX through the sip_request_call()
74  * function. After that, they are activated by sip_call().
75  * 
76  * \par Hanging up
77  * The PBX issues a hangup on both incoming and outgoing calls through
78  * the sip_hangup() function
79  *
80  */
81
82
83 #include <stdio.h>
84 #include <ctype.h>
85 #include <string.h>
86 #include <unistd.h>
87 #include <sys/socket.h>
88 #include <sys/ioctl.h>
89 #include <net/if.h>
90 #include <errno.h>
91 #include <stdlib.h>
92 #include <fcntl.h>
93 #include <netdb.h>
94 #include <signal.h>
95 #include <sys/signal.h>
96 #include <netinet/in.h>
97 #include <netinet/in_systm.h>
98 #include <arpa/inet.h>
99 #include <netinet/ip.h>
100 #include <regex.h>
101
102 #include "asterisk.h"
103
104 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
105
106 #include "asterisk/lock.h"
107 #include "asterisk/channel.h"
108 #include "asterisk/config.h"
109 #include "asterisk/logger.h"
110 #include "asterisk/module.h"
111 #include "asterisk/pbx.h"
112 #include "asterisk/options.h"
113 #include "asterisk/lock.h"
114 #include "asterisk/sched.h"
115 #include "asterisk/io.h"
116 #include "asterisk/rtp.h"
117 #include "asterisk/acl.h"
118 #include "asterisk/manager.h"
119 #include "asterisk/callerid.h"
120 #include "asterisk/cli.h"
121 #include "asterisk/app.h"
122 #include "asterisk/musiconhold.h"
123 #include "asterisk/dsp.h"
124 #include "asterisk/features.h"
125 #include "asterisk/acl.h"
126 #include "asterisk/srv.h"
127 #include "asterisk/astdb.h"
128 #include "asterisk/causes.h"
129 #include "asterisk/utils.h"
130 #include "asterisk/file.h"
131 #include "asterisk/astobj.h"
132 #include "asterisk/dnsmgr.h"
133 #include "asterisk/devicestate.h"
134 #include "asterisk/linkedlists.h"
135 #include "asterisk/stringfields.h"
136 #include "asterisk/monitor.h"
137
138 #ifndef FALSE
139 #define FALSE   0
140 #endif
141
142 #ifndef TRUE
143 #define TRUE 1
144 #endif
145
146 #define VIDEO_CODEC_MASK        0x1fc0000 /*!< Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
147 #ifndef IPTOS_MINCOST
148 #define IPTOS_MINCOST           0x02
149 #endif
150
151 /* #define VOCAL_DATA_HACK */
152
153 #define DEFAULT_DEFAULT_EXPIRY  120
154 #define DEFAULT_MIN_EXPIRY      60
155 #define DEFAULT_MAX_EXPIRY      3600
156 #define DEFAULT_REGISTRATION_TIMEOUT    20
157 #define DEFAULT_MAX_FORWARDS    "70"
158
159 /* guard limit must be larger than guard secs */
160 /* guard min must be < 1000, and should be >= 250 */
161 #define EXPIRY_GUARD_SECS       15              /*!< How long before expiry do we reregister */
162 #define EXPIRY_GUARD_LIMIT      30              /*!< Below here, we use EXPIRY_GUARD_PCT instead of 
163                                                   EXPIRY_GUARD_SECS */
164 #define EXPIRY_GUARD_MIN        500             /*!< This is the minimum guard time applied. If 
165                                                   GUARD_PCT turns out to be lower than this, it 
166                                                    will use this time instead.
167                                                    This is in milliseconds. */
168 #define EXPIRY_GUARD_PCT        0.20            /*!< Percentage of expires timeout to use when 
169                                                    below EXPIRY_GUARD_LIMIT */
170 #define DEFAULT_EXPIRY 900                      /*!< Expire slowly */
171
172 static int min_expiry = DEFAULT_MIN_EXPIRY;     /*!< Minimum accepted registration time */
173 static int max_expiry = DEFAULT_MAX_EXPIRY;     /*!< Maximum accepted registration time */
174 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
175 static int expiry = DEFAULT_EXPIRY;
176
177 #ifndef MAX
178 #define MAX(a,b) ((a) > (b) ? (a) : (b))
179 #endif
180
181 #define CALLERID_UNKNOWN        "Unknown"
182
183 #define DEFAULT_MAXMS           2000            /*!< Qualification: Must be faster than 2 seconds by default */
184 #define DEFAULT_FREQ_OK         60 * 1000       /*!< Qualification: How often to check for the host to be up */
185 #define DEFAULT_FREQ_NOTOK      10 * 1000       /*!< Qualification: How often to check, if the host is down... */
186
187 #define DEFAULT_RETRANS         1000            /*!< How frequently to retransmit Default: 2 * 500 ms in RFC 3261 */
188 #define MAX_RETRANS             6               /*!< Try only 6 times for retransmissions, a total of 7 transmissions */
189 #define MAX_AUTHTRIES           3               /*!< Try authentication three times, then fail */
190
191 #define SIP_MAX_HEADERS         64                      /*!< Max amount of SIP headers to read */
192 #define SIP_MAX_LINES           64                      /*!< Max amount of lines in SIP attachment (like SDP) */
193 #define SIP_MAX_PACKET          4096    /*!< Also from RFC 3261 (2543), should sub headers tho */
194
195 #define INITIAL_CSEQ            101     /*!< our initial sip sequence number */
196
197 static const char desc[] = "Session Initiation Protocol (SIP)";
198 static const char config[] = "sip.conf";
199 static const char notify_config[] = "sip_notify.conf";
200 static int usecnt = 0;
201
202
203 #define RTP     1
204 #define NO_RTP  0
205
206 /*! \brief Authorization scheme for call transfers 
207 \note Not a bitfield flag, since there are plans for other modes,
208         like "only allow transfers for authenticated devices" */
209 enum transfermodes {
210         TRANSFER_OPENFORALL,            /*!< Allow all SIP transfers */
211         TRANSFER_CLOSED,                /*!< Allow no SIP transfers */
212 };
213
214
215 /* Do _NOT_ make any changes to this enum, or the array following it;
216    if you think you are doing the right thing, you are probably
217    not doing the right thing. If you think there are changes
218    needed, get someone else to review them first _before_
219    submitting a patch. If these two lists do not match properly
220    bad things will happen.
221 */
222
223 enum xmittype {
224         XMIT_CRITICAL = 2,              /*!< Transmit critical SIP message reliably, with re-transmits.
225                                                         If it fails, it's critical and will cause a teardown of the session */
226         XMIT_RELIABLE = 1,              /*!< Transmit SIP message reliably, with re-transmits */
227         XMIT_UNRELIABLE = 0,            /*!< Transmit SIP message without bothering with re-transmits */
228 };
229
230 enum subscriptiontype { 
231         NONE = 0,
232         TIMEOUT,
233         XPIDF_XML,
234         DIALOG_INFO_XML,
235         CPIM_PIDF_XML,
236         PIDF_XML,
237         MWI_NOTIFICATION
238 };
239
240 static const struct cfsubscription_types {
241         enum subscriptiontype type;
242         const char * const event;
243         const char * const mediatype;
244         const char * const text;
245 } subscription_types[] = {
246         { NONE,            "-",        "unknown",                    "unknown" },
247         /* IETF draft: draft-ietf-sipping-dialog-package-05.txt */
248         { DIALOG_INFO_XML, "dialog",   "application/dialog-info+xml", "dialog-info+xml" },
249         { CPIM_PIDF_XML,   "presence", "application/cpim-pidf+xml",   "cpim-pidf+xml" },  /* RFC 3863 */
250         { PIDF_XML,        "presence", "application/pidf+xml",        "pidf+xml" },       /* RFC 3863 */
251         { XPIDF_XML,       "presence", "application/xpidf+xml",       "xpidf+xml" },       /* Pre-RFC 3863 with MS additions */
252         { MWI_NOTIFICATION,     "message-summary", "application/simple-message-summary", "mwi" } /* Mailbox notification */
253 };
254
255 enum sipmethod {
256         SIP_UNKNOWN,
257         SIP_RESPONSE,
258         SIP_REGISTER,
259         SIP_OPTIONS,
260         SIP_NOTIFY,
261         SIP_INVITE,
262         SIP_ACK,
263         SIP_PRACK,
264         SIP_BYE,
265         SIP_REFER,
266         SIP_SUBSCRIBE,
267         SIP_MESSAGE,
268         SIP_UPDATE,
269         SIP_INFO,
270         SIP_CANCEL,
271         SIP_PUBLISH,
272 } sip_method_list;
273
274 enum sip_auth_type {
275         PROXY_AUTH,
276         WWW_AUTH,
277 };
278
279 /* States for outbound registrations (with register= lines in sip.conf */
280 enum sipregistrystate {
281         REG_STATE_UNREGISTERED = 0,     /*!< We are not registred */
282         REG_STATE_REGSENT,      /*!< Registration request sent */
283         REG_STATE_AUTHSENT,     /*!< We have tried to authenticate */
284         REG_STATE_REGISTERED,   /*!< Registred and done */
285         REG_STATE_REJECTED,     /*!< Registration rejected */
286         REG_STATE_TIMEOUT,      /*!< Registration timed out */
287         REG_STATE_NOAUTH,       /*!< We have no accepted credentials */
288         REG_STATE_FAILED,       /*!< Registration failed after several tries */
289 };
290
291
292 /*! XXX Note that sip_methods[i].id == i must hold or the code breaks */
293 static const struct  cfsip_methods { 
294         enum sipmethod id;
295         int need_rtp;           /*!< when this is the 'primary' use for a pvt structure, does it need RTP? */
296         char * const text;
297 } sip_methods[] = {
298         { SIP_UNKNOWN,   RTP,    "-UNKNOWN-" },
299         { SIP_RESPONSE,  NO_RTP, "SIP/2.0" },
300         { SIP_REGISTER,  NO_RTP, "REGISTER" },
301         { SIP_OPTIONS,   NO_RTP, "OPTIONS" },
302         { SIP_NOTIFY,    NO_RTP, "NOTIFY" },
303         { SIP_INVITE,    RTP,    "INVITE" },
304         { SIP_ACK,       NO_RTP, "ACK" },
305         { SIP_PRACK,     NO_RTP, "PRACK" },
306         { SIP_BYE,       NO_RTP, "BYE" },
307         { SIP_REFER,     NO_RTP, "REFER" },
308         { SIP_SUBSCRIBE, NO_RTP, "SUBSCRIBE" },
309         { SIP_MESSAGE,   NO_RTP, "MESSAGE" },
310         { SIP_UPDATE,    NO_RTP, "UPDATE" },
311         { SIP_INFO,      NO_RTP, "INFO" },
312         { SIP_CANCEL,    NO_RTP, "CANCEL" },
313         { SIP_PUBLISH,   NO_RTP, "PUBLISH" }
314 };
315
316 /*!  Define SIP option tags, used in Require: and Supported: headers 
317         We need to be aware of these properties in the phones to use 
318         the replace: header. We should not do that without knowing
319         that the other end supports it... 
320         This is nothing we can configure, we learn by the dialog
321         Supported: header on the REGISTER (peer) or the INVITE
322         (other devices)
323         We are not using many of these today, but will in the future.
324         This is documented in RFC 3261
325 */
326 #define SUPPORTED               1
327 #define NOT_SUPPORTED           0
328
329 #define SIP_OPT_REPLACES        (1 << 0)
330 #define SIP_OPT_100REL          (1 << 1)
331 #define SIP_OPT_TIMER           (1 << 2)
332 #define SIP_OPT_EARLY_SESSION   (1 << 3)
333 #define SIP_OPT_JOIN            (1 << 4)
334 #define SIP_OPT_PATH            (1 << 5)
335 #define SIP_OPT_PREF            (1 << 6)
336 #define SIP_OPT_PRECONDITION    (1 << 7)
337 #define SIP_OPT_PRIVACY         (1 << 8)
338 #define SIP_OPT_SDP_ANAT        (1 << 9)
339 #define SIP_OPT_SEC_AGREE       (1 << 10)
340 #define SIP_OPT_EVENTLIST       (1 << 11)
341 #define SIP_OPT_GRUU            (1 << 12)
342 #define SIP_OPT_TARGET_DIALOG   (1 << 13)
343
344 /*! \brief List of well-known SIP options. If we get this in a require,
345    we should check the list and answer accordingly. */
346 static const struct cfsip_options {
347         int id;                 /*!< Bitmap ID */
348         int supported;          /*!< Supported by Asterisk ? */
349         char * const text;      /*!< Text id, as in standard */
350 } sip_options[] = {     /* XXX used in 3 places */
351         /* Replaces: header for transfer */
352         { SIP_OPT_REPLACES,     SUPPORTED,      "replaces" },   
353         /* One version of Polycom firmware has the wrong label */
354         { SIP_OPT_REPLACES,     SUPPORTED,      "replace" },    
355         /* RFC3262: PRACK 100% reliability */
356         { SIP_OPT_100REL,       NOT_SUPPORTED,  "100rel" },     
357         /* SIP Session Timers */
358         { SIP_OPT_TIMER,        NOT_SUPPORTED,  "timer" },
359         /* RFC3959: SIP Early session support */
360         { SIP_OPT_EARLY_SESSION, NOT_SUPPORTED, "early-session" },
361         /* SIP Join header support */
362         { SIP_OPT_JOIN,         NOT_SUPPORTED,  "join" },
363         /* RFC3327: Path support */
364         { SIP_OPT_PATH,         NOT_SUPPORTED,  "path" },
365         /* RFC3840: Callee preferences */
366         { SIP_OPT_PREF,         NOT_SUPPORTED,  "pref" },
367         /* RFC3312: Precondition support */
368         { SIP_OPT_PRECONDITION, NOT_SUPPORTED,  "precondition" },
369         /* RFC3323: Privacy with proxies*/
370         { SIP_OPT_PRIVACY,      NOT_SUPPORTED,  "privacy" },
371         /* RFC4092: Usage of the SDP ANAT Semantics in the SIP */
372         { SIP_OPT_SDP_ANAT,     NOT_SUPPORTED,  "sdp-anat" },
373         /* RFC3329: Security agreement mechanism */
374         { SIP_OPT_SEC_AGREE,    NOT_SUPPORTED,  "sec_agree" },
375         /* SIMPLE events:  draft-ietf-simple-event-list-07.txt */
376         { SIP_OPT_EVENTLIST,    NOT_SUPPORTED,  "eventlist" },
377         /* GRUU: Globally Routable User Agent URI's */
378         { SIP_OPT_GRUU,         NOT_SUPPORTED,  "gruu" },
379         /* Target-dialog: draft-ietf-sip-target-dialog-00.txt */
380         { SIP_OPT_TARGET_DIALOG,NOT_SUPPORTED,  "target-dialog" },
381 };
382
383
384 /*! \brief SIP Methods we support */
385 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY"
386
387 /*! \brief SIP Extensions we support */
388 #define SUPPORTED_EXTENSIONS "replaces" 
389
390
391 /* Default values, set and reset in reload_config before reading configuration */
392 /* These are default values in the source. There are other recommended values in the
393    sip.conf.sample for new installations. These may differ to keep backwards compatibility,
394    yet encouraging new behaviour on new installations 
395  */
396 #define DEFAULT_SIP_PORT        5060    /*!< From RFC 3261 (former 2543) */
397 #define DEFAULT_CONTEXT         "default"
398 #define DEFAULT_MUSICCLASS      "default"
399 #define DEFAULT_VMEXTEN         "asterisk"
400 #define DEFAULT_CALLERID        "asterisk"
401 #define DEFAULT_NOTIFYMIME      "application/simple-message-summary"
402 #define DEFAULT_MWITIME         10
403 #define DEFAULT_ALLOWGUEST      TRUE
404 #define DEFAULT_SRVLOOKUP       FALSE           /*!< Recommended setting is ON */
405 #define DEFAULT_COMPACTHEADERS  FALSE
406 #define DEFAULT_TOS_SIP         0               /*!< Call signalling packets should be marked as DSCP CS3, but the default is 0 to be compatible with previous versions. */
407 #define DEFAULT_TOS_AUDIO       0               /*!< Audio packets should be marked as DSCP EF (Expedited Forwarding), but the default is 0 to be compatible with previous versions. */
408 #define DEFAULT_TOS_VIDEO       0               /*!< Video packets should be marked as DSCP AF41, but the default is 0 to be compatible with previous versions. */
409 #define DEFAULT_ALLOW_EXT_DOM   TRUE
410 #define DEFAULT_REALM           "asterisk"
411 #define DEFAULT_NOTIFYRINGING   TRUE
412 #define DEFAULT_PEDANTIC        FALSE
413 #define DEFAULT_AUTOCREATEPEER  FALSE
414 #define DEFAULT_QUALIFY         FALSE
415 #define DEFAULT_T1MIN           100             /*!< 100 MS for minimal roundtrip time */
416 #define DEFAULT_MAX_CALL_BITRATE (384)          /*!< Max bitrate for video */
417 #ifndef DEFAULT_USERAGENT
418 #define DEFAULT_USERAGENT "Asterisk PBX"        /*!< Default Useragent: header unless re-defined in sip.conf */
419 #endif
420
421
422 /* Default setttings are used as a channel setting and as a default when
423    configuring devices */
424 static char default_context[AST_MAX_CONTEXT];
425 static char default_subscribecontext[AST_MAX_CONTEXT];
426 static char default_language[MAX_LANGUAGE];
427 static char default_callerid[AST_MAX_EXTENSION];
428 static char default_fromdomain[AST_MAX_EXTENSION];
429 static char default_notifymime[AST_MAX_EXTENSION];
430 static int default_qualify;             /*!< Default Qualify= setting */
431 static char default_vmexten[AST_MAX_EXTENSION];
432 static char default_musicclass[MAX_MUSICCLASS];         /*!< Global music on hold class */
433 static int default_maxcallbitrate;      /*!< Maximum bitrate for call */
434 static struct ast_codec_pref default_prefs;             /*!< Default codec prefs */
435
436 /* Global settings only apply to the channel */
437 static int global_rtautoclear;
438 static int global_notifyringing;        /*!< Send notifications on ringing */
439 static int srvlookup;                   /*!< SRV Lookup on or off. Default is off, RFC behavior is on */
440 static int pedanticsipchecking;         /*!< Extra checking ?  Default off */
441 static int autocreatepeer;              /*!< Auto creation of peers at registration? Default off. */
442 static int global_relaxdtmf;                    /*!< Relax DTMF */
443 static int global_rtptimeout;           /*!< Time out call if no RTP */
444 static int global_rtpholdtimeout;
445 static int global_rtpkeepalive;         /*!< Send RTP keepalives */
446 static int global_reg_timeout;  
447 static int global_regattempts_max;      /*!< Registration attempts before giving up */
448 static int global_allowguest;           /*!< allow unauthenticated users/peers to connect? */
449 static int global_allowsubscribe;       /*!< Flag for disabling ALL subscriptions, this is FALSE only if all peers are FALSE 
450                                             the global setting is in globals_flags[1] */
451 static int global_mwitime;              /*!< Time between MWI checks for peers */
452 static int global_tos_sip;              /*!< IP type of service for SIP packets */
453 static int global_tos_audio;            /*!< IP type of service for audio RTP packets */
454 static int global_tos_video;            /*!< IP type of service for video RTP packets */
455 static int compactheaders;              /*!< send compact sip headers */
456 static int recordhistory;               /*!< Record SIP history. Off by default */
457 static int dumphistory;                 /*!< Dump history to verbose before destroying SIP dialog */
458 static char global_realm[MAXHOSTNAMELEN];               /*!< Default realm */
459 static char global_regcontext[AST_MAX_CONTEXT];         /*!< Context for auto-extensions */
460 static char global_useragent[AST_MAX_EXTENSION];        /*!< Useragent for the SIP channel */
461 static int allow_external_domains;      /*!< Accept calls to external SIP domains? */
462 static int global_callevents;           /*!< Whether we send manager events or not */
463 static int global_t1min;                /*!< T1 roundtrip time minimum */
464 enum transfermodes global_allowtransfer;        /*! SIP Refer restriction scheme */
465
466 /*! \brief Codecs that we support by default: */
467 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
468 static int noncodeccapability = AST_RTP_DTMF;
469
470 /* Object counters */
471 static int suserobjs = 0;               /*!< Static users */
472 static int ruserobjs = 0;               /*!< Realtime users */
473 static int speerobjs = 0;               /*!< Statis peers */
474 static int rpeerobjs = 0;               /*!< Realtime peers */
475 static int apeerobjs = 0;               /*!< Autocreated peer objects */
476 static int regobjs = 0;                 /*!< Registry objects */
477
478 static struct ast_flags global_flags[2] = {{0}};        /*!< global SIP_ flags */
479
480 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
481
482 /*! \brief Protect the SIP dialog list (of sip_pvt's) */
483 AST_MUTEX_DEFINE_STATIC(iflock);
484
485 /*! \brief Protect the monitoring thread, so only one process can kill or start it, and not
486    when it's doing something critical. */
487 AST_MUTEX_DEFINE_STATIC(netlock);
488
489 AST_MUTEX_DEFINE_STATIC(monlock);
490
491 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
492
493 /*! \brief This is the thread for the monitor which checks for input on the channels
494    which are not currently in use.  */
495 static pthread_t monitor_thread = AST_PTHREADT_NULL;
496
497 static int sip_reloading = FALSE;                       /*!< Flag for avoiding multiple reloads at the same time */
498 static enum channelreloadreason sip_reloadreason;       /*!< Reason for last reload/load of configuration */
499
500 static struct sched_context *sched;     /*!< The scheduling context */
501 static struct io_context *io;           /*!< The IO context */
502
503 #define DEC_CALL_LIMIT  0
504 #define INC_CALL_LIMIT  1
505
506
507 /*! \brief sip_request: The data grabbed from the UDP socket */
508 struct sip_request {
509         char *rlPart1;          /*!< SIP Method Name or "SIP/2.0" protocol version */
510         char *rlPart2;          /*!< The Request URI or Response Status */
511         int len;                /*!< Length */
512         int headers;            /*!< # of SIP Headers */
513         int method;             /*!< Method of this request */
514         int lines;              /*!< SDP Content */
515         unsigned int flags;     /*!< SIP_PKT Flags for this packet */
516         char *header[SIP_MAX_HEADERS];
517         char *line[SIP_MAX_LINES];
518         char data[SIP_MAX_PACKET];
519 };
520
521 /*
522  * A sip packet is stored into the data[] buffer, with the header followed
523  * by an empty line and the body of the message.
524  * On outgoing packets, data is accumulated in data[] with len reflecting
525  * the next available byte, headers and lines count the number of lines
526  * in both parts. There are no '\0' in data[0..len-1].
527  *
528  * On received packet, the input read from the socket is copied into data[],
529  * len is set and the string is NUL-terminated. Then a parser fills up
530  * the other fields -header[] and line[] to point to the lines of the
531  * message, rlPart1 and rlPart2 parse the first lnie as below:
532  *
533  * Requests have in the first line      METHOD URI SIP/2.0
534  *      rlPart1 = method; rlPart2 = uri;
535  * Responses have in the first line     SIP/2.0 code description
536  *      rlPart1 = SIP/2.0; rlPart2 = code + description;
537  *
538  */
539
540 /*! \brief structure used in transfers */
541 struct sip_dual {
542         struct ast_channel *chan1;      /*!< First channel involved */
543         struct ast_channel *chan2;      /*!< Second channel involved */
544         struct sip_request req;         /*!< Request that caused the transfer (REFER) */
545         int seqno;                      /*!< Sequence number */
546 };
547
548 struct sip_pkt;
549
550 /*! \brief Parameters to the transmit_invite function */
551 struct sip_invite_param {
552         const char *distinctive_ring;   /*!< Distinctive ring header */
553         int addsipheaders;              /*!< Add extra SIP headers */
554         const char *uri_options;        /*!< URI options to add to the URI */
555         const char *vxml_url;           /*!< VXML url for Cisco phones */
556         char *auth;                     /*!< Authentication */
557         char *authheader;               /*!< Auth header */
558         enum sip_auth_type auth_type;   /*!< Authentication type */
559         const char *replaces;           /*!< Replaces header for call transfers */
560         int transfer;                   /*!< Flag - is this Invite part of a SIP transfer? (invite/replaces) */
561 };
562
563 /*! \brief Structure to save routing information for a SIP session */
564 struct sip_route {
565         struct sip_route *next;
566         char hop[0];
567 };
568
569 /*! \brief Modes for SIP domain handling in the PBX */
570 enum domain_mode {
571         SIP_DOMAIN_AUTO,                /*!< This domain is auto-configured */
572         SIP_DOMAIN_CONFIG,              /*!< This domain is from configuration */
573 };
574
575 struct domain {
576         char domain[MAXHOSTNAMELEN];            /*!< SIP domain we are responsible for */
577         char context[AST_MAX_EXTENSION];        /*!< Incoming context for this domain */
578         enum domain_mode mode;                  /*!< How did we find this domain? */
579         AST_LIST_ENTRY(domain) list;            /*!< List mechanics */
580 };
581
582 static AST_LIST_HEAD_STATIC(domain_list, domain);       /*!< The SIP domain list */
583
584
585 /*! \brief sip_history: Structure for saving transactions within a SIP dialog */
586 struct sip_history {
587         AST_LIST_ENTRY(sip_history) list;
588         char event[0];  /* actually more, depending on needs */
589 };
590
591 AST_LIST_HEAD_NOLOCK(sip_history_head, sip_history); /*!< history list, entry in sip_pvt */
592
593 /*! \brief sip_auth: Creadentials for authentication to other SIP services */
594 struct sip_auth {
595         char realm[AST_MAX_EXTENSION];  /*!< Realm in which these credentials are valid */
596         char username[256];             /*!< Username */
597         char secret[256];               /*!< Secret */
598         char md5secret[256];            /*!< MD5Secret */
599         struct sip_auth *next;          /*!< Next auth structure in list */
600 };
601
602 /*--- Various flags for the flags field in the pvt structure */
603 #define SIP_ALREADYGONE         (1 << 0)        /*!< Whether or not we've already been destroyed by our peer */
604 #define SIP_NEEDDESTROY         (1 << 1)        /*!< if we need to be destroyed by the monitor thread */
605 #define SIP_NOVIDEO             (1 << 2)        /*!< Didn't get video in invite, don't offer */
606 #define SIP_RINGING             (1 << 3)        /*!< Have sent 180 ringing */
607 #define SIP_PROGRESS_SENT       (1 << 4)        /*!< Have sent 183 message progress */
608 #define SIP_NEEDREINVITE        (1 << 5)        /*!< Do we need to send another reinvite? */
609 #define SIP_PENDINGBYE          (1 << 6)        /*!< Need to send bye after we ack? */
610 #define SIP_GOTREFER            (1 << 7)        /*!< Got a refer? */
611 #define SIP_PROMISCREDIR        (1 << 8)        /*!< Promiscuous redirection */
612 #define SIP_TRUSTRPID           (1 << 9)        /*!< Trust RPID headers? */
613 #define SIP_USEREQPHONE         (1 << 10)       /*!< Add user=phone to numeric URI. Default off */
614 #define SIP_REALTIME            (1 << 11)       /*!< Flag for realtime users */
615 #define SIP_USECLIENTCODE       (1 << 12)       /*!< Trust X-ClientCode info message */
616 #define SIP_OUTGOING            (1 << 13)       /*!< Is this an outgoing call? */
617 #define SIP_FREEBIT             (1 << 14)       /*!< Free for session-related use */
618 #define SIP_FREEBIT3            (1 << 15)       /*!< Free for session-related use */
619 #define SIP_DTMF                (3 << 16)       /*!< DTMF Support: four settings, uses two bits */
620 #define SIP_DTMF_RFC2833        (0 << 16)       /*!< DTMF Support: RTP DTMF - "rfc2833" */
621 #define SIP_DTMF_INBAND         (1 << 16)       /*!< DTMF Support: Inband audio, only for ULAW/ALAW - "inband" */
622 #define SIP_DTMF_INFO           (2 << 16)       /*!< DTMF Support: SIP Info messages - "info" */
623 #define SIP_DTMF_AUTO           (3 << 16)       /*!< DTMF Support: AUTO switch between rfc2833 and in-band DTMF */
624 /* NAT settings */
625 #define SIP_NAT                 (3 << 18)       /*!< four settings, uses two bits */
626 #define SIP_NAT_NEVER           (0 << 18)       /*!< No nat support */
627 #define SIP_NAT_RFC3581         (1 << 18)       /*!< NAT RFC3581 */
628 #define SIP_NAT_ROUTE           (2 << 18)       /*!< NAT Only ROUTE */
629 #define SIP_NAT_ALWAYS          (3 << 18)       /*!< NAT Both ROUTE and RFC3581 */
630 /* re-INVITE related settings */
631 #define SIP_REINVITE            (3 << 20)       /*!< two bits used */
632 #define SIP_CAN_REINVITE        (1 << 20)       /*!< allow peers to be reinvited to send media directly p2p */
633 #define SIP_REINVITE_UPDATE     (2 << 20)       /*!< use UPDATE (RFC3311) when reinviting this peer */
634 /* "insecure" settings */
635 #define SIP_INSECURE_PORT       (1 << 22)       /*!< don't require matching port for incoming requests */
636 #define SIP_INSECURE_INVITE     (1 << 23)       /*!< don't require authentication for incoming INVITEs */
637 /* Sending PROGRESS in-band settings */
638 #define SIP_PROG_INBAND         (3 << 24)       /*!< three settings, uses two bits */
639 #define SIP_PROG_INBAND_NEVER   (0 << 24)
640 #define SIP_PROG_INBAND_NO      (1 << 24)
641 #define SIP_PROG_INBAND_YES     (2 << 24)
642 #define SIP_CALL_ONHOLD         (1 << 26)       /*!< Call states */
643 #define SIP_CALL_LIMIT          (1 << 27)       /*!< Call limit enforced for this call */
644 #define SIP_SENDRPID            (1 << 28)       /*!< Remote Party-ID Support */
645 #define SIP_INC_COUNT           (1 << 29)       /*!< Did this connection increment the counter of in-use calls? */
646
647 #define SIP_FLAGS_TO_COPY \
648         (SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_SENDRPID | SIP_DTMF | SIP_REINVITE | \
649          SIP_PROG_INBAND | SIP_USECLIENTCODE | SIP_NAT | \
650          SIP_USEREQPHONE | SIP_INSECURE_PORT | SIP_INSECURE_INVITE)
651
652 /* a new page of flags for peers */
653 #define SIP_PAGE2_RTCACHEFRIENDS        (1 << 0)
654 #define SIP_PAGE2_RTUPDATE              (1 << 1)
655 #define SIP_PAGE2_RTAUTOCLEAR           (1 << 2)
656 #define SIP_PAGE2_IGNOREREGEXPIRE       (1 << 3)
657 #define SIP_PAGE2_RT_FROMCONTACT        (1 << 4)
658 #define SIP_PAGE2_DEBUG                 (3 << 5)
659 #define SIP_PAGE2_DEBUG_CONFIG          (1 << 5)
660 #define SIP_PAGE2_DEBUG_CONSOLE         (1 << 6)
661 #define SIP_PAGE2_DYNAMIC               (1 << 7)        /*!< Dynamic Peers register with Asterisk */
662 #define SIP_PAGE2_SELFDESTRUCT          (1 << 8)        /*!< Automatic peers need to destruct themselves */
663 #define SIP_PAGE2_VIDEOSUPPORT          (1 << 9)
664 #define SIP_PAGE2_ALLOWSUBSCRIBE        (1 << 10)       /*!< Allow subscriptions from this peer? */
665 #define SIP_PAGE2_ALLOWOVERLAP          (1 << 11)       /*!< Allow overlap dialing ? */
666 #define SIP_PAGE2_SUBSCRIBEMWIONLY      (1 << 12)       /*!< Only issue MWI notification if subscribed to */
667
668
669 #define SIP_PAGE2_FLAGS_TO_COPY \
670         (SIP_PAGE2_ALLOWSUBSCRIBE | SIP_PAGE2_ALLOWOVERLAP | SIP_PAGE2_VIDEOSUPPORT)
671
672 /* SIP packet flags */
673 #define SIP_PKT_DEBUG           (1 << 0)        /*!< Debug this packet */
674 #define SIP_PKT_WITH_TOTAG      (1 << 1)        /*!< This packet has a to-tag */
675 #define SIP_PKT_IGNORE          (1 << 2)        /*!< This is a re-transmit, ignore it */
676 #define SIP_PKT_IGNORE_RESP     (1 << 3)        /*!< Resp ignore - ??? */
677 #define SIP_PKT_IGNORE_REQ      (1 << 4)        /*!< Req ignore - ??? */
678
679 #define sipdebug                ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG)
680 #define sipdebug_config         ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG)
681 #define sipdebug_console        ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE)
682
683 /*! \brief Parameters to know status of transfer */
684 enum referstatus {
685         REFER_IDLE,             /*!< No REFER is in progress */
686         REFER_SENT,             /*!< Sent REFER to transferee */
687         REFER_RECEIVED,         /*!< Received REFER from transferer */
688         REFER_CONFIRMED,        /*!< Refer confirmed with a 100 TRYING */
689         REFER_ACCEPTED,         /*!< Accepted by transferee */
690         REFER_RINGING,          /*!< Target Ringing */
691         REFER_200OK,            /*!< Answered by transfer target */
692         REFER_FAILED,           /*!< REFER declined - go on */
693         REFER_NOAUTH            /*!< We had no auth for REFER */
694 };
695
696 static const struct c_referstatusstring {
697         enum referstatus status;
698         char *text;
699 } referstatusstrings[] = {
700         { REFER_IDLE,           "<none>" },
701         { REFER_SENT,           "Request sent" },
702         { REFER_RECEIVED,       "Request received" },
703         { REFER_ACCEPTED,       "Accepted" },
704         { REFER_RINGING,        "Target ringing" },
705         { REFER_200OK,          "Done" },
706         { REFER_FAILED,         "Failed" },
707         { REFER_NOAUTH,         "Failed - auth failure" }
708 } ;
709
710
711 /*! \brief sip_pvt: PVT structures are used for each SIP dialog, ie. a call, a registration, a subscribe  */
712 static struct sip_pvt {
713         ast_mutex_t lock;                       /*!< Dialog private lock */
714         int method;                             /*!< SIP method that opened this dialog */
715         AST_DECLARE_STRING_FIELDS(
716                 AST_STRING_FIELD(callid);       /*!< Global CallID */
717                 AST_STRING_FIELD(randdata);     /*!< Random data */
718                 AST_STRING_FIELD(accountcode);  /*!< Account code */
719                 AST_STRING_FIELD(realm);        /*!< Authorization realm */
720                 AST_STRING_FIELD(nonce);        /*!< Authorization nonce */
721                 AST_STRING_FIELD(opaque);       /*!< Opaque nonsense */
722                 AST_STRING_FIELD(qop);          /*!< Quality of Protection, since SIP wasn't complicated enough yet. */
723                 AST_STRING_FIELD(domain);       /*!< Authorization domain */
724                 AST_STRING_FIELD(refer_to);     /*!< Place to store REFER-TO extension */
725                 AST_STRING_FIELD(referred_by);  /*!< Place to store REFERRED-BY extension */
726                 AST_STRING_FIELD(refer_contact);/*!< Place to store Contact info from a REFER extension */
727                 AST_STRING_FIELD(from);         /*!< The From: header */
728                 AST_STRING_FIELD(useragent);    /*!< User agent in SIP request */
729                 AST_STRING_FIELD(exten);        /*!< Extension where to start */
730                 AST_STRING_FIELD(context);      /*!< Context for this call */
731                 AST_STRING_FIELD(subscribecontext); /*!< Subscribecontext */
732                 AST_STRING_FIELD(fromdomain);   /*!< Domain to show in the from field */
733                 AST_STRING_FIELD(fromuser);     /*!< User to show in the user field */
734                 AST_STRING_FIELD(fromname);     /*!< Name to show in the user field */
735                 AST_STRING_FIELD(tohost);       /*!< Host we should put in the "to" field */
736                 AST_STRING_FIELD(language);     /*!< Default language for this call */
737                 AST_STRING_FIELD(musicclass);   /*!< Music on Hold class */
738                 AST_STRING_FIELD(rdnis);        /*!< Referring DNIS */
739                 AST_STRING_FIELD(theirtag);     /*!< Their tag */
740                 AST_STRING_FIELD(username);     /*!< [user] name */
741                 AST_STRING_FIELD(peername);     /*!< [peer] name, not set if [user] */
742                 AST_STRING_FIELD(authname);     /*!< Who we use for authentication */
743                 AST_STRING_FIELD(uri);          /*!< Original requested URI */
744                 AST_STRING_FIELD(okcontacturi); /*!< URI from the 200 OK on INVITE */
745                 AST_STRING_FIELD(peersecret);   /*!< Password */
746                 AST_STRING_FIELD(peermd5secret);
747                 AST_STRING_FIELD(cid_num);      /*!< Caller*ID */
748                 AST_STRING_FIELD(cid_name);     /*!< Caller*ID */
749                 AST_STRING_FIELD(via);          /*!< Via: header */
750                 AST_STRING_FIELD(fullcontact);  /*!< The Contact: that the UA registers with us */
751                 AST_STRING_FIELD(our_contact);  /*!< Our contact header */
752                 AST_STRING_FIELD(rpid);         /*!< Our RPID header */
753                 AST_STRING_FIELD(rpid_from);    /*!< Our RPID From header */
754         );
755         struct ast_codec_pref prefs;            /*!< codec prefs */
756         unsigned int ocseq;                     /*!< Current outgoing seqno */
757         unsigned int icseq;                     /*!< Current incoming seqno */
758         ast_group_t callgroup;                  /*!< Call group */
759         ast_group_t pickupgroup;                /*!< Pickup group */
760         int lastinvite;                         /*!< Last Cseq of invite */
761         struct ast_flags flags[2];              /*!< SIP_ flags */
762         int timer_t1;                           /*!< SIP timer T1, ms rtt */
763         unsigned int sipoptions;                /*!< Supported SIP sipoptions on the other end */
764         int capability;                         /*!< Special capability (codec) */
765         int jointcapability;                    /*!< Supported capability at both ends (codecs ) */
766         int peercapability;                     /*!< Supported peer capability */
767         int prefcodec;                          /*!< Preferred codec (outbound only) */
768         int noncodeccapability;
769         int maxcallbitrate;                     /*!< Maximum Call Bitrate for Video Calls */    
770         int callingpres;                        /*!< Calling presentation */
771         int authtries;                          /*!< Times we've tried to authenticate */
772         int expiry;                             /*!< How long we take to expire */
773         long branch;                            /*!< One random number */
774         char tag[11];                           /*!< Another random number */
775         int sessionid;                          /*!< SDP Session ID */
776         int sessionversion;                     /*!< SDP Session Version */
777         struct sockaddr_in sa;                  /*!< Our peer */
778         struct sockaddr_in redirip;             /*!< Where our RTP should be going if not to us */
779         struct sockaddr_in vredirip;            /*!< Where our Video RTP should be going if not to us */
780         int redircodecs;                        /*!< Redirect codecs */
781         struct sockaddr_in recv;                /*!< Received as */
782         struct in_addr ourip;                   /*!< Our IP */
783         struct ast_channel *owner;              /*!< Who owns us */
784         struct sip_pvt *refer_call;             /*!< Call we are referring */
785         struct sip_route *route;                /*!< Head of linked list of routing steps (fm Record-Route) */
786         int route_persistant;                   /*!< Is this the "real" route? */
787         struct sip_auth *peerauth;              /*!< Realm authentication */
788         int noncecount;                         /*!< Nonce-count */
789         char lastmsg[256];                      /*!< Last Message sent/received */
790         int amaflags;                           /*!< AMA Flags */
791         int pendinginvite;                      /*!< Any pending invite */
792         struct sip_request initreq;             /*!< Initial request that opened the SIP dialog */
793         
794         int maxtime;                            /*!< Max time for first response */
795         int initid;                             /*!< Auto-congest ID if appropriate */
796         int autokillid;                         /*!< Auto-kill ID */
797         time_t lastrtprx;                       /*!< Last RTP received */
798         time_t lastrtptx;                       /*!< Last RTP sent */
799         int rtptimeout;                         /*!< RTP timeout time */
800         int rtpholdtimeout;                     /*!< RTP timeout when on hold */
801         int rtpkeepalive;                       /*!< Send RTP packets for keepalive */
802         enum transfermodes allowtransfer;       /*! SIP Refer restriction scheme */
803         enum subscriptiontype subscribed;       /*!< Is this dialog a subscription?  */
804         int stateid;
805         int laststate;                          /*!< Last known extension state */
806         int dialogver;
807         
808         struct ast_dsp *vad;                    /*!< Voice Activation Detection dsp */
809         
810         struct sip_peer *relatedpeer;           /*!< If this dialog is related to a peer, which one 
811                                                         Used in peerpoke, mwi subscriptions */
812         struct sip_registry *registry;          /*!< If this is a REGISTER dialog, to which registry */
813         struct ast_rtp *rtp;                    /*!< RTP Session */
814         struct ast_rtp *vrtp;                   /*!< Video RTP session */
815         struct sip_pkt *packets;                /*!< Packets scheduled for re-transmission */
816         struct sip_history_head *history;       /*!< History of this SIP dialog */
817         struct ast_variable *chanvars;          /*!< Channel variables to set for call */
818         struct sip_pvt *next;                   /*!< Next dialog in chain */
819         struct sip_invite_param *options;       /*!< Options for INVITE */
820 } *iflist = NULL;
821
822 #define FLAG_RESPONSE (1 << 0)
823 #define FLAG_FATAL (1 << 1)
824
825 /*! \brief sip packet - read in sipsock_read(), transmitted in send_request() */
826 struct sip_pkt {
827         struct sip_pkt *next;                   /*!< Next packet */
828         int retrans;                            /*!< Retransmission number */
829         int method;                             /*!< SIP method for this packet */
830         int seqno;                              /*!< Sequence number */
831         unsigned int flags;                     /*!< non-zero if this is a response packet (e.g. 200 OK) */
832         struct sip_pvt *owner;                  /*!< Owner AST call */
833         int retransid;                          /*!< Retransmission ID */
834         int timer_a;                            /*!< SIP timer A, retransmission timer */
835         int timer_t1;                           /*!< SIP Timer T1, estimated RTT or 500 ms */
836         int packetlen;                          /*!< Length of packet */
837         char data[0];
838 };      
839
840 /*! \brief Structure for SIP user data. User's place calls to us */
841 struct sip_user {
842         /* Users who can access various contexts */
843         ASTOBJ_COMPONENTS(struct sip_user);
844         char secret[80];                /*!< Password */
845         char md5secret[80];             /*!< Password in md5 */
846         char context[AST_MAX_CONTEXT];  /*!< Default context for incoming calls */
847         char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
848         char cid_num[80];               /*!< Caller ID num */
849         char cid_name[80];              /*!< Caller ID name */
850         char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
851         char language[MAX_LANGUAGE];    /*!< Default language for this user */
852         char musicclass[MAX_MUSICCLASS];/*!< Music on Hold class */
853         char useragent[256];            /*!< User agent in SIP request */
854         struct ast_codec_pref prefs;    /*!< codec prefs */
855         ast_group_t callgroup;          /*!< Call group */
856         ast_group_t pickupgroup;        /*!< Pickup Group */
857         unsigned int sipoptions;        /*!< Supported SIP options */
858         struct ast_flags flags[2];      /*!< SIP_ flags */
859         int amaflags;                   /*!< AMA flags for billing */
860         int callingpres;                /*!< Calling id presentation */
861         int capability;                 /*!< Codec capability */
862         int inUse;                      /*!< Number of calls in use */
863         int call_limit;                 /*!< Limit of concurrent calls */
864         enum transfermodes allowtransfer;       /*! SIP Refer restriction scheme */
865         struct ast_ha *ha;              /*!< ACL setting */
866         struct ast_variable *chanvars;  /*!< Variables to set for channel created by user */
867         int maxcallbitrate;             /*!< Maximum Bitrate for a video call */
868 };
869
870 /*! \brief Structure for SIP peer data, we place calls to peers if registered  or fixed IP address (host) */
871 /* XXX field 'name' must be first otherwise sip_addrcmp() will fail */
872 struct sip_peer {
873         ASTOBJ_COMPONENTS(struct sip_peer);     /*!< name, refcount, objflags,  object pointers */
874                                         /*!< peer->name is the unique name of this object */
875         char secret[80];                /*!< Password */
876         char md5secret[80];             /*!< Password in MD5 */
877         struct sip_auth *auth;          /*!< Realm authentication list */
878         char context[AST_MAX_CONTEXT];  /*!< Default context for incoming calls */
879         char subscribecontext[AST_MAX_CONTEXT]; /*!< Default context for subscriptions */
880         char username[80];              /*!< Temporary username until registration */ 
881         char accountcode[AST_MAX_ACCOUNT_CODE]; /*!< Account code */
882         int amaflags;                   /*!< AMA Flags (for billing) */
883         char tohost[MAXHOSTNAMELEN];    /*!< If not dynamic, IP address */
884         char regexten[AST_MAX_EXTENSION]; /*!< Extension to register (if regcontext is used) */
885         char fromuser[80];              /*!< From: user when calling this peer */
886         char fromdomain[MAXHOSTNAMELEN];        /*!< From: domain when calling this peer */
887         char fullcontact[256];          /*!< Contact registered with us (not in sip.conf) */
888         char cid_num[80];               /*!< Caller ID num */
889         char cid_name[80];              /*!< Caller ID name */
890         int callingpres;                /*!< Calling id presentation */
891         int inUse;                      /*!< Number of calls in use */
892         int call_limit;                 /*!< Limit of concurrent calls */
893         enum transfermodes allowtransfer;       /*! SIP Refer restriction scheme */
894         char vmexten[AST_MAX_EXTENSION]; /*!< Dialplan extension for MWI notify message*/
895         char mailbox[AST_MAX_EXTENSION]; /*!< Mailbox setting for MWI checks */
896         char language[MAX_LANGUAGE];    /*!<  Default language for prompts */
897         char musicclass[MAX_MUSICCLASS];/*!<  Music on Hold class */
898         char useragent[256];            /*!<  User agent in SIP request (saved from registration) */
899         struct ast_codec_pref prefs;    /*!<  codec prefs */
900         int lastmsgssent;
901         time_t  lastmsgcheck;           /*!<  Last time we checked for MWI */
902         unsigned int sipoptions;        /*!<  Supported SIP options */
903         struct ast_flags flags[2];      /*!<  SIP_ flags */
904         int expire;                     /*!<  When to expire this peer registration */
905         int capability;                 /*!<  Codec capability */
906         int rtptimeout;                 /*!<  RTP timeout */
907         int rtpholdtimeout;             /*!<  RTP Hold Timeout */
908         int rtpkeepalive;               /*!<  Send RTP packets for keepalive */
909         ast_group_t callgroup;          /*!<  Call group */
910         ast_group_t pickupgroup;        /*!<  Pickup group */
911         struct ast_dnsmgr_entry *dnsmgr;/*!<  DNS refresh manager for peer */
912         struct sockaddr_in addr;        /*!<  IP address of peer */
913         int maxcallbitrate;             /*!< Maximum Bitrate for a video call */
914         
915         /* Qualification */
916         struct sip_pvt *call;           /*!<  Call pointer */
917         int pokeexpire;                 /*!<  When to expire poke (qualify= checking) */
918         int lastms;                     /*!<  How long last response took (in ms), or -1 for no response */
919         int maxms;                      /*!<  Max ms we will accept for the host to be up, 0 to not monitor */
920         struct timeval ps;              /*!<  Ping send time */
921         
922         struct sockaddr_in defaddr;     /*!<  Default IP address, used until registration */
923         struct ast_ha *ha;              /*!<  Access control list */
924         struct ast_variable *chanvars;  /*!<  Variables to set for channel created by user */
925         struct sip_pvt *mwipvt;         /*!<  Subscription for MWI */
926         int lastmsg;
927 };
928
929
930
931 /*! \brief Registrations with other SIP proxies */
932 struct sip_registry {
933         ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
934         AST_DECLARE_STRING_FIELDS(
935                 AST_STRING_FIELD(callid);       /*!< Global Call-ID */
936                 AST_STRING_FIELD(realm);        /*!< Authorization realm */
937                 AST_STRING_FIELD(nonce);        /*!< Authorization nonce */
938                 AST_STRING_FIELD(opaque);       /*!< Opaque nonsense */
939                 AST_STRING_FIELD(qop);          /*!< Quality of Protection, since SIP wasn't complicated enough yet. */
940                 AST_STRING_FIELD(domain);       /*!< Authorization domain */
941                 AST_STRING_FIELD(username);     /*!< Who we are registering as */
942                 AST_STRING_FIELD(authuser);     /*!< Who we *authenticate* as */
943                 AST_STRING_FIELD(hostname);     /*!< Domain or host we register to */
944                 AST_STRING_FIELD(secret);       /*!< Password in clear text */  
945                 AST_STRING_FIELD(md5secret);    /*!< Password in md5 */
946                 AST_STRING_FIELD(contact);      /*!< Contact extension */
947                 AST_STRING_FIELD(random);
948         );
949         int portno;                     /*!<  Optional port override */
950         int expire;                     /*!< Sched ID of expiration */
951         int regattempts;                /*!< Number of attempts (since the last success) */
952         int timeout;                    /*!< sched id of sip_reg_timeout */
953         int refresh;                    /*!< How often to refresh */
954         struct sip_pvt *call;           /*!< create a sip_pvt structure for each outbound "registration dialog" in progress */
955         enum sipregistrystate regstate; /*!< Registration state (see above) */
956         int callid_valid;               /*!< 0 means we haven't chosen callid for this registry yet. */
957         unsigned int ocseq;             /*!< Sequence number we got to for REGISTERs for this registry */
958         struct sockaddr_in us;          /*!< Who the server thinks we are */
959         int noncecount;                 /*!< Nonce-count */
960         char lastmsg[256];              /*!< Last Message sent/received */
961 };
962
963 /* --- Linked lists of various objects --------*/
964
965 /*! \brief  The user list: Users and friends */
966 static struct ast_user_list {
967         ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
968 } userl;
969
970 /*! \brief  The peer list: Peers and Friends */
971 static struct ast_peer_list {
972         ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
973 } peerl;
974
975 /*! \brief  The register list: Other SIP proxys we register with and place calls to */
976 static struct ast_register_list {
977         ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
978         int recheck;
979 } regl;
980
981 /*! \todo Move the sip_auth list to AST_LIST */
982 static struct sip_auth *authl = NULL;           /*!< Authentication list for realm authentication */
983
984
985 /* --- Sockets and networking --------------*/
986 static int sipsock  = -1;                       /*!< Main socket for SIP network communication */
987 static struct sockaddr_in bindaddr = { 0, };    /*!< The address we bind to */
988 static struct sockaddr_in externip;             /*!< External IP address if we are behind NAT */
989 static char externhost[MAXHOSTNAMELEN];         /*!< External host name (possibly with dynamic DNS and DHCP */
990 static time_t externexpire = 0;                 /*!< Expiration counter for re-resolving external host name in dynamic DNS */
991 static int externrefresh = 10;
992 static struct ast_ha *localaddr;                /*!< List of local networks, on the same side of NAT as this Asterisk */
993 static struct in_addr __ourip;
994 static struct sockaddr_in outboundproxyip;
995 static int ourport;
996 static struct sockaddr_in debugaddr;
997
998 struct ast_config *notify_types;                /*!< The list of manual NOTIFY types we know how to send */
999
1000
1001
1002 /*---------------------------- Forward declarations of functions in chan_sip.c */
1003 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
1004 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, enum xmittype reliable);
1005 static int transmit_response_with_unsupported(struct sip_pvt *p, const char *msg, struct sip_request *req, const char *unsupported);
1006 static int transmit_response_with_auth(struct sip_pvt *p, const char *msg, struct sip_request *req, const char *rand, enum xmittype reliable, const char *header, int stale);
1007 static int transmit_request(struct sip_pvt *p, int sipmethod, int inc, enum xmittype reliable, int newbranch);
1008 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int inc, enum xmittype reliable, int newbranch);
1009 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sendsdp, int init);
1010 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
1011 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
1012 static int transmit_info_with_vidupdate(struct sip_pvt *p);
1013 static int transmit_message_with_text(struct sip_pvt *p, const char *text);
1014 static int transmit_refer(struct sip_pvt *p, const char *dest);
1015 static int sip_sipredirect(struct sip_pvt *p, const char *dest);
1016 static struct sip_peer *temp_peer(const char *name);
1017 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, int sipmethod, int init);
1018 static void free_old_route(struct sip_route *route);
1019 static int reply_digest(struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len);
1020 static int build_reply_digest(struct sip_pvt *p, int method, char *digest, int digest_len);
1021 static int update_call_counter(struct sip_pvt *fup, int event);
1022 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int realtime);
1023 static struct sip_user *build_user(const char *name, struct ast_variable *v, int realtime);
1024 static int sip_do_reload(enum channelreloadreason reason);
1025 static int expire_register(void *data);
1026 static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause);
1027 static int sip_devicestate(void *data);
1028 static int sip_sendtext(struct ast_channel *ast, const char *text);
1029 static int sip_call(struct ast_channel *ast, char *dest, int timeout);
1030 static int sip_hangup(struct ast_channel *ast);
1031 static int sip_answer(struct ast_channel *ast);
1032 static struct ast_frame *sip_read(struct ast_channel *ast);
1033 static int sip_write(struct ast_channel *ast, struct ast_frame *frame);
1034 static int sip_indicate(struct ast_channel *ast, int condition);
1035 static int sip_transfer(struct ast_channel *ast, const char *dest);
1036 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
1037 static int sip_senddigit(struct ast_channel *ast, char digit);
1038 static int clear_realm_authentication(struct sip_auth *authlist);       /* Clear realm authentication list (at reload) */
1039 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno);   /* Add realm authentication in list */
1040 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, const char *realm);        /* Find authentication for a specific realm */
1041 static int check_auth(struct sip_pvt *p, struct sip_request *req, const char *username,
1042                 const char *secret, const char *md5secret, int sipmethod,
1043                 char *uri, enum xmittype reliable, int ignore);
1044 static int check_sip_domain(const char *domain, char *context, size_t len); /* Check if domain is one of our local domains */
1045 static void append_date(struct sip_request *req);       /* Append date to SIP packet */
1046 static int determine_firstline_parts(struct sip_request *req);
1047 static void sip_dump_history(struct sip_pvt *dialog);   /* Dump history to LOG_DEBUG at end of dialog, before destroying data */
1048 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
1049 static int transmit_state_notify(struct sip_pvt *p, int state, int full);
1050 static const char *gettag(const struct sip_request *req, char *header, char *tagbuf, int tagbufsize);
1051 static int find_sip_method(const char *msg);
1052 static unsigned int parse_sip_options(struct sip_pvt *pvt, const char *supported);
1053 static void sip_destroy(struct sip_pvt *p);
1054 static void sip_destroy_peer(struct sip_peer *peer);
1055 static void sip_destroy_user(struct sip_user *user);
1056 static void parse_request(struct sip_request *req);
1057 static const char *get_header(const struct sip_request *req, const char *name);
1058 static void copy_request(struct sip_request *dst,struct sip_request *src);
1059 static int transmit_response_reliable(struct sip_pvt *p, const char *msg, struct sip_request *req);
1060 static int transmit_register(struct sip_registry *r, int sipmethod, char *auth, char *authheader);
1061 static int sip_poke_peer(struct sip_peer *peer);
1062 static int __sip_do_register(struct sip_registry *r);
1063 static int restart_monitor(void);
1064 static void set_peer_defaults(struct sip_peer *peer);
1065 static struct sip_peer *temp_peer(const char *name);
1066 static int sip_send_mwi_to_peer(struct sip_peer *peer);
1067 static int sip_scheddestroy(struct sip_pvt *p, int ms);
1068
1069 /*------Request handling functions */
1070 static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct sockaddr_in *sin, int *recount, char *e);
1071 static int handle_request_refer(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, int *nounlock);
1072 static int handle_request_bye(struct sip_pvt *p, struct sip_request *req);
1073 static int handle_request_register(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, char *e);
1074 static int handle_request_cancel(struct sip_pvt *p, struct sip_request *req);
1075 static int handle_request_message(struct sip_pvt *p, struct sip_request *req);
1076 static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e);
1077 static void handle_request_info(struct sip_pvt *p, struct sip_request *req);
1078 static int handle_request_options(struct sip_pvt *p, struct sip_request *req);
1079
1080 /*----- RTP interface functions */
1081 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active);
1082 static struct ast_rtp *sip_get_rtp_peer(struct ast_channel *chan);
1083 static struct ast_rtp *sip_get_vrtp_peer(struct ast_channel *chan);
1084 static int sip_get_codec(struct ast_channel *chan);
1085
1086 /*! \brief Definition of this channel for PBX channel registration */
1087 static const struct ast_channel_tech sip_tech = {
1088         .type = "SIP",
1089         .description = "Session Initiation Protocol (SIP)",
1090         .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
1091         .properties = AST_CHAN_TP_WANTSJITTER,
1092         .requester = sip_request_call,
1093         .devicestate = sip_devicestate,
1094         .call = sip_call,
1095         .hangup = sip_hangup,
1096         .answer = sip_answer,
1097         .read = sip_read,
1098         .write = sip_write,
1099         .write_video = sip_write,
1100         .indicate = sip_indicate,
1101         .transfer = sip_transfer,
1102         .fixup = sip_fixup,
1103         .send_digit = sip_senddigit,
1104         .bridge = ast_rtp_bridge,
1105         .send_text = sip_sendtext,
1106 };
1107
1108 /*! \brief Interface structure with callbacks used to connect to RTP module */
1109 static struct ast_rtp_protocol sip_rtp = {
1110         type: "SIP",
1111         get_rtp_info: sip_get_rtp_peer,
1112         get_vrtp_info: sip_get_vrtp_peer,
1113         set_rtp_peer: sip_set_rtp_peer,
1114         get_codec: sip_get_codec,
1115 };
1116
1117 /*! \brief Convert transfer status to string */
1118 static char *referstatus2str(enum referstatus rstatus)
1119 {
1120         int i = (sizeof(referstatusstrings) / sizeof(referstatusstrings[0]));
1121         int x;
1122
1123         for (x = 0; x < i; x++) {
1124                 if (referstatusstrings[x].status ==  rstatus)
1125                         return (char *) referstatusstrings[x].text;
1126         }
1127         return "";
1128 }
1129
1130
1131 /*! \brief returns true if 'name' (with optional trailing whitespace)
1132  * matches the sip method 'id'.
1133  * Strictly speaking, SIP methods are case SENSITIVE, but we do
1134  * a case-insensitive comparison to be more tolerant.
1135  * following Jon Postel's rule: Be gentle in what you accept, strict with what you send 
1136  */
1137 static int method_match(enum sipmethod id, const char *name)
1138 {
1139         int len = strlen(sip_methods[id].text);
1140         int l_name = name ? strlen(name) : 0;
1141         /* true if the string is long enough, and ends with whitespace, and matches */
1142         return (l_name >= len && name[len] < 33 &&
1143                 !strncasecmp(sip_methods[id].text, name, len));
1144 }
1145
1146 /*! \brief  find_sip_method: Find SIP method from header */
1147 static int find_sip_method(const char *msg)
1148 {
1149         int i, res = 0;
1150         
1151         if (ast_strlen_zero(msg))
1152                 return 0;
1153         for (i = 1; i < (sizeof(sip_methods) / sizeof(sip_methods[0])) && !res; i++) {
1154                 if (method_match(i, msg))
1155                         res = sip_methods[i].id;
1156         }
1157         return res;
1158 }
1159
1160 /*! \brief Parse supported header in incoming packet */
1161 static unsigned int parse_sip_options(struct sip_pvt *pvt, const char *supported)
1162 {
1163         char *next, *sep;
1164         char *temp = ast_strdupa(supported);
1165         unsigned int profile = 0;
1166         int i, found;
1167
1168         if (!pvt || ast_strlen_zero(supported) )
1169                 return 0;
1170
1171         if (option_debug > 2 && sipdebug)
1172                 ast_log(LOG_DEBUG, "Begin: parsing SIP \"Supported: %s\"\n", supported);
1173
1174         for (next = temp; next; next = sep) {
1175                 found = FALSE;
1176                 if ( (sep = strchr(next, ',')) != NULL)
1177                         *sep++ = '\0';
1178                 next = ast_skip_blanks(next);
1179                 if (option_debug > 2 && sipdebug)
1180                         ast_log(LOG_DEBUG, "Found SIP option: -%s-\n", next);
1181                 for (i=0; i < (sizeof(sip_options) / sizeof(sip_options[0])); i++) {
1182                         if (!strcasecmp(next, sip_options[i].text)) {
1183                                 profile |= sip_options[i].id;
1184                                 found = TRUE;
1185                                 if (option_debug > 2 && sipdebug)
1186                                         ast_log(LOG_DEBUG, "Matched SIP option: %s\n", next);
1187                                 break;
1188                         }
1189                 }
1190                 if (!found && option_debug > 2 && sipdebug)
1191                         ast_log(LOG_DEBUG, "Found no match for SIP option: %s (Please file bug report!)\n", next);
1192         }
1193
1194         pvt->sipoptions = profile;
1195         return profile;
1196 }
1197
1198 /*! \brief See if we pass debug IP filter */
1199 static inline int sip_debug_test_addr(const struct sockaddr_in *addr) 
1200 {
1201         if (!sipdebug)
1202                 return 0;
1203         if (debugaddr.sin_addr.s_addr) {
1204                 if (((ntohs(debugaddr.sin_port) != 0)
1205                         && (debugaddr.sin_port != addr->sin_port))
1206                         || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
1207                         return 0;
1208         }
1209         return 1;
1210 }
1211
1212 /* The real destination address for a write */
1213 static const struct sockaddr_in *sip_real_dst(const struct sip_pvt *p)
1214 {
1215         return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? &p->recv : &p->sa;
1216 }
1217
1218 static const char *sip_nat_mode(const struct sip_pvt *p)
1219 {
1220         return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? "NAT" : "no NAT";
1221 }
1222
1223 /*! \brief Test PVT for debugging output */
1224 static inline int sip_debug_test_pvt(struct sip_pvt *p) 
1225 {
1226         if (!sipdebug)
1227                 return 0;
1228         return sip_debug_test_addr(sip_real_dst(p));
1229 }
1230
1231 /*! \brief Transmit SIP message */
1232 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
1233 {
1234         int res;
1235         char iabuf[INET_ADDRSTRLEN];
1236         const struct sockaddr_in *dst = sip_real_dst(p);
1237         res=sendto(sipsock, data, len, 0, (const struct sockaddr *)dst, sizeof(struct sockaddr_in));
1238
1239         if (res != len)
1240                 ast_log(LOG_WARNING, "sip_xmit of %p (len %d) to %s:%d returned %d: %s\n", data, len, ast_inet_ntoa(iabuf, sizeof(iabuf), dst->sin_addr), ntohs(dst->sin_port), res, strerror(errno));
1241         return res;
1242 }
1243
1244
1245 /*! \brief Build a Via header for a request */
1246 static void build_via(struct sip_pvt *p)
1247 {
1248         char iabuf[INET_ADDRSTRLEN];
1249         /* Work around buggy UNIDEN UIP200 firmware */
1250         const char *rport = ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_RFC3581 ? ";rport" : "";
1251
1252         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
1253         ast_string_field_build(p, via, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x%s",
1254                          ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch, rport);
1255 }
1256
1257 /*! \brief NAT fix - decide which IP address to use for ASterisk server?
1258  * Only used for outbound registrations */
1259 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
1260 {
1261         /*
1262          * Using the localaddr structure built up with localnet statements
1263          * apply it to their address to see if we need to substitute our
1264          * externip or can get away with our internal bindaddr
1265          */
1266         struct sockaddr_in theirs;
1267         theirs.sin_addr = *them;
1268
1269         if (localaddr && externip.sin_addr.s_addr &&
1270            ast_apply_ha(localaddr, &theirs)) {
1271                 if (externexpire && time(NULL) >= externexpire) {
1272                         struct ast_hostent ahp;
1273                         struct hostent *hp;
1274
1275                         time(&externexpire);
1276                         externexpire += externrefresh;
1277                         if ((hp = ast_gethostbyname(externhost, &ahp))) {
1278                                 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
1279                         } else
1280                                 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
1281                 }
1282                 *us = externip.sin_addr;
1283                 if (option_debug) {
1284                         char iabuf[INET_ADDRSTRLEN];
1285                         ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
1286                 
1287                         ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
1288                 }
1289         } else if (bindaddr.sin_addr.s_addr)
1290                 *us = bindaddr.sin_addr;
1291         else
1292                 return ast_ouraddrfor(them, us);
1293         return 0;
1294 }
1295
1296 /*! \brief Append to SIP dialog history 
1297         \return Always returns 0 */
1298 #define append_history(p, event, fmt , args... )        append_history_full(p, "%-15s " fmt, event, ## args)
1299
1300 static int append_history_full(struct sip_pvt *p, const char *fmt, ...)
1301         __attribute__ ((format (printf, 2, 3)));
1302
1303 /*! \brief Append to SIP dialog history with arg list  */
1304 static void append_history_va(struct sip_pvt *p, const char *fmt, va_list ap)
1305 {
1306         char buf[80], *c = buf; /* max history length */
1307         struct sip_history *hist;
1308         int l;
1309
1310         vsnprintf(buf, sizeof(buf), fmt, ap);
1311         strsep(&c, "\r\n"); /* Trim up everything after \r or \n */
1312         l = strlen(buf) + 1;
1313         if (!(hist = ast_calloc(1, sizeof(*hist) + l)))
1314                 return;
1315         if (!p->history && !(p->history = ast_calloc(1, sizeof(*p->history)))) {
1316                 free(hist);
1317                 return;
1318         }
1319         memcpy(hist->event, buf, l);
1320         AST_LIST_INSERT_TAIL(p->history, hist, list);
1321 }
1322
1323 /*! \brief Append to SIP dialog history with arg list  */
1324 static int append_history_full(struct sip_pvt *p, const char *fmt, ...)
1325 {
1326         va_list ap;
1327
1328         if (!recordhistory || !p)
1329                 return 0;
1330         va_start(ap, fmt);
1331         append_history_va(p, fmt, ap);
1332         va_end(ap);
1333
1334         return 0;
1335 }
1336
1337 /*! \brief Retransmit SIP message if no answer */
1338 static int retrans_pkt(void *data)
1339 {
1340         struct sip_pkt *pkt=data, *prev, *cur = NULL;
1341         char iabuf[INET_ADDRSTRLEN];
1342         int reschedule = DEFAULT_RETRANS;
1343
1344         /* Lock channel */
1345         ast_mutex_lock(&pkt->owner->lock);
1346
1347         if (pkt->retrans < MAX_RETRANS) {
1348                 pkt->retrans++;
1349                 if (!pkt->timer_t1) {   /* Re-schedule using timer_a and timer_t1 */
1350                         if (sipdebug && option_debug > 3)
1351                                 ast_log(LOG_DEBUG, "SIP TIMER: Not rescheduling id #%d:%s (Method %d) (No timer T1)\n", pkt->retransid, sip_methods[pkt->method].text, pkt->method);
1352                 } else {
1353                         int siptimer_a;
1354
1355                         if (sipdebug && option_debug > 3)
1356                                 ast_log(LOG_DEBUG, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n", pkt->retransid, pkt->retrans, sip_methods[pkt->method].text, pkt->method);
1357                         if (!pkt->timer_a)
1358                                 pkt->timer_a = 2 ;
1359                         else
1360                                 pkt->timer_a = 2 * pkt->timer_a;
1361  
1362                         /* For non-invites, a maximum of 4 secs */
1363                         siptimer_a = pkt->timer_t1 * pkt->timer_a;      /* Double each time */
1364                         if (pkt->method != SIP_INVITE && siptimer_a > 4000)
1365                                 siptimer_a = 4000;
1366                 
1367                         /* Reschedule re-transmit */
1368                         reschedule = siptimer_a;
1369                         if (option_debug > 3)
1370                                 ast_log(LOG_DEBUG, "** 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);
1371                 } 
1372
1373                 if (pkt->owner && sip_debug_test_pvt(pkt->owner)) {
1374                         if (ast_test_flag(&pkt->owner->flags[0], SIP_NAT_ROUTE))
1375                                 ast_verbose("Retransmitting #%d (NAT) to %s:%d:\n%s\n---\n", pkt->retrans, ast_inet_ntoa(iabuf, sizeof(iabuf), pkt->owner->recv.sin_addr), ntohs(pkt->owner->recv.sin_port), pkt->data);
1376                         else
1377                                 ast_verbose("Retransmitting #%d (no NAT) to %s:%d:\n%s\n---\n", pkt->retrans, ast_inet_ntoa(iabuf, sizeof(iabuf), pkt->owner->sa.sin_addr), ntohs(pkt->owner->sa.sin_port), pkt->data);
1378                 }
1379
1380                 append_history(pkt->owner, "ReTx", "%d %s", reschedule, pkt->data);
1381                 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
1382                 ast_mutex_unlock(&pkt->owner->lock);
1383                 return  reschedule;
1384         } 
1385         /* Too many retries */
1386         if (pkt->owner && pkt->method != SIP_OPTIONS) {
1387                 if (ast_test_flag(pkt, FLAG_FATAL) || sipdebug) /* Tell us if it's critical or if we're debugging */
1388                         ast_log(LOG_WARNING, "Maximum retries exceeded on transmission %s for seqno %d (%s %s)\n", pkt->owner->callid, pkt->seqno, (ast_test_flag(pkt, FLAG_FATAL)) ? "Critical" : "Non-critical", (ast_test_flag(pkt, FLAG_RESPONSE)) ? "Response" : "Request");
1389         } else {
1390                 if ((pkt->method == SIP_OPTIONS) && sipdebug)
1391                         ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s) \n", pkt->owner->callid);
1392         }
1393         append_history(pkt->owner, "MaxRetries", "%s", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
1394                 
1395         pkt->retransid = -1;
1396
1397         if (ast_test_flag(pkt, FLAG_FATAL)) {
1398                 while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
1399                         ast_mutex_unlock(&pkt->owner->lock);
1400                         usleep(1);
1401                         ast_mutex_lock(&pkt->owner->lock);
1402                 }
1403                 if (pkt->owner->owner) {
1404                         ast_set_flag(&pkt->owner->flags[0], SIP_ALREADYGONE);
1405                         ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet.\n", pkt->owner->callid);
1406                         ast_queue_hangup(pkt->owner->owner);
1407                         ast_mutex_unlock(&pkt->owner->owner->lock);
1408                 } else {
1409                         /* If no channel owner, destroy now */
1410                         ast_set_flag(&pkt->owner->flags[0], SIP_NEEDDESTROY);   
1411                 }
1412         }
1413         /* In any case, go ahead and remove the packet */
1414         for (prev = NULL, cur = pkt->owner->packets; cur; prev = cur, cur = cur->next) {
1415                 if (cur == pkt)
1416                         break;
1417         }
1418         if (cur) {
1419                 if (prev)
1420                         prev->next = cur->next;
1421                 else
1422                         pkt->owner->packets = cur->next;
1423                 ast_mutex_unlock(&pkt->owner->lock);
1424                 free(cur);
1425                 pkt = NULL;
1426         } else
1427                 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
1428         if (pkt)
1429                 ast_mutex_unlock(&pkt->owner->lock);
1430         return 0;
1431 }
1432
1433 /*! \brief Transmit packet with retransmits 
1434         \return 0 on success, -1 on failure to allocate packet 
1435 */
1436 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod)
1437 {
1438         struct sip_pkt *pkt;
1439         int siptimer_a = DEFAULT_RETRANS;
1440
1441         if (!(pkt = ast_calloc(1, sizeof(*pkt) + len + 1)))
1442                 return -1;
1443         memcpy(pkt->data, data, len);
1444         pkt->method = sipmethod;
1445         pkt->packetlen = len;
1446         pkt->next = p->packets;
1447         pkt->owner = p;
1448         pkt->seqno = seqno;
1449         pkt->flags = resp;
1450         pkt->data[len] = '\0';
1451         pkt->timer_t1 = p->timer_t1;    /* Set SIP timer T1 */
1452         if (fatal)
1453                 ast_set_flag(pkt, FLAG_FATAL);
1454         if (pkt->timer_t1)
1455                 siptimer_a = pkt->timer_t1 * 2;
1456
1457         /* Schedule retransmission */
1458         pkt->retransid = ast_sched_add_variable(sched, siptimer_a, retrans_pkt, pkt, 1);
1459         if (option_debug > 3 && sipdebug)
1460                 ast_log(LOG_DEBUG, "*** SIP TIMER: Initalizing retransmit timer on packet: Id  #%d\n", pkt->retransid);
1461         pkt->next = p->packets;
1462         p->packets = pkt;
1463
1464         __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);      /* Send packet */
1465         if (sipmethod == SIP_INVITE) {
1466                 /* Note this is a pending invite */
1467                 p->pendinginvite = seqno;
1468         }
1469         return 0;
1470 }
1471
1472 /*! \brief Kill a SIP dialog (called by scheduler) */
1473 static int __sip_autodestruct(void *data)
1474 {
1475         struct sip_pvt *p = data;
1476
1477         /* If this is a subscription, tell the phone that we got a timeout */
1478         if (p->subscribed) {
1479                 p->subscribed = TIMEOUT;
1480                 transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1); /* Send last notification */
1481                 p->subscribed = NONE;
1482                 append_history(p, "Subscribestatus", "timeout");
1483                 if (option_debug > 2)
1484                         ast_log(LOG_DEBUG, "Re-scheduled destruction of SIP subsription %s\n", p->callid ? p->callid : "<unknown>");
1485                 return 10000;   /* Reschedule this destruction so that we know that it's gone */
1486         }
1487
1488         /* Reset schedule ID */
1489         p->autokillid = -1;
1490
1491         if (option_debug)
1492                 ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
1493         append_history(p, "AutoDestroy", "");
1494         if (p->owner) {
1495                 ast_log(LOG_WARNING, "Autodestruct on dialog '%s' with owner in place (Method: %s)\n", p->callid, sip_methods[p->method].text);
1496                 ast_queue_hangup(p->owner);
1497         } else {
1498                 sip_destroy(p);
1499         }
1500         return 0;
1501 }
1502
1503 /*! \brief Schedule destruction of SIP call */
1504 static int sip_scheddestroy(struct sip_pvt *p, int ms)
1505 {
1506         if (sip_debug_test_pvt(p))
1507                 ast_verbose("Scheduling destruction of SIP dialog '%s' in %d ms (Method: %s)\n", p->callid, ms, sip_methods[p->method].text);
1508         if (recordhistory)
1509                 append_history(p, "SchedDestroy", "%d ms", ms);
1510
1511         if (p->autokillid > -1)
1512                 ast_sched_del(sched, p->autokillid);
1513         p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
1514         return 0;
1515 }
1516
1517 /*! \brief Cancel destruction of SIP dialog */
1518 static int sip_cancel_destroy(struct sip_pvt *p)
1519 {
1520         if (p->autokillid > -1) {
1521                 ast_sched_del(sched, p->autokillid);
1522                 append_history(p, "CancelDestroy", "");
1523                 p->autokillid = -1;
1524         }
1525         return 0;
1526 }
1527
1528 /*! \brief Acknowledges receipt of a packet and stops retransmission */
1529 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod, int reset)
1530 {
1531         struct sip_pkt *cur, *prev = NULL;
1532         int res = -1;
1533
1534         /* Just in case... */
1535         char *msg;
1536
1537         msg = sip_methods[sipmethod].text;
1538
1539         ast_mutex_lock(&p->lock);
1540         for (cur = p->packets; cur; prev = cur, cur = cur->next) {
1541                 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
1542                         ((ast_test_flag(cur, FLAG_RESPONSE)) || 
1543                          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
1544                         if (!resp && (seqno == p->pendinginvite)) {
1545                                 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
1546                                 p->pendinginvite = 0;
1547                         }
1548                         /* this is our baby */
1549                         if (prev)
1550                                 prev->next = cur->next;
1551                         else
1552                                 p->packets = cur->next;
1553                         if (cur->retransid > -1) {
1554                                 if (sipdebug && option_debug > 3)
1555                                         ast_log(LOG_DEBUG, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
1556                                 ast_sched_del(sched, cur->retransid);
1557                         }
1558                         if (!reset)
1559                                 free(cur);
1560                         res = 0;
1561                         break;
1562                 }
1563         }
1564         ast_mutex_unlock(&p->lock);
1565         if (option_debug)
1566                 ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: Match %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
1567         return res;
1568 }
1569
1570 /*! \brief Pretend to ack all packets */
1571 static int __sip_pretend_ack(struct sip_pvt *p)
1572 {
1573         struct sip_pkt *cur = NULL;
1574
1575         while (p->packets) {
1576                 if (cur == p->packets) {
1577                         ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
1578                         return -1;
1579                 }
1580                 cur = p->packets;
1581                 if (cur->method)
1582                         __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), cur->method, FALSE);
1583                 else {  /* Unknown packet type */
1584                         char *c;
1585                         char method[128];
1586
1587                         ast_copy_string(method, p->packets->data, sizeof(method));
1588                         c = ast_skip_blanks(method); /* XXX what ? */
1589                         *c = '\0';
1590                         __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), find_sip_method(method), FALSE);
1591                 }
1592         }
1593         return 0;
1594 }
1595
1596 /*! \brief Acks receipt of packet, keep it around (used for provisional responses) */
1597 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
1598 {
1599         struct sip_pkt *cur;
1600         int res = -1;
1601
1602         for (cur = p->packets; cur; cur = cur->next) {
1603                 if (cur->seqno == seqno && ast_test_flag(cur, FLAG_RESPONSE) == resp &&
1604                         (ast_test_flag(cur, FLAG_RESPONSE) || method_match(sipmethod, cur->data))) {
1605                         /* this is our baby */
1606                         if (cur->retransid > -1) {
1607                                 if (option_debug > 3 && sipdebug)
1608                                         ast_log(LOG_DEBUG, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, sip_methods[sipmethod].text);
1609                                 ast_sched_del(sched, cur->retransid);
1610                         }
1611                         cur->retransid = -1;
1612                         res = 0;
1613                         break;
1614                 }
1615         }
1616         if (option_debug)
1617                 ast_log(LOG_DEBUG, "(Provisional) Stopping retransmission (but retaining packet) on '%s' %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
1618         return res;
1619 }
1620
1621
1622 /*! \brief Copy SIP request, parse it */
1623 static void parse_copy(struct sip_request *dst, struct sip_request *src)
1624 {
1625         memset(dst, 0, sizeof(*dst));
1626         memcpy(dst->data, src->data, sizeof(dst->data));
1627         dst->len = src->len;
1628         parse_request(dst);
1629 }
1630
1631 /*! \brief Transmit response on SIP request*/
1632 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
1633 {
1634         int res;
1635
1636         if (sip_debug_test_pvt(p)) {
1637                 char iabuf[INET_ADDRSTRLEN];
1638                 if (ast_test_flag(&p->flags[0], SIP_NAT_ROUTE))
1639                         ast_verbose("%sTransmitting (NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->recv.sin_addr), ntohs(p->recv.sin_port), req->data);
1640                 else
1641                         ast_verbose("%sTransmitting (no NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), ntohs(p->sa.sin_port), req->data);
1642         }
1643         if (recordhistory) {
1644                 struct sip_request tmp;
1645                 parse_copy(&tmp, req);
1646                 append_history(p, reliable ? "TxRespRel" : "TxResp", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"), 
1647                         tmp.method == SIP_RESPONSE ? tmp.rlPart2 : sip_methods[tmp.method].text);
1648         }
1649         res = (reliable) ?
1650                 __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable == XMIT_CRITICAL), req->method) :
1651                 __sip_xmit(p, req->data, req->len);
1652         if (res > 0)
1653                 return 0;
1654         return res;
1655 }
1656
1657 /*! \brief Send SIP Request to the other part of the dialogue */
1658 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
1659 {
1660         int res;
1661
1662         if (sip_debug_test_pvt(p)) {
1663                 char iabuf[INET_ADDRSTRLEN];
1664                 if (ast_test_flag(&p->flags[0], SIP_NAT_ROUTE))
1665                         ast_verbose("%sTransmitting (NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->recv.sin_addr), ntohs(p->recv.sin_port), req->data);
1666                 else
1667                         ast_verbose("%sTransmitting (no NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), ntohs(p->sa.sin_port), req->data);
1668         }
1669         if (recordhistory) {
1670                 struct sip_request tmp;
1671                 parse_copy(&tmp, req);
1672                 append_history(p, reliable ? "TxReqRel" : "TxReq", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"), sip_methods[tmp.method].text);
1673         }
1674         res = (reliable) ?
1675                 __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1), req->method) :
1676                 __sip_xmit(p, req->data, req->len);
1677         return res;
1678 }
1679
1680 /*! \brief Pick out text in brackets from character string
1681         \return pointer to terminated stripped string
1682         \param tmp input string that will be modified */
1683 static char *get_in_brackets(char *tmp)
1684 {
1685         char *parse;
1686         char *first_quote;
1687         char *first_bracket;
1688         char *second_bracket;
1689         char last_char;
1690
1691         parse = tmp;
1692         for (;;) {
1693                 first_quote = strchr(parse, '"');
1694                 first_bracket = strchr(parse, '<');
1695                 if (first_quote && first_bracket && (first_quote < first_bracket)) {
1696                         last_char = '\0';
1697                         for (parse = first_quote + 1; *parse; parse++) {
1698                                 if ((*parse == '"') && (last_char != '\\'))
1699                                         break;
1700                                 last_char = *parse;
1701                         }
1702                         if (!*parse) {
1703                                 ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
1704                                 return tmp;
1705                         }
1706                         parse++;
1707                         continue;
1708                 }
1709                 if (first_bracket) {
1710                         second_bracket = strchr(first_bracket + 1, '>');
1711                         if (second_bracket) {
1712                                 *second_bracket = '\0';
1713                                 return first_bracket + 1;
1714                         } else {
1715                                 ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
1716                                 return tmp;
1717                         }
1718                 }
1719                 return tmp;
1720         }
1721 }
1722
1723 /*! \brief Send SIP MESSAGE text within a call
1724         Called from PBX core sendtext() application */
1725 static int sip_sendtext(struct ast_channel *ast, const char *text)
1726 {
1727         struct sip_pvt *p = ast->tech_pvt;
1728         int debug = sip_debug_test_pvt(p);
1729
1730         if (debug)
1731                 ast_verbose("Sending text %s on %s\n", text, ast->name);
1732         if (!p)
1733                 return -1;
1734         if (ast_strlen_zero(text))
1735                 return 0;
1736         if (debug)
1737                 ast_verbose("Really sending text %s on %s\n", text, ast->name);
1738         transmit_message_with_text(p, text);
1739         return 0;       
1740 }
1741
1742 /*! \brief Update peer object in realtime storage */
1743 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expirey)
1744 {
1745         char port[10];
1746         char ipaddr[20];
1747         char regseconds[20];
1748         time_t nowtime;
1749         const char *fc = fullcontact ? "fullcontact" : NULL;
1750         
1751         time(&nowtime);
1752         nowtime += expirey;
1753         snprintf(regseconds, sizeof(regseconds), "%d", (int)nowtime);   /* Expiration time */
1754         ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
1755         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
1756         
1757         ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr,
1758                 "port", port, "regseconds", regseconds,
1759                 "username", username, fc, fullcontact, NULL); /* note fc _can_ be NULL */
1760 }
1761
1762 /*! \brief Automatically add peer extension to dial plan */
1763 static void register_peer_exten(struct sip_peer *peer, int onoff)
1764 {
1765         char multi[256];
1766         char *stringp, *ext;
1767         if (!ast_strlen_zero(global_regcontext)) {
1768
1769                 ast_copy_string(multi, S_OR(peer->regexten, peer->name), sizeof(multi));
1770                 stringp = multi;
1771                 while((ext = strsep(&stringp, "&"))) {
1772                         if (onoff)
1773                                 ast_add_extension(global_regcontext, 1, ext, 1, NULL, NULL, "Noop",
1774                                                   ast_strdup(peer->name), free, "SIP");
1775                         else
1776                                 ast_context_remove_extension(global_regcontext, ext, 1, NULL);
1777                 }
1778         }
1779 }
1780
1781 /*! \brief Destroy peer object from memory */
1782 static void sip_destroy_peer(struct sip_peer *peer)
1783 {
1784         if (option_debug > 2)
1785                 ast_log(LOG_DEBUG, "Destroying SIP peer %s\n", peer->name);
1786
1787         /* Delete it, it needs to disappear */
1788         if (peer->call)
1789                 sip_destroy(peer->call);
1790
1791         if (peer->mwipvt) {     /* We have an active subscription, delete it */
1792                 sip_destroy(peer->mwipvt);
1793         }
1794
1795         if (peer->chanvars) {
1796                 ast_variables_destroy(peer->chanvars);
1797                 peer->chanvars = NULL;
1798         }
1799         if (peer->expire > -1)
1800                 ast_sched_del(sched, peer->expire);
1801         if (peer->pokeexpire > -1)
1802                 ast_sched_del(sched, peer->pokeexpire);
1803         register_peer_exten(peer, FALSE);
1804         ast_free_ha(peer->ha);
1805         if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT))
1806                 apeerobjs--;
1807         else if (ast_test_flag(&peer->flags[0], SIP_REALTIME))
1808                 rpeerobjs--;
1809         else
1810                 speerobjs--;
1811         clear_realm_authentication(peer->auth);
1812         peer->auth = NULL;
1813         if (peer->dnsmgr)
1814                 ast_dnsmgr_release(peer->dnsmgr);
1815         free(peer);
1816 }
1817
1818 /*! \brief Update peer data in database (if used) */
1819 static void update_peer(struct sip_peer *p, int expiry)
1820 {
1821         int rtcachefriends = ast_test_flag(&p->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
1822         if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTUPDATE) &&
1823             (ast_test_flag(&p->flags[0], SIP_REALTIME) || rtcachefriends)) {
1824                 realtime_update_peer(p->name, &p->addr, p->username, rtcachefriends ? p->fullcontact : NULL, expiry);
1825         }
1826 }
1827
1828
1829 /*! \brief  realtime_peer: Get peer from realtime storage
1830  * Checks the "sippeers" realtime family from extconfig.conf 
1831  * \todo Consider adding check of port address when matching here to follow the same
1832  *      algorithm as for static peers. Will we break anything by adding that?
1833 */
1834 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1835 {
1836         struct sip_peer *peer = NULL;
1837         struct ast_variable *var;
1838         struct ast_variable *tmp;
1839         char *newpeername = (char *) peername;
1840         char iabuf[80];
1841
1842         /* First check on peer name */
1843         if (newpeername) 
1844                 var = ast_load_realtime("sippeers", "name", peername, NULL);
1845         else if (sin) { /* Then check on IP address for dynamic peers */
1846                 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
1847                 var = ast_load_realtime("sippeers", "host", iabuf, NULL);       /* First check for fixed IP hosts */
1848                 if (!var)
1849                         var = ast_load_realtime("sippeers", "ipaddr", iabuf, NULL);     /* Then check for registred hosts */
1850         
1851         } else
1852                 return NULL;
1853
1854         if (!var)
1855                 return NULL;
1856
1857         for (tmp = var; tmp; tmp = tmp->next) {
1858                 /* If this is type=user, then skip this object. */
1859                 if (!strcasecmp(tmp->name, "type") &&
1860                     !strcasecmp(tmp->value, "user")) {
1861                         ast_variables_destroy(var);
1862                         return NULL;
1863                 } else if (!newpeername && !strcasecmp(tmp->name, "name")) {
1864                         newpeername = tmp->value;
1865                 }
1866         }
1867         
1868         if (!newpeername) {     /* Did not find peer in realtime */
1869                 ast_log(LOG_WARNING, "Cannot Determine peer name ip=%s\n", iabuf);
1870                 ast_variables_destroy(var);
1871                 return NULL;
1872         }
1873
1874         /* Peer found in realtime, now build it in memory */
1875         peer = build_peer(newpeername, var, !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS));
1876         if (!peer) {
1877                 ast_variables_destroy(var);
1878                 return NULL;
1879         }
1880
1881         if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
1882                 /* Cache peer */
1883                 ast_copy_flags(&peer->flags[1],&global_flags[1], SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
1884                 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTAUTOCLEAR)) {
1885                         if (peer->expire > -1) {
1886                                 ast_sched_del(sched, peer->expire);
1887                         }
1888                         peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, (void *)peer);
1889                 }
1890                 ASTOBJ_CONTAINER_LINK(&peerl,peer);
1891         } else {
1892                 ast_set_flag(&peer->flags[0], SIP_REALTIME);
1893         }
1894         ast_variables_destroy(var);
1895
1896         return peer;
1897 }
1898
1899 /*! \brief Support routine for find_peer */
1900 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
1901 {
1902         /* We know name is the first field, so we can cast */
1903         struct sip_peer *p = (struct sip_peer *) name;
1904         return  !(!inaddrcmp(&p->addr, sin) || 
1905                                         (ast_test_flag(&p->flags[0], SIP_INSECURE_PORT) &&
1906                                         (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
1907 }
1908
1909 /*! \brief Locate peer by name or ip address 
1910  *      This is used on incoming SIP message to find matching peer on ip
1911         or outgoing message to find matching peer on name */
1912 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
1913 {
1914         struct sip_peer *p = NULL;
1915
1916         if (peer)
1917                 p = ASTOBJ_CONTAINER_FIND(&peerl, peer);
1918         else
1919                 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl, sin, name, sip_addr_hashfunc, 1, sip_addrcmp);
1920
1921         if (!p && realtime) {
1922                 p = realtime_peer(peer, sin);
1923         }
1924         return p;
1925 }
1926
1927 /*! \brief Remove user object from in-memory storage */
1928 static void sip_destroy_user(struct sip_user *user)
1929 {
1930         if (option_debug > 2)
1931                 ast_log(LOG_DEBUG, "Destroying user object from memory: %s\n", user->name);
1932         ast_free_ha(user->ha);
1933         if (user->chanvars) {
1934                 ast_variables_destroy(user->chanvars);
1935                 user->chanvars = NULL;
1936         }
1937         if (ast_test_flag(&user->flags[0], SIP_REALTIME))
1938                 ruserobjs--;
1939         else
1940                 suserobjs--;
1941         free(user);
1942 }
1943
1944 /*! \brief Load user from realtime storage
1945  * Loads user from "sipusers" category in realtime (extconfig.conf)
1946  * Users are matched on From: user name (the domain in skipped) */
1947 static struct sip_user *realtime_user(const char *username)
1948 {
1949         struct ast_variable *var;
1950         struct ast_variable *tmp;
1951         struct sip_user *user = NULL;
1952
1953         var = ast_load_realtime("sipusers", "name", username, NULL);
1954
1955         if (!var)
1956                 return NULL;
1957
1958         for (tmp = var; tmp; tmp = tmp->next) {
1959                 if (!strcasecmp(tmp->name, "type") &&
1960                         !strcasecmp(tmp->value, "peer")) {
1961                         ast_variables_destroy(var);
1962                         return NULL;
1963                 }
1964         }
1965
1966         user = build_user(username, var, !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS));
1967         
1968         if (!user) {    /* No user found */
1969                 ast_variables_destroy(var);
1970                 return NULL;
1971         }
1972
1973         if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
1974                 ast_set_flag(&user->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
1975                 suserobjs++;
1976                 ASTOBJ_CONTAINER_LINK(&userl,user);
1977         } else {
1978                 /* Move counter from s to r... */
1979                 suserobjs--;
1980                 ruserobjs++;
1981                 ast_set_flag(&user->flags[0], SIP_REALTIME);
1982         }
1983         ast_variables_destroy(var);
1984         return user;
1985 }
1986
1987 /*! \brief Locate user by name 
1988  * Locates user by name (From: sip uri user name part) first
1989  * from in-memory list (static configuration) then from 
1990  * realtime storage (defined in extconfig.conf) */
1991 static struct sip_user *find_user(const char *name, int realtime)
1992 {
1993         struct sip_user *u = ASTOBJ_CONTAINER_FIND(&userl, name);
1994         if (!u && realtime)
1995                 u = realtime_user(name);
1996         return u;
1997 }
1998
1999 /*! \brief Create address structure from peer reference */
2000 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer)
2001 {
2002         int natflags;
2003
2004         if ((peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr) &&
2005             (!peer->maxms || ((peer->lastms >= 0)  && (peer->lastms <= peer->maxms)))) {
2006                 r->sa = (peer->addr.sin_addr.s_addr) ? peer->addr : peer->defaddr;
2007                 r->recv = r->sa;
2008         } else {
2009                 return -1;
2010         }
2011
2012         ast_copy_flags(&r->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
2013         ast_copy_flags(&r->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
2014         r->capability = peer->capability;
2015         if (!ast_test_flag(&r->flags[1], SIP_PAGE2_VIDEOSUPPORT) && r->vrtp) {
2016                 ast_rtp_destroy(r->vrtp);
2017                 r->vrtp = NULL;
2018         }
2019         r->prefs = peer->prefs;
2020         natflags = ast_test_flag(&r->flags[0], SIP_NAT) & SIP_NAT_ROUTE;
2021         if (r->rtp) {
2022                 if (option_debug)
2023                         ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", natflags);
2024                 ast_rtp_setnat(r->rtp, natflags);
2025         }
2026         if (r->vrtp) {
2027                 if (option_debug)
2028                         ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", natflags);
2029                 ast_rtp_setnat(r->vrtp, natflags);
2030         }
2031         ast_string_field_set(r, peername, peer->username);
2032         ast_string_field_set(r, authname, peer->username);
2033         ast_string_field_set(r, username, peer->username);
2034         ast_string_field_set(r, peersecret, peer->secret);
2035         ast_string_field_set(r, peermd5secret, peer->md5secret);
2036         ast_string_field_set(r, tohost, peer->tohost);
2037         ast_string_field_set(r, fullcontact, peer->fullcontact);
2038         if (!r->initreq.headers && !ast_strlen_zero(peer->fromdomain)) {
2039                 char *tmpcall;
2040                 char *c;
2041                 tmpcall = ast_strdupa(r->callid);
2042                 if (tmpcall) {
2043                         c = strchr(tmpcall, '@');
2044                         if (c) {
2045                                 *c = '\0';
2046                                 ast_string_field_build(r, callid, "%s@%s", tmpcall, peer->fromdomain);
2047                         }
2048                 }
2049         }
2050         if (ast_strlen_zero(r->tohost)) {
2051                 char iabuf[INET_ADDRSTRLEN];
2052
2053                 ast_inet_ntoa(iabuf, sizeof(iabuf),  r->sa.sin_addr);
2054                 ast_string_field_set(r, tohost, iabuf);
2055         }
2056         if (!ast_strlen_zero(peer->fromdomain))
2057                 ast_string_field_set(r, fromdomain, peer->fromdomain);
2058         if (!ast_strlen_zero(peer->fromuser))
2059                 ast_string_field_set(r, fromuser, peer->fromuser);
2060         r->maxtime = peer->maxms;
2061         r->callgroup = peer->callgroup;
2062         r->pickupgroup = peer->pickupgroup;
2063         r->allowtransfer = peer->allowtransfer;
2064         /* Set timer T1 to RTT for this peer (if known by qualify=) */
2065         /* Minimum is settable or default to 100 ms */
2066         if (peer->maxms && peer->lastms)
2067                 r->timer_t1 = peer->lastms < global_t1min ? global_t1min : peer->lastms;
2068         if ((ast_test_flag(&r->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
2069             (ast_test_flag(&r->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
2070                 r->noncodeccapability |= AST_RTP_DTMF;
2071         else
2072                 r->noncodeccapability &= ~AST_RTP_DTMF;
2073         ast_string_field_set(r, context, peer->context);
2074         r->rtptimeout = peer->rtptimeout;
2075         r->rtpholdtimeout = peer->rtpholdtimeout;
2076         r->rtpkeepalive = peer->rtpkeepalive;
2077         if (peer->call_limit)
2078                 ast_set_flag(&r->flags[0], SIP_CALL_LIMIT);
2079         r->maxcallbitrate = peer->maxcallbitrate;
2080         
2081         return 0;
2082 }
2083
2084 /*! \brief create address structure from peer name
2085  *      Or, if peer not found, find it in the global DNS 
2086  *      returns TRUE (-1) on failure, FALSE on success */
2087 static int create_addr(struct sip_pvt *dialog, const char *opeer)
2088 {
2089         struct hostent *hp;
2090         struct ast_hostent ahp;
2091         struct sip_peer *p;
2092         int found=0;
2093         char *port;
2094         int portno;
2095         char host[MAXHOSTNAMELEN], *hostn;
2096         char peer[256];
2097
2098         ast_copy_string(peer, opeer, sizeof(peer));
2099         port = strchr(peer, ':');
2100         if (port)
2101                 *port++ = '\0';
2102         dialog->sa.sin_family = AF_INET;
2103         dialog->timer_t1 = 500; /* Default SIP retransmission timer T1 (RFC 3261) */
2104         p = find_peer(peer, NULL, 1);
2105
2106         if (p) {
2107                 found++;
2108                 if (create_addr_from_peer(dialog, p))
2109                         ASTOBJ_UNREF(p, sip_destroy_peer);
2110         }
2111         if (!p) {
2112                 if (found)
2113                         return -1;
2114
2115                 hostn = peer;
2116                 portno = port ? atoi(port) : DEFAULT_SIP_PORT;
2117                 if (srvlookup) {
2118                         char service[MAXHOSTNAMELEN];
2119                         int tportno;
2120                         int ret;
2121                         snprintf(service, sizeof(service), "_sip._udp.%s", peer);
2122                         ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
2123                         if (ret > 0) {
2124                                 hostn = host;
2125                                 portno = tportno;
2126                         }
2127                 }
2128                 hp = ast_gethostbyname(hostn, &ahp);
2129                 if (hp) {
2130                         ast_string_field_set(dialog, tohost, peer);
2131                         memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr));
2132                         dialog->sa.sin_port = htons(portno);
2133                         dialog->recv = dialog->sa;
2134                         return 0;
2135                 } else {
2136                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
2137                         return -1;
2138                 }
2139         } else {
2140                 ASTOBJ_UNREF(p, sip_destroy_peer);
2141                 return 0;
2142         }
2143 }
2144
2145 /*! \brief Scheduled congestion on a call */
2146 static int auto_congest(void *nothing)
2147 {
2148         struct sip_pvt *p = nothing;
2149
2150         ast_mutex_lock(&p->lock);
2151         p->initid = -1;
2152         if (p->owner) {
2153                 /* XXX fails on possible deadlock */
2154                 if (!ast_mutex_trylock(&p->owner->lock)) {
2155                         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
2156                         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
2157                         ast_mutex_unlock(&p->owner->lock);
2158                 }
2159         }
2160         ast_mutex_unlock(&p->lock);
2161         return 0;
2162 }
2163
2164
2165
2166
2167 /*! \brief Initiate SIP call from PBX 
2168  *      used from the dial() application      */
2169 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
2170 {
2171         int res;
2172         struct sip_pvt *p;
2173         struct varshead *headp;
2174         struct ast_var_t *current;
2175         
2176         p = ast->tech_pvt;
2177         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
2178                 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
2179                 return -1;
2180         }
2181
2182         /* Check whether there is vxml_url, distinctive ring variables */
2183         headp=&ast->varshead;
2184         AST_LIST_TRAVERSE(headp,current,entries) {
2185                 /* Check whether there is a VXML_URL variable */
2186                 if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
2187                         p->options->vxml_url = ast_var_value(current);
2188                 } else if (!p->options->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
2189                         p->options->uri_options = ast_var_value(current);
2190                 } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
2191                         /* Check whether there is a ALERT_INFO variable */
2192                         p->options->distinctive_ring = ast_var_value(current);
2193                 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
2194                         /* Check whether there is a variable with a name starting with SIPADDHEADER */
2195                         p->options->addsipheaders = 1;
2196                 }
2197         }
2198         
2199         res = 0;
2200         ast_set_flag(&p->flags[0], SIP_OUTGOING);
2201         if (option_debug)
2202                 ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
2203         res = update_call_counter(p, INC_CALL_LIMIT);
2204         if ( res != -1 ) {
2205                 p->callingpres = ast->cid.cid_pres;
2206                 p->jointcapability = p->capability;
2207                 transmit_invite(p, SIP_INVITE, 1, 2);
2208                 if (p->maxtime) {
2209                         /* Initialize auto-congest time */
2210                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
2211                 }
2212         }
2213         return res;
2214 }
2215
2216 /*! \brief Destroy registry object
2217         Objects created with the register= statement in static configuration */
2218 static void sip_registry_destroy(struct sip_registry *reg)
2219 {
2220         /* Really delete */
2221         if (option_debug > 2)
2222                 ast_log(LOG_DEBUG, "Destroying registry entry for %s@%s\n", reg->username, reg->hostname);
2223
2224         if (reg->call) {
2225                 /* Clear registry before destroying to ensure
2226                    we don't get reentered trying to grab the registry lock */
2227                 reg->call->registry = NULL;
2228                 if (option_debug > 2)
2229                         ast_log(LOG_DEBUG, "Destroying active SIP dialog for registry %s@%s\n", reg->username, reg->hostname);
2230                 sip_destroy(reg->call);
2231         }
2232         if (reg->expire > -1)
2233                 ast_sched_del(sched, reg->expire);
2234         if (reg->timeout > -1)
2235                 ast_sched_del(sched, reg->timeout);
2236         ast_string_field_free_all(reg);
2237         regobjs--;
2238         free(reg);
2239         
2240 }
2241
2242 /*! \brief Execute destrucion of SIP dialog structure, release memory */
2243 static void __sip_destroy(struct sip_pvt *p, int lockowner)
2244 {
2245         struct sip_pvt *cur, *prev = NULL;
2246         struct sip_pkt *cp;
2247
2248         if (sip_debug_test_pvt(p) || option_debug > 2)
2249                 ast_verbose("Really destroying SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);
2250
2251         /* Remove link from peer to subscription of MWI */
2252         if (p->relatedpeer && p->relatedpeer->mwipvt)
2253                 p->relatedpeer->mwipvt = NULL;
2254
2255         if (dumphistory)
2256                 sip_dump_history(p);
2257
2258         if (p->options)
2259                 free(p->options);
2260
2261         if (p->stateid > -1)
2262                 ast_extension_state_del(p->stateid, NULL);
2263         if (p->initid > -1)
2264                 ast_sched_del(sched, p->initid);
2265         if (p->autokillid > -1)
2266                 ast_sched_del(sched, p->autokillid);
2267
2268         if (p->rtp)
2269                 ast_rtp_destroy(p->rtp);
2270         if (p->vrtp)
2271                 ast_rtp_destroy(p->vrtp);
2272         if (p->route) {
2273                 free_old_route(p->route);
2274                 p->route = NULL;
2275         }
2276         if (p->registry) {
2277                 if (p->registry->call == p)
2278                         p->registry->call = NULL;
2279                 ASTOBJ_UNREF(p->registry, sip_registry_destroy);
2280         }
2281
2282         /* Unlink us from the owner if we have one */
2283         if (p->owner) {
2284                 if (lockowner)
2285                         ast_mutex_lock(&p->owner->lock);
2286                 if (option_debug)
2287                         ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
2288                 p->owner->tech_pvt = NULL;
2289                 if (lockowner)
2290                         ast_mutex_unlock(&p->owner->lock);
2291         }
2292         /* Clear history */
2293         if (p->history) {
2294                 struct sip_history *hist;
2295                 while( (hist = AST_LIST_REMOVE_HEAD(p->history, list)) )
2296                         free(hist);
2297                 free(p->history);
2298                 p->history = NULL;
2299         }
2300
2301         for (prev = NULL, cur = iflist; cur; prev = cur, cur = cur->next) {
2302                 if (cur == p) {
2303                         if (prev)
2304                                 prev->next = cur->next;
2305                         else
2306                                 iflist = cur->next;
2307                         break;
2308                 }
2309         }
2310         if (!cur) {
2311                 ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
2312                 return;
2313         } 
2314         if (p->initid > -1)
2315                 ast_sched_del(sched, p->initid);
2316
2317         /* remove all current packets in this dialog */
2318         while((cp = p->packets)) {
2319                 p->packets = p->packets->next;
2320                 if (cp->retransid > -1)
2321                         ast_sched_del(sched, cp->retransid);
2322                 free(cp);
2323         }
2324         if (p->chanvars) {
2325                 ast_variables_destroy(p->chanvars);
2326                 p->chanvars = NULL;
2327         }
2328         ast_mutex_destroy(&p->lock);
2329
2330         ast_string_field_free_all(p);
2331
2332         free(p);
2333 }
2334
2335 /*! \brief  update_call_counter: Handle call_limit for SIP users 
2336  * Setting a call-limit will cause calls above the limit not to be accepted.
2337  *
2338  * Remember that for a type=friend, there's one limit for the user and
2339  * another for the peer, not a combined call limit.
2340  * This will cause unexpected behaviour in subscriptions, since a "friend"
2341  * is *two* devices in Asterisk, not one.
2342  *
2343  * Thought: For realtime, we should propably update storage with inuse counter... 
2344  *
2345  * \return 0 if call is ok (no call limit, below treshold)
2346  *      -1 on rejection of call
2347  *              
2348  */
2349 static int update_call_counter(struct sip_pvt *fup, int event)
2350 {
2351         char name[256];
2352         int *inuse, *call_limit;
2353         int outgoing = ast_test_flag(&fup->flags[0], SIP_OUTGOING);
2354         struct sip_user *u = NULL;
2355         struct sip_peer *p = NULL;
2356
2357         if (option_debug > 2)
2358                 ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
2359         /* Test if we need to check call limits, in order to avoid 
2360            realtime lookups if we do not need it */
2361         if (!ast_test_flag(&fup->flags[0], SIP_CALL_LIMIT))
2362                 return 0;
2363
2364         ast_copy_string(name, fup->username, sizeof(name));
2365
2366         /* Check the list of users */
2367         if (!outgoing)  /* Only check users for incoming calls */
2368                 u = find_user(name, 1);
2369
2370         if (u) {
2371                 inuse = &u->inUse;
2372                 call_limit = &u->call_limit;
2373                 p = NULL;
2374         } else {
2375                 /* Try to find peer */
2376                 if (!p)
2377                         p = find_peer(fup->peername, NULL, 1);
2378                 if (p) {
2379                         inuse = &p->inUse;
2380                         call_limit = &p->call_limit;
2381                         ast_copy_string(name, fup->peername, sizeof(name));
2382                 } else {
2383                         if (option_debug > 1)
2384                                 ast_log(LOG_DEBUG, "%s is not a local user, no call limit\n", name);
2385                         return 0;
2386                 }
2387         }
2388         switch(event) {
2389                 /* incoming and outgoing affects the inUse counter */
2390                 case DEC_CALL_LIMIT:
2391                         if ( *inuse > 0 ) {
2392                                 if (ast_test_flag(&fup->flags[0], SIP_INC_COUNT))
2393                                         (*inuse)--;
2394                         } else {
2395                                 *inuse = 0;
2396                         }
2397                         if (option_debug > 1 || sipdebug) {
2398                                 ast_log(LOG_DEBUG, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
2399                         }
2400                         break;
2401                 case INC_CALL_LIMIT:
2402                         if (*call_limit > 0 ) {
2403                                 if (*inuse >= *call_limit) {
2404                                         ast_log(LOG_ERROR, "Call %s %s '%s' rejected due to usage limit of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
2405                                         if (u)
2406                                                 ASTOBJ_UNREF(u, sip_destroy_user);
2407                                         else
2408                                                 ASTOBJ_UNREF(p, sip_destroy_peer);
2409                                         return -1; 
2410                                 }
2411                         }
2412                         (*inuse)++;
2413                         ast_set_flag(&fup->flags[0], SIP_INC_COUNT);
2414                         if (option_debug > 1 || sipdebug) {
2415                                 ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
2416                         }
2417                         break;
2418                 default:
2419                         ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
2420         }
2421         if (u)
2422                 ASTOBJ_UNREF(u, sip_destroy_user);
2423         else
2424                 ASTOBJ_UNREF(p, sip_destroy_peer);
2425         return 0;
2426 }
2427
2428 /*! \brief Destroy SIP call structure */
2429 static void sip_destroy(struct sip_pvt *p)
2430 {
2431         ast_mutex_lock(&iflock);
2432         if (option_debug > 2)
2433                 ast_log(LOG_DEBUG, "Destroying SIP dialog %s\n", p->callid);
2434         __sip_destroy(p, 1);
2435         ast_mutex_unlock(&iflock);
2436 }
2437
2438 /*! \brief Convert SIP hangup causes to Asterisk hangup causes */
2439 static int hangup_sip2cause(int cause)
2440 {
2441         /* Possible values taken from causes.h */
2442
2443         switch(cause) {
2444                 case 401:       /* Unauthorized */
2445                         return AST_CAUSE_CALL_REJECTED;
2446                 case 403:       /* Not found */
2447                         return AST_CAUSE_CALL_REJECTED;
2448                 case 404:       /* Not found */
2449                         return AST_CAUSE_UNALLOCATED;
2450                 case 405:       /* Method not allowed */
2451                         return AST_CAUSE_INTERWORKING;
2452                 case 407:       /* Proxy authentication required */
2453                         return AST_CAUSE_CALL_REJECTED;
2454                 case 408:       /* No reaction */
2455                         return AST_CAUSE_NO_USER_RESPONSE;
2456                 case 409:       /* Conflict */
2457                         return AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
2458                 case 410:       /* Gone */
2459                         return AST_CAUSE_UNALLOCATED;
2460                 case 411:       /* Length required */
2461                         return AST_CAUSE_INTERWORKING;
2462                 case 413:       /* Request entity too large */
2463                         return AST_CAUSE_INTERWORKING;
2464                 case 414:       /* Request URI too large */
2465                         return AST_CAUSE_INTERWORKING;
2466                 case 415:       /* Unsupported media type */
2467                         return AST_CAUSE_INTERWORKING;
2468                 case 420:       /* Bad extension */
2469                         return AST_CAUSE_NO_ROUTE_DESTINATION;
2470                 case 480:       /* No answer */
2471                         return AST_CAUSE_FAILURE;
2472                 case 481:       /* No answer */
2473                         return AST_CAUSE_INTERWORKING;
2474                 case 482:       /* Loop detected */
2475                         return AST_CAUSE_INTERWORKING;
2476                 case 483:       /* Too many hops */
2477                         return AST_CAUSE_NO_ANSWER;
2478                 case 484:       /* Address incomplete */
2479                         return AST_CAUSE_INVALID_NUMBER_FORMAT;
2480                 case 485:       /* Ambigous */
2481                         return AST_CAUSE_UNALLOCATED;
2482                 case 486:       /* Busy everywhere */
2483                         return AST_CAUSE_BUSY;
2484                 case 487:       /* Request terminated */
2485                         return AST_CAUSE_INTERWORKING;
2486                 case 488:       /* No codecs approved */
2487                         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2488                 case 491:       /* Request pending */
2489                         return AST_CAUSE_INTERWORKING;
2490                 case 493:       /* Undecipherable */
2491                         return AST_CAUSE_INTERWORKING;
2492                 case 500:       /* Server internal failure */
2493                         return AST_CAUSE_FAILURE;
2494                 case 501:       /* Call rejected */
2495                         return AST_CAUSE_FACILITY_REJECTED;
2496                 case 502:       
2497                         return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2498                 case 503:       /* Service unavailable */
2499                         return AST_CAUSE_CONGESTION;
2500                 case 504:       /* Gateway timeout */
2501                         return AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE;
2502                 case 505:       /* SIP version not supported */
2503                         return AST_CAUSE_INTERWORKING;
2504                 case 600:       /* Busy everywhere */
2505                         return AST_CAUSE_USER_BUSY;
2506                 case 603:       /* Decline */
2507                         return AST_CAUSE_CALL_REJECTED;
2508                 case 604:       /* Does not exist anywhere */
2509                         return AST_CAUSE_UNALLOCATED;
2510                 case 606:       /* Not acceptable */
2511                         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2512                 default:
2513                         return AST_CAUSE_NORMAL;
2514         }
2515         /* Never reached */
2516         return 0;
2517 }
2518
2519 /*! \brief Convert Asterisk hangup causes to SIP codes 
2520 \verbatim
2521  Possible values from causes.h
2522         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
2523         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
2524
2525         In addition to these, a lot of PRI codes is defined in causes.h 
2526         ...should we take care of them too ?
2527         
2528         Quote RFC 3398
2529
2530    ISUP Cause value                        SIP response
2531    ----------------                        ------------
2532    1  unallocated number                   404 Not Found
2533    2  no route to network                  404 Not found
2534    3  no route to destination              404 Not found
2535    16 normal call clearing                 --- (*)
2536    17 user busy                            486 Busy here
2537    18 no user responding                   408 Request Timeout
2538    19 no answer from the user              480 Temporarily unavailable
2539    20 subscriber absent                    480 Temporarily unavailable
2540    21 call rejected                        403 Forbidden (+)
2541    22 number changed (w/o diagnostic)      410 Gone
2542    22 number changed (w/ diagnostic)       301 Moved Permanently
2543    23 redirection to new destination       410 Gone
2544    26 non-selected user clearing           404 Not Found (=)
2545    27 destination out of order             502 Bad Gateway
2546    28 address incomplete                   484 Address incomplete
2547    29 facility rejected                    501 Not implemented
2548    31 normal unspecified                   480 Temporarily unavailable
2549 \endverbatim
2550 */
2551 static const char *hangup_cause2sip(int cause)
2552 {
2553         switch (cause) {
2554                 case AST_CAUSE_UNALLOCATED:             /* 1 */
2555                 case AST_CAUSE_NO_ROUTE_DESTINATION:    /* 3 IAX2: Can't find extension in context */
2556                 case AST_CAUSE_NO_ROUTE_TRANSIT_NET:    /* 2 */
2557                         return "404 Not Found";
2558                 case AST_CAUSE_CONGESTION:              /* 34 */
2559                 case AST_CAUSE_SWITCH_CONGESTION:       /* 42 */
2560                         return "503 Service Unavailable";
2561                 case AST_CAUSE_NO_USER_RESPONSE:        /* 18 */
2562                         return "408 Request Timeout";
2563                 case AST_CAUSE_NO_ANSWER:               /* 19 */
2564                         return "480 Temporarily unavailable";
2565                 case AST_CAUSE_CALL_REJECTED:           /* 21 */
2566                         return "403 Forbidden";
2567                 case AST_CAUSE_NUMBER_CHANGED:          /* 22 */
2568                         return "410 Gone";
2569                 case AST_CAUSE_NORMAL_UNSPECIFIED:      /* 31 */
2570                         return "480 Temporarily unavailable";
2571                 case AST_CAUSE_INVALID_NUMBER_FORMAT:
2572                         return "484 Address incomplete";
2573                 case AST_CAUSE_USER_BUSY:
2574                         return "486 Busy here";
2575                 case AST_CAUSE_FAILURE:
2576                         return "500 Server internal failure";
2577                 case AST_CAUSE_FACILITY_REJECTED:       /* 29 */
2578                         return "501 Not Implemented";
2579                 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
2580                         return "503 Service Unavailable";
2581                 /* Used in chan_iax2 */
2582                 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
2583                         return "502 Bad Gateway";
2584                 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:       /* Can't find codec to connect to host */
2585                         return "488 Not Acceptable Here";
2586                         
2587                 case AST_CAUSE_NOTDEFINED:
2588                 default:
2589                         ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
2590                         return NULL;
2591         }
2592
2593         /* Never reached */
2594         return 0;
2595 }
2596
2597
2598 /*! \brief  sip_hangup: Hangup SIP call
2599  * Part of PBX interface, called from ast_hangup */
2600 static int sip_hangup(struct ast_channel *ast)
2601 {
2602         struct sip_pvt *p = ast->tech_pvt;
2603         int needcancel = FALSE;
2604         struct ast_flags locflags = {0};
2605
2606         if (!p) {
2607                 ast_log(LOG_DEBUG, "Asked to hangup channel that was not connected\n");
2608                 return 0;
2609         }
2610         if (option_debug && sipdebug)
2611                 ast_log(LOG_DEBUG, "Hangup call %s, SIP callid %s)\n", ast->name, p->callid);
2612
2613         ast_mutex_lock(&p->lock);
2614         if (option_debug && sipdebug)
2615                 ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter on hangup\n", p->username);
2616         update_call_counter(p, DEC_CALL_LIMIT);
2617         /* Determine how to disconnect */
2618         if (p->owner != ast) {
2619                 ast_log(LOG_WARNING, "Huh?  We aren't the owner? Can't hangup call.\n");
2620                 ast_mutex_unlock(&p->lock);
2621                 return 0;
2622         }
2623         /* If the call is not UP, we need to send CANCEL instead of BYE */
2624         if (ast->_state != AST_STATE_UP)
2625                 needcancel = TRUE;
2626
2627         /* Disconnect */
2628         p = ast->tech_pvt;
2629         if (p->vad)
2630                 ast_dsp_free(p->vad);
2631
2632         p->owner = NULL;
2633         ast->tech_pvt = NULL;
2634
2635         ast_mutex_lock(&usecnt_lock);
2636         usecnt--;
2637         ast_mutex_unlock(&usecnt_lock);
2638         ast_update_use_count();
2639
2640         ast_set_flag(&locflags, SIP_NEEDDESTROY);       
2641
2642         /* Start the process if it's not already started */
2643         if (!ast_test_flag(&p->flags[0], SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
2644                 if (needcancel) {       /* Outgoing call, not up */
2645                         if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
2646                                 /* stop retransmitting an INVITE that has not received a response */
2647                                 __sip_pretend_ack(p);
2648
2649                                 /* Send a new request: CANCEL */
2650                                 transmit_request_with_auth(p, SIP_CANCEL, p->ocseq, XMIT_RELIABLE, 0);
2651                                 /* Actually don't destroy us yet, wait for the 487 on our original 
2652                                    INVITE, but do set an autodestruct just in case we never get it. */
2653                                 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
2654
2655                                 sip_scheddestroy(p, 32000);
2656                                 if ( p->initid != -1 ) {
2657                                         /* channel still up - reverse dec of inUse counter
2658                                            only if the channel is not auto-congested */
2659                                         update_call_counter(p, INC_CALL_LIMIT);
2660                                 }
2661                         } else {        /* Incoming call, not up */
2662                                 const char *res;
2663                                 if (ast->hangupcause && (res = hangup_cause2sip(ast->hangupcause)))
2664                                         transmit_response_reliable(p, res, &p->initreq);
2665                                 else 
2666                                         transmit_response_reliable(p, "603 Declined", &p->initreq);
2667                         }
2668                 } else {        /* Call is in UP state, send BYE */
2669                         if (!p->pendinginvite) {
2670                                 /* Send a hangup */
2671                                 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
2672                         } else {
2673                                 /* Note we will need a BYE when this all settles out
2674                                    but we can't send one while we have "INVITE" outstanding. */
2675                                 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);     
2676                                 ast_clear_flag(&p->flags[0], SIP_NEEDREINVITE); 
2677                         }
2678                 }
2679         }
2680         ast_copy_flags(&p->flags[0], &locflags, SIP_NEEDDESTROY);       
2681         ast_mutex_unlock(&p->lock);
2682         return 0;
2683 }
2684
2685 /*! \brief Try setting codec suggested by the SIP_CODEC channel variable */
2686 static void try_suggested_sip_codec(struct sip_pvt *p)
2687 {
2688         int fmt;
2689         const char *codec;
2690
2691         codec = pbx_builtin_getvar_helper(p->owner, "SIP_CODEC");
2692         if (!codec) 
2693                 return;
2694
2695         fmt = ast_getformatbyname(codec);
2696         if (fmt) {
2697                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n", codec);
2698                 if (p->jointcapability & fmt) {
2699                         p->jointcapability &= fmt;
2700                         p->capability &= fmt;
2701                 } else
2702                         ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
2703         } else
2704                 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n", codec);
2705         return; 
2706 }
2707
2708 /*! \brief  sip_answer: Answer SIP call , send 200 OK on Invite 
2709  * Part of PBX interface */
2710 static int sip_answer(struct ast_channel *ast)
2711 {
2712         int res = 0;
2713         struct sip_pvt *p = ast->tech_pvt;
2714
2715         ast_mutex_lock(&p->lock);
2716         if (ast->_state != AST_STATE_UP) {
2717                 try_suggested_sip_codec(p);     
2718
2719                 ast_setstate(ast, AST_STATE_UP);
2720                 if (option_debug)
2721                         ast_log(LOG_DEBUG, "SIP answering channel: %s\n", ast->name);
2722                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, XMIT_RELIABLE);
2723         }
2724         ast_mutex_unlock(&p->lock);
2725         return res;
2726 }
2727
2728 /*! \brief Send frame to media channel (rtp) */
2729 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
2730 {
2731         struct sip_pvt *p = ast->tech_pvt;
2732         int res = 0;
2733
2734         switch (frame->frametype) {
2735         case AST_FRAME_VOICE:
2736                 if (!(frame->subclass & ast->nativeformats)) {
2737                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
2738                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
2739                         return 0;
2740                 }
2741                 if (p) {
2742                         ast_mutex_lock(&p->lock);
2743                         if (p->rtp) {
2744                                 /* If channel is not up, activate early media session */
2745                                 if ((ast->_state != AST_STATE_UP) &&
2746                                     !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
2747                                     !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
2748                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
2749                                         ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);  
2750                                 }
2751                                 time(&p->lastrtptx);
2752                                 res =  ast_rtp_write(p->rtp, frame);
2753                         }
2754                         ast_mutex_unlock(&p->lock);
2755                 }
2756                 break;
2757         case AST_FRAME_VIDEO:
2758                 if (p) {
2759                         ast_mutex_lock(&p->lock);
2760                         if (p->vrtp) {
2761                                 /* Activate video early media */
2762                                 if ((ast->_state != AST_STATE_UP) &&
2763                                     !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
2764                                     !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
2765                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
2766                                         ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);  
2767                                 }
2768                                 time(&p->lastrtptx);
2769                                 res =  ast_rtp_write(p->vrtp, frame);
2770                         }
2771                         ast_mutex_unlock(&p->lock);
2772                 }
2773                 break;
2774         case AST_FRAME_IMAGE:
2775                 return 0;
2776                 break;
2777         default: 
2778                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
2779                 return 0;
2780         }
2781
2782         return res;
2783 }
2784
2785 /*! \brief  sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
2786         Basically update any ->owner links */
2787 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
2788 {
2789         int ret = -1;
2790         struct sip_pvt *p;
2791
2792         if (!newchan || !newchan->tech_pvt) {
2793                 ast_log(LOG_WARNING, "No SIP tech_pvt! Fixup of %s failed.\n", oldchan->name);
2794                 return -1;
2795         }
2796         p = newchan->tech_pvt;
2797
2798         ast_mutex_lock(&p->lock);
2799         if (p->owner != oldchan)
2800                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
2801         else {
2802                 p->owner = newchan;
2803                 append_history(p, "Masq", "Old channel: %s\n", oldchan->name);
2804                 ret = 0;
2805         }
2806         ast_mutex_unlock(&p->lock);
2807         return ret;
2808 }
2809
2810 /*! \brief Send DTMF character on SIP channel
2811         within one call, we're able to transmit in many methods simultaneously */
2812 static int sip_senddigit(struct ast_channel *ast, char digit)
2813 {
2814         struct sip_pvt *p = ast->tech_pvt;
2815         int res = 0;
2816
2817         ast_mutex_lock(&p->lock);
2818         switch (ast_test_flag(&p->flags[0], SIP_DTMF)) {
2819         case SIP_DTMF_INFO:
2820                 transmit_info_with_digit(p, digit);
2821                 break;
2822         case SIP_DTMF_RFC2833:
2823                 if (p->rtp)
2824                         ast_rtp_senddigit(p->rtp, digit);
2825                 break;
2826         case SIP_DTMF_INBAND:
2827                 res = -1;
2828                 break;
2829         }
2830         ast_mutex_unlock(&p->lock);
2831         return res;
2832 }
2833
2834 /*! \brief Transfer SIP call */
2835 static int sip_transfer(struct ast_channel *ast, const char *dest)
2836 {
2837         struct sip_pvt *p = ast->tech_pvt;
2838         int res;
2839
2840         ast_mutex_lock(&p->lock);
2841         if (ast->_state == AST_STATE_RING)
2842                 res = sip_sipredirect(p, dest);
2843         else
2844                 res = transmit_refer(p, dest);
2845         ast_mutex_unlock(&p->lock);
2846         return res;
2847 }
2848
2849 /*! \brief Play indication to user 
2850  * With SIP a lot of indications is sent as messages, letting the device play
2851    the indication - busy signal, congestion etc 
2852    \return -1 to force ast_indicate to send indication in audio, 0 if SIP can handle the indication by sending a message
2853 */
2854 static int sip_indicate(struct ast_channel *ast, int condition)
2855 {
2856         struct sip_pvt *p = ast->tech_pvt;
2857         int res = 0;
2858
2859         ast_mutex_lock(&p->lock);
2860         switch(condition) {
2861         case AST_CONTROL_RINGING:
2862                 if (ast->_state == AST_STATE_RING) {
2863                         if (!ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) ||
2864                             (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {                          
2865                                 /* Send 180 ringing if out-of-band seems reasonable */
2866                                 transmit_response(p, "180 Ringing", &p->initreq);
2867                                 ast_set_flag(&p->flags[0], SIP_RINGING);
2868                                 if (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
2869                                         break;
2870                         } else {
2871                                 /* Well, if it's not reasonable, just send in-band */
2872                         }
2873                 }
2874                 res = -1;
2875                 break;
2876         case AST_CONTROL_BUSY:
2877                 if (ast->_state != AST_STATE_UP) {
2878                         transmit_response(p, "486 Busy Here", &p->initreq);
2879                         ast_set_flag(&p->flags[0], SIP_ALREADYGONE);    
2880                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2881                         break;
2882                 }
2883                 res = -1;
2884                 break;
2885         case AST_CONTROL_CONGESTION:
2886                 if (ast->_state != AST_STATE_UP) {
2887                         transmit_response(p, "503 Service Unavailable", &p->initreq);
2888                         ast_set_flag(&p->flags[0], SIP_ALREADYGONE);    
2889                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2890                         break;
2891                 }
2892                 res = -1;
2893                 break;
2894         case AST_CONTROL_PROCEEDING:
2895                 if ((ast->_state != AST_STATE_UP) &&
2896                     !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
2897                     !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
2898                         transmit_response(p, "100 Trying", &p->initreq);
2899                         break;
2900                 }
2901                 res = -1;
2902                 break;
2903         case AST_CONTROL_PROGRESS:
2904                 if ((ast->_state != AST_STATE_UP) &&
2905                     !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
2906                     !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
2907                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
2908                         ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);  
2909                         break;
2910                 }
2911                 res = -1;
2912                 break;
2913         case AST_CONTROL_HOLD:  /* The other part of the bridge are put on hold */
2914                 if (sipdebug)
2915                         ast_log(LOG_DEBUG, "Bridged channel now on hold - %s\n", p->callid);
2916                 res = -1;
2917                 break;
2918         case AST_CONTROL_UNHOLD:        /* The other part of the bridge are back from hold */
2919                 if (sipdebug)
2920                         ast_log(LOG_DEBUG, "Bridged channel is back from hold, let's talk! : %s\n", p->callid);
2921                 res = -1;
2922                 break;
2923         case AST_CONTROL_VIDUPDATE:     /* Request a video frame update */
2924                 if (p->vrtp && !ast_test_flag(&p->flags[0], SIP_NOVIDEO)) {
2925                         transmit_info_with_vidupdate(p);
2926                         /* ast_rtcp_send_h261fur(p->vrtp); */
2927                         res = 0;
2928                 } else
2929                         res = -1;
2930                 break;
2931         case -1:
2932                 res = -1;
2933                 break;
2934         default:
2935                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
2936                 res = -1;
2937                 break;
2938         }
2939         ast_mutex_unlock(&p->lock);
2940         return res;
2941 }
2942
2943
2944
2945 /*! \brief Initiate a call in the SIP channel
2946         called from sip_request_call (calls from the pbx ) */
2947 static struct ast_channel *sip_new(struct sip_pvt *i, int state, const char *title)
2948 {
2949         struct ast_channel *tmp;
2950         struct ast_variable *v = NULL;
2951         int fmt;
2952         int what;
2953         
2954         ast_mutex_unlock(&i->lock);
2955         /* Don't hold a sip pvt lock while we allocate a channel */
2956         tmp = ast_channel_alloc(1);
2957         ast_mutex_lock(&i->lock);
2958         if (!tmp) {
2959                 ast_log(LOG_WARNING, "Unable to allocate SIP channel structure\n");
2960                 return NULL;
2961         }
2962         tmp->tech = &sip_tech;
2963         /* Select our native format based on codec preference until we receive
2964            something from another device to the contrary. */
2965         if (i->jointcapability)
2966                 what = i->jointcapability;
2967         else if (i->capability)
2968                 what = i->capability;
2969         else
2970                 what = global_capability;
2971         tmp->nativeformats = ast_codec_choose(&i->prefs, what, 1) | (i->jointcapability & AST_FORMAT_VIDEO_MASK);
2972         fmt = ast_best_codec(tmp->nativeformats);
2973
2974         if (title)
2975                 ast_string_field_build(tmp, name, "SIP/%s-%04lx", title, ast_random() & 0xffff);
2976         else if (strchr(i->fromdomain,':'))
2977                 ast_string_field_build(tmp, name, "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2978         else
2979                 ast_string_field_build(tmp, name, "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2980
2981         if (ast_test_flag(&i->flags[0], SIP_DTMF) ==  SIP_DTMF_INBAND) {
2982                 i->vad = ast_dsp_new();
2983                 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2984                 if (global_relaxdtmf)
2985                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2986         }
2987         if (i->rtp) {
2988                 tmp->fds[0] = ast_rtp_fd(i->rtp);
2989                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
2990         }
2991         if (i->vrtp) {
2992                 tmp->fds[2] = ast_rtp_fd(i->vrtp);
2993                 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2994         }
2995         if (state == AST_STATE_RING)
2996                 tmp->rings = 1;
2997         tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2998         tmp->writeformat = fmt;
2999         tmp->rawwriteformat = fmt;
3000         tmp->readformat = fmt;
3001         tmp->rawreadformat = fmt;
3002         tmp->tech_pvt = i;
3003
3004         tmp->callgroup = i->callgroup;
3005         tmp->pickupgroup = i->pickupgroup;
3006         tmp->cid.cid_pres = i->callingpres;
3007         if (!ast_strlen_zero(i->accountcode))
3008                 ast_string_field_set(tmp, accountcode, i->accountcode);
3009         if (i->amaflags)
3010                 tmp->amaflags = i->amaflags;
3011         if (!ast_strlen_zero(i->language))
3012                 ast_string_field_set(tmp, language, i->language);
3013         if (!ast_strlen_zero(i->musicclass))
3014                 ast_string_field_set(tmp, musicclass, i->musicclass);
3015         i->owner = tmp;
3016         ast_mutex_lock(&usecnt_lock);
3017         usecnt++;
3018         ast_mutex_unlock(&usecnt_lock);
3019         ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
3020         ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
3021         if (!ast_strlen_zero(i->cid_num)) 
3022                 tmp->cid.cid_num = ast_strdup(i->cid_num);
3023         if (!ast_strlen_zero(i->cid_name))
3024                 tmp->cid.cid_name = ast_strdup(i->cid_name);
3025         if (!ast_strlen_zero(i->rdnis))
3026                 tmp->cid.cid_rdnis = ast_strdup(i->rdnis);
3027         if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
3028                 tmp->cid.cid_dnid = ast_strdup(i->exten);
3029         tmp->priority = 1;
3030         if (!ast_strlen_zero(i->uri))
3031                 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
3032         if (!ast_strlen_zero(i->domain))
3033                 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
3034         if (!ast_strlen_zero(i->useragent))
3035                 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
3036         if (!ast_strlen_zero(i->callid))
3037                 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
3038         ast_setstate(tmp, state);
3039         if (state != AST_STATE_DOWN && ast_pbx_start(tmp)) {
3040                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
3041                 tmp->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
3042                 ast_hangup(tmp);
3043                 tmp = NULL;
3044         }
3045         /* Set channel variables for this call from configuration */
3046         for (v = i->chanvars ; v ; v = v->next)
3047                 pbx_builtin_setvar_helper(tmp,v->name,v->value);
3048
3049         append_history(i, "NewChan", "Channel %s - from %s", tmp->name, i->callid);
3050                                 
3051         return tmp;
3052 }
3053
3054 /*! \brief Reads one line of SIP message body */
3055 static const char* get_sdp_by_line(const char* line, const char *name, int nameLen)
3056 {
3057         if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=')
3058                 return ast_skip_blanks(line + nameLen + 1);
3059         return "";
3060 }
3061
3062 /*! \brief get_sdp_iterate: lookup 'name' in the request starting
3063  * at the 'start' line. Returns the matching line, and 'start'
3064  * is updated with the next line number.
3065  */
3066 static const char* get_sdp_iterate(int* start,
3067                              struct sip_request *req, const char *name)
3068 {
3069         int len = strlen(name);
3070
3071         while (*start < req->lines) {
3072                 const char *r = get_sdp_by_line(req->line[(*start)++], name, len);
3073                 if (r[0] != '\0')
3074                         return r;
3075         }
3076         return "";
3077 }
3078
3079 /*! \brief  get_sdp: Gets all kind of SIP message bodies, including SDP,
3080    but the name wrongly applies _only_ sdp */
3081 static const char *get_sdp(struct sip_request *req, const char *name) 
3082 {
3083         int dummy = 0;
3084         return get_sdp_iterate(&dummy, req, name);
3085 }
3086
3087 static const char *find_alias(const char *name, const char *_default)
3088 {
3089         /*! \brief Structure for conversion between compressed SIP and "normal" SIP */
3090         static const struct cfalias {
3091                 char * const fullname;
3092                 char * const shortname;
3093         } aliases[] = {
3094                 { "Content-Type", "c" },
3095                 { "Content-Encoding", "e" },
3096                 { "From", "f" },
3097                 { "Call-ID", "i" },
3098                 { "Contact", "m" },
3099                 { "Content-Length", "l" },
3100                 { "Subject", "s" },
3101                 { "To", "t" },
3102                 { "Supported", "k" },
3103                 { "Refer-To", "r" },
3104                 { "Referred-By", "b" },
3105                 { "Allow-Events", "u" },
3106                 { "Event", "o" },
3107                 { "Via", "v" },
3108                 { "Accept-Contact",      "a" },
3109                 { "Reject-Contact",      "j" },
3110                 { "Request-Disposition", "d" },
3111                 { "Session-Expires",     "x" },
3112         };
3113         int x;
3114         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++) 
3115                 if (!strcasecmp(aliases[x].fullname, name))
3116                         return aliases[x].shortname;
3117         return _default;
3118 }
3119
3120 static const char *__get_header(const struct sip_request *req, const char *name, int *start)
3121 {
3122         int pass;
3123
3124         /*
3125          * Technically you can place arbitrary whitespace both before and after the ':' in
3126          * a header, although RFC3261 clearly says you shouldn't before, and place just
3127          * one afterwards.  If you shouldn't do it, what absolute idiot decided it was 
3128          * a good idea to say you can do it, and if you can do it, why in the hell would.
3129          * you say you shouldn't.
3130          * Anyways, pedanticsipchecking controls whether we allow spaces before ':',
3131          * and we always allow spaces after that for compatibility.
3132          */
3133         for (pass = 0; name && pass < 2;pass++) {
3134                 int x, len = strlen(name);
3135                 for (x=*start; x<req->headers; x++) {
3136                         if (!strncasecmp(req->header[x], name, len)) {
3137                                 char *r = req->header[x] + len; /* skip name */
3138                                 if (pedanticsipchecking)
3139                                         r = ast_skip_blanks(r);
3140
3141                                 if (*r == ':') {
3142                                         *start = x+1;
3143                                         return ast_skip_blanks(r+1);
3144                                 }
3145                         }
3146                 }
3147                 if (pass == 0) /* Try aliases */
3148                         name = find_alias(name, NULL);
3149         }
3150
3151         /* Don't return NULL, so get_header is always a valid pointer */
3152         return "";
3153 }
3154
3155 /*! \brief Get header from SIP request */
3156 static const char *get_header(const struct sip_request *req, const char *name)
3157 {
3158         int start = 0;
3159         return __get_header(req, name, &start);
3160 }
3161
3162 /*! \brief Read RTP from network */
3163 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
3164 {
3165         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
3166         struct ast_frame *f;
3167         
3168         if (!p->rtp) {
3169                 /* We have no RTP allocated for this channel */
3170                 return &ast_null_frame;
3171         }
3172
3173         switch(ast->fdno) {
3174         case 0:
3175                 f = ast_rtp_read(p->rtp);       /* RTP Audio */
3176                 break;
3177         case 1:
3178                 f = ast_rtcp_read(p->rtp);      /* RTCP Control Channel */
3179                 break;
3180         case 2:
3181                 f = ast_rtp_read(p->vrtp);      /* RTP Video */
3182                 break;
3183         case 3:
3184                 f = ast_rtcp_read(p->vrtp);     /* RTCP Control Channel for video */
3185                 break;
3186         default:
3187                 f = &ast_null_frame;
3188         }
3189         /* Don't forward RFC2833 if we're not supposed to */
3190         if (f && (f->frametype == AST_FRAME_DTMF) &&
3191             (ast_test_flag(&p->flags[0], SIP_DTMF) != SIP_DTMF_RFC2833))
3192                 return &ast_null_frame;
3193
3194         if (p->owner) {
3195                 /* We already hold the channel lock */
3196                 if (f->frametype == AST_FRAME_VOICE) {
3197                         if (f->subclass != (p->owner->nativeformats & AST_FORMAT_AUDIO_MASK)) {
3198                                 if (option_debug)
3199                                         ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
3200                                 p->owner->nativeformats = (p->owner->nativeformats & AST_FORMAT_VIDEO_MASK) | f->subclass;
3201                                 ast_set_read_format(p->owner, p->owner->readformat);
3202                                 ast_set_write_format(p->owner, p->owner->writeformat);
3203                         }
3204                         if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
3205                                 f = ast_dsp_process(p->owner, p->vad, f);
3206                                 if (option_debug && f && (f->frametype == AST_FRAME_DTMF)) 
3207                                         ast_log(LOG_DEBUG, "* Detected inband DTMF '%c'\n", f->subclass);
3208                         }
3209                 }
3210         }
3211         return f;
3212 }
3213
3214 /*! \brief Read SIP RTP from channel */
3215 static struct ast_frame *sip_read(struct ast_channel *ast)
3216 {
3217         struct ast_frame *fr;
3218         struct sip_pvt *p = ast->tech_pvt;
3219
3220         ast_mutex_lock(&p->lock);
3221         fr = sip_rtp_read(ast, p);
3222         time(&p->lastrtprx);
3223         ast_mutex_unlock(&p->lock);
3224         return fr;
3225 }
3226
3227
3228 /*! \brief Generate 32 byte random string for callid's etc */
3229 static char *generate_random_string(char *buf, size_t size)
3230 {
3231         long val[4];
3232         int x;
3233
3234         for (x=0; x<4; x++)
3235                 val[x] = ast_random();
3236         snprintf(buf, size, "%08lx%08lx%08lx%08lx", val[0], val[1], val[2], val[3]);
3237
3238         return buf;
3239 }
3240
3241 /*! \brief Build SIP Call-ID value for a non-REGISTER transaction */
3242 static void build_callid_pvt(struct sip_pvt *pvt)
3243 {
3244         char iabuf[INET_ADDRSTRLEN];
3245         char buf[33];
3246
3247         const char *host = S_OR(pvt->fromdomain, ast_inet_ntoa(iabuf, sizeof(iabuf), pvt->ourip));
3248         
3249         ast_string_field_build(pvt, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host);
3250
3251 }
3252
3253 /*! \brief Build SIP Call-ID value for a REGISTER transaction */
3254 static void build_callid_registry(struct sip_registry *reg, struct in_addr ourip, const char *fromdomain)
3255 {
3256         char iabuf[INET_ADDRSTRLEN];
3257         char buf[33];
3258
3259         const char *host = S_OR(fromdomain, ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
3260
3261         ast_string_field_build(reg, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host);
3262 }
3263
3264 /*! \brief Make our SIP dialog tag */
3265 static void make_our_tag(char *tagbuf, size_t len)
3266 {
3267         snprintf(tagbuf, len, "as%08lx", ast_random());
3268 }
3269
3270 /*! \brief Allocate SIP_PVT structure and set defaults */
3271 static struct sip_pvt *sip_alloc(ast_string_field callid, struct sockaddr_in *sin,
3272                                  int useglobal_nat, const int intended_method)
3273 {
3274         struct sip_pvt *p;
3275
3276         if (!(p = ast_calloc(1, sizeof(*p))))
3277                 return NULL;
3278
3279         if (ast_string_field_init(p, 512)) {
3280                 free(p);
3281                 return NULL;
3282         }
3283
3284         ast_mutex_init(&p->lock);
3285
3286         p->method = intended_method;
3287         p->initid = -1;
3288         p->autokillid = -1;
3289         p->subscribed = NONE;
3290         p->stateid = -1;
3291         p->prefs = default_prefs;               /* Set default codecs for this call */
3292
3293         if (intended_method != SIP_OPTIONS)     /* Peerpoke has it's own system */
3294                 p->timer_t1 = 500;      /* Default SIP retransmission timer T1 (RFC 3261) */
3295         if (sin) {
3296                 p->sa = *sin;
3297                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
3298                         p->ourip = __ourip;
3299         } else {
3300                 p->ourip = __ourip;
3301         }
3302         
3303         ast_copy_flags(&p->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
3304         ast_copy_flags(&p->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
3305
3306         p->branch = ast_random();       
3307         make_our_tag(p->tag, sizeof(p->tag));
3308         p->ocseq = INITIAL_CSEQ;
3309
3310         if (sip_methods[intended_method].need_rtp) {
3311                 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
3312                 if (ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT))
3313                         p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
3314                 if (!p->rtp || (ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) && !p->vrtp)) {
3315                         ast_log(LOG_WARNING, "Unable to create RTP audio %s session: %s\n",
3316                                 ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "and video" : "", strerror(errno));
3317                         ast_mutex_destroy(&p->lock);
3318                         if (p->chanvars) {
3319                                 ast_variables_destroy(p->chanvars);
3320                                 p->chanvars = NULL;
3321                         }
3322                         free(p);
3323                         return NULL;
3324                 }
3325                 ast_rtp_settos(p->rtp, global_tos_audio);
3326                 if (p->vrtp)
3327                         ast_rtp_settos(p->vrtp, global_tos_video);
3328                 p->rtptimeout = global_rtptimeout;
3329                 p->rtpholdtimeout = global_rtpholdtimeout;
3330                 p->rtpkeepalive = global_rtpkeepalive;
3331                 p->maxcallbitrate = default_maxcallbitrate;
3332         }
3333
3334         if (useglobal_nat && sin) {
3335                 int natflags;
3336                 /* Setup NAT structure according to global settings if we have an address */
3337                 ast_copy_flags(&p->flags[0], &global_flags[0], SIP_NAT);
3338                 p->recv = *sin;
3339                 natflags = ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE;
3340                 if (p->rtp)
3341                         ast_rtp_setnat(p->rtp, natflags);
3342                 if (p->vrtp)
3343                         ast_rtp_setnat(p->vrtp, natflags);
3344         }
3345
3346         if (p->method != SIP_REGISTER)
3347                 ast_string_field_set(p, fromdomain, default_fromdomain);
3348         build_via(p);
3349         if (!callid)
3350                 build_callid_pvt(p);
3351         else
3352                 ast_string_field_set(p, callid, callid);
3353         /* Assign default music on hold class */
3354         ast_string_field_set(p, musicclass, default_musicclass);
3355         p->capability = global_capability;
3356         p->allowtransfer = global_allowtransfer;
3357         if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
3358             (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
3359                 p->noncodeccapability |= AST_RTP_DTMF;
3360         ast_string_field_set(p, context, default_context);
3361
3362         /* Add to active dialog list */
3363         ast_mutex_lock(&iflock);
3364         p->next = iflist;
3365         iflist = p;
3366         ast_mutex_unlock(&iflock);
3367         if (option_debug)
3368                 ast_log(LOG_DEBUG, "Allocating new SIP dialog for %s - %s (%s)\n", callid ? callid : "(No Call-ID)", sip_methods[intended_method].text, p->rtp ? "With RTP" : "No RTP");
3369         return p;
3370 }
3371
3372 /*! \brief Connect incoming SIP message to current dialog or create new dialog structure
3373         Called by handle_request, sipsock_read */
3374 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
3375 {
3376         struct sip_pvt *p;
3377         char *tag = ""; /* note, tag is never NULL */
3378         char totag[128];
3379         char fromtag[128];
3380         const char *callid = get_header(req, "Call-ID");
3381
3382         if (pedanticsipchecking) {
3383                 /* In principle Call-ID's uniquely identify a call, but with a forking SIP proxy
3384                    we need more to identify a branch - so we have to check branch, from
3385                    and to tags to identify a call leg.
3386                    For Asterisk to behave correctly, you need to turn on pedanticsipchecking
3387                    in sip.conf
3388                    */
3389                 if (gettag(req, "To", totag, sizeof(totag)))
3390                         ast_set_flag(req, SIP_PKT_WITH_TOTAG);  /* Used in handle_request/response */
3391                 gettag(req, "From", fromtag, sizeof(fromtag));
3392
3393                 tag = (req->method == SIP_RESPONSE) ? totag : fromtag;
3394
3395                 if (option_debug > 4 )
3396                         ast_log(LOG_DEBUG, "= Looking for  Call ID: %s (Checking %s) --From tag %s --To-tag %s  \n", callid, req->method==SIP_RESPONSE ? "To" : "From", fromtag, totag);
3397         }
3398
3399         ast_mutex_lock(&iflock);
3400         for (p = iflist; p; p = p->next) {
3401                 /* In pedantic, we do not want packets with bad syntax to be connected to a PVT */
3402                 int found = FALSE;
3403                 if (req->method == SIP_REGISTER)
3404                         found = (!strcmp(p->callid, callid));
3405                 else 
3406                         found = (!strcmp(p->callid, callid) && 
3407                         (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) ;
3408
3409                 if (option_debug > 4)
3410                         ast_log(LOG_DEBUG, "= %s Their Call ID: %s Their Tag %s Our tag: %s\n", found ? "Found" : "No match", p->callid, p->theirtag, p->tag);
3411
3412                 /* If we get a new request within an existing to-tag - check the to tag as well */
3413                 if (pedanticsipchecking && found  && req->method != SIP_RESPONSE) {     /* SIP Request */
3414                         if (p->tag[0] == '\0' && totag[0]) {
3415                                 /* We have no to tag, but they have. Wrong dialog */
3416                                 found = FALSE;
3417                         } else if (totag[0]) {                  /* Both have tags, compare them */
3418                                 if (strcmp(totag, p->tag)) {
3419                                         found = FALSE;          /* This is not our packet */
3420                                 }
3421                         }
3422                         if (!found && option_debug > 4)
3423                                 ast_log(LOG_DEBUG, "= Being pedantic: This is not our match on request: Call ID: %s Ourtag <null> Totag %s Method %s\n", p->callid, totag, sip_methods[req->method].text);
3424                 }
3425
3426
3427                 if (found) {
3428                         /* Found the call */
3429                         ast_mutex_lock(&p->lock);
3430                         ast_mutex_unlock(&iflock);
3431                         return p;
3432                 }
3433         }
3434         ast_mutex_unlock(&iflock);
3435         /* Allocate new call */
3436         if ((p = sip_alloc(callid, sin, 1, intended_method)))
3437                 ast_mutex_lock(&p->lock);
3438         return p;
3439 }
3440
3441 /*! \brief Parse register=> line in sip.conf and add to registry */
3442 static int sip_register(char *value, int lineno)
3443 {
3444         struct sip_registry *reg;
3445         char copy[256];
3446         char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
3447         char *porta=NULL;
3448         char *contact=NULL;
3449         char *stringp=NULL;
3450         
3451         if (!value)
3452                 return -1;
3453         ast_copy_string(copy, value, sizeof(copy));
3454         stringp=copy;
3455         username = stringp;
3456         hostname = strrchr(stringp, '@');
3457         if (hostname)
3458                 *hostname++ = '\0';
3459         if (ast_strlen_zero(username) || ast_strlen_zero(hostname)) {
3460                 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d\n", lineno);
3461                 return -1;
3462         }
3463         stringp = username;
3464         username = strsep(&stringp, ":");
3465         if (username) {
3466                 secret = strsep(&stringp, ":");
3467                 if (secret) 
3468                         authuser = strsep(&stringp, ":");
3469         }
3470         stringp = hostname;
3471         hostname = strsep(&stringp, "/");
3472         if (hostname) 
3473                 contact = strsep(&stringp, "/");
3474         if (ast_strlen_zero(contact))
3475                 contact = "s";
3476         stringp=hostname;
3477         hostname = strsep(&stringp, ":");
3478         porta = strsep(&stringp, ":");
3479         
3480         if (porta && !atoi(porta)) {
3481                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
3482                 return -1;
3483         }
3484         if (!(reg = ast_calloc(1, sizeof(*reg)))) {