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