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