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