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