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