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