remove unused config option (issue #5358)
[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         char tag[11];                           /* 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         unsigned int osptimelimit;              /* OSP call duration limit */
641 #endif
642         struct sip_request initreq;             /* Initial request */
643         
644         int maxtime;                            /* Max time for first response */
645         int maxforwards;                        /* keep the max-forwards info */
646         int initid;                             /* Auto-congest ID if appropriate */
647         int autokillid;                         /* Auto-kill ID */
648         time_t lastrtprx;                       /* Last RTP received */
649         time_t lastrtptx;                       /* Last RTP sent */
650         int rtptimeout;                         /* RTP timeout time */
651         int rtpholdtimeout;                     /* RTP timeout when on hold */
652         int rtpkeepalive;                       /* Send RTP packets for keepalive */
653         enum subscriptiontype subscribed;       /* Is this call a subscription?  */
654         int stateid;
655         int laststate;                          /* Last known extension state */
656         int dialogver;
657         
658         struct ast_dsp *vad;                    /* Voice Activation Detection dsp */
659         
660         struct sip_peer *peerpoke;              /* If this calls is to poke a peer, which one */
661         struct sip_registry *registry;          /* If this is a REGISTER call, to which registry */
662         struct ast_rtp *rtp;                    /* RTP Session */
663         struct ast_rtp *vrtp;                   /* Video RTP session */
664         struct sip_pkt *packets;                /* Packets scheduled for re-transmission */
665         struct sip_history *history;            /* History of this SIP dialog */
666         struct ast_variable *chanvars;          /* Channel variables to set for call */
667         struct sip_pvt *next;                   /* Next call in chain */
668         struct sip_invite_param *options;       /* Options for INVITE */
669 } *iflist = NULL;
670
671 #define FLAG_RESPONSE (1 << 0)
672 #define FLAG_FATAL (1 << 1)
673
674 /* sip packet - read in sipsock_read, transmitted in send_request */
675 struct sip_pkt {
676         struct sip_pkt *next;                   /* Next packet */
677         int retrans;                            /* Retransmission number */
678         int method;                             /* SIP method for this packet */
679         int seqno;                              /* Sequence number */
680         unsigned int flags;                     /* non-zero if this is a response packet (e.g. 200 OK) */
681         struct sip_pvt *owner;                  /* Owner call */
682         int retransid;                          /* Retransmission ID */
683         int timer_a;                            /* SIP timer A, retransmission timer */
684         int timer_t1;                           /* SIP Timer T1, estimated RTT or 500 ms */
685         int packetlen;                          /* Length of packet */
686         char data[0];
687 };      
688
689 /* Structure for SIP user data. User's place calls to us */
690 struct sip_user {
691         /* Users who can access various contexts */
692         ASTOBJ_COMPONENTS(struct sip_user);
693         char secret[80];                /* Password */
694         char md5secret[80];             /* Password in md5 */
695         char context[AST_MAX_CONTEXT];  /* Default context for incoming calls */
696         char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
697         char cid_num[80];               /* Caller ID num */
698         char cid_name[80];              /* Caller ID name */
699         char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
700         char language[MAX_LANGUAGE];    /* Default language for this user */
701         char musicclass[MAX_MUSICCLASS];/* Music on Hold class */
702         char useragent[256];            /* User agent in SIP request */
703         struct ast_codec_pref prefs;    /* codec prefs */
704         ast_group_t callgroup;          /* Call group */
705         ast_group_t pickupgroup;        /* Pickup Group */
706         unsigned int flags;             /* SIP flags */ 
707         unsigned int sipoptions;        /* Supported SIP options */
708         struct ast_flags flags_page2;   /* SIP_PAGE2 flags */
709         int amaflags;                   /* AMA flags for billing */
710         int callingpres;                /* Calling id presentation */
711         int capability;                 /* Codec capability */
712         int inUse;                      /* Number of calls in use */
713         int call_limit;                 /* Limit of concurrent calls */
714         struct ast_ha *ha;              /* ACL setting */
715         struct ast_variable *chanvars;  /* Variables to set for channel created by user */
716 };
717
718 /* Structure for SIP peer data, we place calls to peers if registered  or fixed IP address (host) */
719 struct sip_peer {
720         ASTOBJ_COMPONENTS(struct sip_peer);     /* name, refcount, objflags,  object pointers */
721                                         /* peer->name is the unique name of this object */
722         char secret[80];                /* Password */
723         char md5secret[80];             /* Password in MD5 */
724         struct sip_auth *auth;          /* Realm authentication list */
725         char context[AST_MAX_CONTEXT];  /* Default context for incoming calls */
726         char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
727         char username[80];              /* Temporary username until registration */ 
728         char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
729         int amaflags;                   /* AMA Flags (for billing) */
730         char tohost[MAXHOSTNAMELEN];    /* If not dynamic, IP address */
731         char regexten[AST_MAX_EXTENSION]; /* Extension to register (if regcontext is used) */
732         char fromuser[80];              /* From: user when calling this peer */
733         char fromdomain[MAXHOSTNAMELEN];        /* From: domain when calling this peer */
734         char fullcontact[256];          /* Contact registered with us (not in sip.conf) */
735         char cid_num[80];               /* Caller ID num */
736         char cid_name[80];              /* Caller ID name */
737         int callingpres;                /* Calling id presentation */
738         int inUse;                      /* Number of calls in use */
739         int call_limit;                 /* Limit of concurrent calls */
740         char vmexten[AST_MAX_EXTENSION];        /* Dialplan extension for MWI notify message*/
741         char mailbox[AST_MAX_EXTENSION]; /* Mailbox setting for MWI checks */
742         char language[MAX_LANGUAGE];    /* Default language for prompts */
743         char musicclass[MAX_MUSICCLASS];/* Music on Hold class */
744         char useragent[256];            /* User agent in SIP request (saved from registration) */
745         struct ast_codec_pref prefs;    /* codec prefs */
746         int lastmsgssent;
747         time_t  lastmsgcheck;           /* Last time we checked for MWI */
748         unsigned int flags;             /* SIP flags */ 
749         unsigned int sipoptions;        /* Supported SIP options */
750         struct ast_flags flags_page2;   /* SIP_PAGE2 flags */
751         int expire;                     /* When to expire this peer registration */
752         int capability;                 /* Codec capability */
753         int rtptimeout;                 /* RTP timeout */
754         int rtpholdtimeout;             /* RTP Hold Timeout */
755         int rtpkeepalive;               /* Send RTP packets for keepalive */
756         ast_group_t callgroup;          /* Call group */
757         ast_group_t pickupgroup;        /* Pickup group */
758         struct ast_dnsmgr_entry *dnsmgr;/* DNS refresh manager for peer */
759         struct sockaddr_in addr;        /* IP address of peer */
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         r->prefs = peer->prefs;
1815         if (r->rtp) {
1816                 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1817                 ast_rtp_setnat(r->rtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1818         }
1819         if (r->vrtp) {
1820                 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1821                 ast_rtp_setnat(r->vrtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1822         }
1823         ast_copy_string(r->peername, peer->username, sizeof(r->peername));
1824         ast_copy_string(r->authname, peer->username, sizeof(r->authname));
1825         ast_copy_string(r->username, peer->username, sizeof(r->username));
1826         ast_copy_string(r->peersecret, peer->secret, sizeof(r->peersecret));
1827         ast_copy_string(r->peermd5secret, peer->md5secret, sizeof(r->peermd5secret));
1828         ast_copy_string(r->tohost, peer->tohost, sizeof(r->tohost));
1829         ast_copy_string(r->fullcontact, peer->fullcontact, sizeof(r->fullcontact));
1830         if (!r->initreq.headers && !ast_strlen_zero(peer->fromdomain)) {
1831                 if ((callhost = strchr(r->callid, '@'))) {
1832                         strncpy(callhost + 1, peer->fromdomain, sizeof(r->callid) - (callhost - r->callid) - 2);
1833                 }
1834         }
1835         if (ast_strlen_zero(r->tohost)) {
1836                 if (peer->addr.sin_addr.s_addr)
1837                         ast_inet_ntoa(r->tohost, sizeof(r->tohost), peer->addr.sin_addr);
1838                 else
1839                         ast_inet_ntoa(r->tohost, sizeof(r->tohost), peer->defaddr.sin_addr);
1840         }
1841         if (!ast_strlen_zero(peer->fromdomain))
1842                 ast_copy_string(r->fromdomain, peer->fromdomain, sizeof(r->fromdomain));
1843         if (!ast_strlen_zero(peer->fromuser))
1844                 ast_copy_string(r->fromuser, peer->fromuser, sizeof(r->fromuser));
1845         r->maxtime = peer->maxms;
1846         r->callgroup = peer->callgroup;
1847         r->pickupgroup = peer->pickupgroup;
1848         /* Set timer T1 to RTT for this peer (if known by qualify=) */
1849         if (peer->maxms && peer->lastms)
1850                 r->timer_t1 = peer->lastms;
1851         if ((ast_test_flag(r, SIP_DTMF) == SIP_DTMF_RFC2833) || (ast_test_flag(r, SIP_DTMF) == SIP_DTMF_AUTO))
1852                 r->noncodeccapability |= AST_RTP_DTMF;
1853         else
1854                 r->noncodeccapability &= ~AST_RTP_DTMF;
1855         ast_copy_string(r->context, peer->context,sizeof(r->context));
1856         r->rtptimeout = peer->rtptimeout;
1857         r->rtpholdtimeout = peer->rtpholdtimeout;
1858         r->rtpkeepalive = peer->rtpkeepalive;
1859         if (peer->call_limit)
1860                 ast_set_flag(r, SIP_CALL_LIMIT);
1861
1862         return 0;
1863 }
1864
1865 /*--- create_addr: create address structure from peer name ---*/
1866 /*      Or, if peer not found, find it in the global DNS */
1867 /*      returns TRUE (-1) on failure, FALSE on success */
1868 static int create_addr(struct sip_pvt *dialog, char *opeer)
1869 {
1870         struct hostent *hp;
1871         struct ast_hostent ahp;
1872         struct sip_peer *p;
1873         int found=0;
1874         char *port;
1875         int portno;
1876         char host[MAXHOSTNAMELEN], *hostn;
1877         char peer[256];
1878
1879         ast_copy_string(peer, opeer, sizeof(peer));
1880         port = strchr(peer, ':');
1881         if (port) {
1882                 *port = '\0';
1883                 port++;
1884         }
1885         dialog->sa.sin_family = AF_INET;
1886         dialog->timer_t1 = 500; /* Default SIP retransmission timer T1 (RFC 3261) */
1887         p = find_peer(peer, NULL, 1);
1888
1889         if (p) {
1890                 found++;
1891                 if (create_addr_from_peer(dialog, p))
1892                         ASTOBJ_UNREF(p, sip_destroy_peer);
1893         }
1894         if (!p) {
1895                 if (found)
1896                         return -1;
1897
1898                 hostn = peer;
1899                 if (port)
1900                         portno = atoi(port);
1901                 else
1902                         portno = DEFAULT_SIP_PORT;
1903                 if (srvlookup) {
1904                         char service[MAXHOSTNAMELEN];
1905                         int tportno;
1906                         int ret;
1907                         snprintf(service, sizeof(service), "_sip._udp.%s", peer);
1908                         ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
1909                         if (ret > 0) {
1910                                 hostn = host;
1911                                 portno = tportno;
1912                         }
1913                 }
1914                 hp = ast_gethostbyname(hostn, &ahp);
1915                 if (hp) {
1916                         ast_copy_string(dialog->tohost, peer, sizeof(dialog->tohost));
1917                         memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr));
1918                         dialog->sa.sin_port = htons(portno);
1919                         memcpy(&dialog->recv, &dialog->sa, sizeof(dialog->recv));
1920                         return 0;
1921                 } else {
1922                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
1923                         return -1;
1924                 }
1925         } else {
1926                 ASTOBJ_UNREF(p, sip_destroy_peer);
1927                 return 0;
1928         }
1929 }
1930
1931 /*--- auto_congest: Scheduled congestion on a call ---*/
1932 static int auto_congest(void *nothing)
1933 {
1934         struct sip_pvt *p = nothing;
1935         ast_mutex_lock(&p->lock);
1936         p->initid = -1;
1937         if (p->owner) {
1938                 if (!ast_mutex_trylock(&p->owner->lock)) {
1939                         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
1940                         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
1941                         ast_mutex_unlock(&p->owner->lock);
1942                 }
1943         }
1944         ast_mutex_unlock(&p->lock);
1945         return 0;
1946 }
1947
1948
1949
1950
1951 /*--- sip_call: Initiate SIP call from PBX ---*/
1952 /*      used from the dial() application      */
1953 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
1954 {
1955         int res;
1956         struct sip_pvt *p;
1957 #ifdef OSP_SUPPORT
1958         char *osphandle = NULL;
1959 #endif  
1960         struct varshead *headp;
1961         struct ast_var_t *current;
1962         
1963
1964         
1965         p = ast->tech_pvt;
1966         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1967                 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
1968                 return -1;
1969         }
1970
1971
1972         /* Check whether there is vxml_url, distinctive ring variables */
1973
1974         headp=&ast->varshead;
1975         AST_LIST_TRAVERSE(headp,current,entries) {
1976                 /* Check whether there is a VXML_URL variable */
1977                 if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
1978                         p->options->vxml_url = ast_var_value(current);
1979                } else if (!p->options->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
1980                        p->options->uri_options = ast_var_value(current);
1981                 } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
1982                         /* Check whether there is a ALERT_INFO variable */
1983                         p->options->distinctive_ring = ast_var_value(current);
1984                 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
1985                         /* Check whether there is a variable with a name starting with SIPADDHEADER */
1986                         p->options->addsipheaders = 1;
1987                 }
1988
1989                 
1990 #ifdef OSP_SUPPORT
1991                 else if (!p->options->osptoken && !strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1992                         p->options->osptoken = ast_var_value(current);
1993                 } else if (!osphandle && !strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1994                         osphandle = ast_var_value(current);
1995                 }
1996 #endif
1997         }
1998         
1999         res = 0;
2000         ast_set_flag(p, SIP_OUTGOING);
2001 #ifdef OSP_SUPPORT
2002         if (!p->options->osptoken || !osphandle || (sscanf(osphandle, "%d", &p->osphandle) != 1)) {
2003                 /* Force Disable OSP support */
2004                 ast_log(LOG_DEBUG, "Disabling OSP support for this call. osptoken = %s, osphandle = %s\n", p->options->osptoken, osphandle);
2005                 p->options->osptoken = NULL;
2006                 osphandle = NULL;
2007                 p->osphandle = -1;
2008         }
2009 #endif
2010         ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
2011         res = update_call_counter(p, INC_CALL_LIMIT);
2012         if ( res != -1 ) {
2013                 p->callingpres = ast->cid.cid_pres;
2014                 p->jointcapability = p->capability;
2015                 transmit_invite(p, SIP_INVITE, 1, 2);
2016                 if (p->maxtime) {
2017                         /* Initialize auto-congest time */
2018                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
2019                 }
2020         }
2021         return res;
2022 }
2023
2024 /*--- sip_registry_destroy: Destroy registry object ---*/
2025 /*      Objects created with the register= statement in static configuration */
2026 static void sip_registry_destroy(struct sip_registry *reg)
2027 {
2028         /* Really delete */
2029         if (reg->call) {
2030                 /* Clear registry before destroying to ensure
2031                    we don't get reentered trying to grab the registry lock */
2032                 reg->call->registry = NULL;
2033                 sip_destroy(reg->call);
2034         }
2035         if (reg->expire > -1)
2036                 ast_sched_del(sched, reg->expire);
2037         if (reg->timeout > -1)
2038                 ast_sched_del(sched, reg->timeout);
2039         regobjs--;
2040         free(reg);
2041         
2042 }
2043
2044 /*---  __sip_destroy: Execute destrucion of call structure, release memory---*/
2045 static void __sip_destroy(struct sip_pvt *p, int lockowner)
2046 {
2047         struct sip_pvt *cur, *prev = NULL;
2048         struct sip_pkt *cp;
2049         struct sip_history *hist;
2050
2051         if (sip_debug_test_pvt(p))
2052                 ast_verbose("Destroying call '%s'\n", p->callid);
2053
2054         if (dumphistory)
2055                 sip_dump_history(p);
2056
2057         if (p->options)
2058                 free(p->options);
2059
2060         if (p->stateid > -1)
2061                 ast_extension_state_del(p->stateid, NULL);
2062         if (p->initid > -1)
2063                 ast_sched_del(sched, p->initid);
2064         if (p->autokillid > -1)
2065                 ast_sched_del(sched, p->autokillid);
2066
2067         if (p->rtp) {
2068                 ast_rtp_destroy(p->rtp);
2069         }
2070         if (p->vrtp) {
2071                 ast_rtp_destroy(p->vrtp);
2072         }
2073         if (p->route) {
2074                 free_old_route(p->route);
2075                 p->route = NULL;
2076         }
2077         if (p->registry) {
2078                 if (p->registry->call == p)
2079                         p->registry->call = NULL;
2080                 ASTOBJ_UNREF(p->registry,sip_registry_destroy);
2081         }
2082
2083         if (p->rpid)
2084                 free(p->rpid);
2085
2086         if (p->rpid_from)
2087                 free(p->rpid_from);
2088
2089         /* Unlink us from the owner if we have one */
2090         if (p->owner) {
2091                 if (lockowner)
2092                         ast_mutex_lock(&p->owner->lock);
2093                 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
2094                 p->owner->tech_pvt = NULL;
2095                 if (lockowner)
2096                         ast_mutex_unlock(&p->owner->lock);
2097         }
2098         /* Clear history */
2099         while(p->history) {
2100                 hist = p->history;
2101                 p->history = p->history->next;
2102                 free(hist);
2103         }
2104
2105         cur = iflist;
2106         while(cur) {
2107                 if (cur == p) {
2108                         if (prev)
2109                                 prev->next = cur->next;
2110                         else
2111                                 iflist = cur->next;
2112                         break;
2113                 }
2114                 prev = cur;
2115                 cur = cur->next;
2116         }
2117         if (!cur) {
2118                 ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
2119                 return;
2120         } 
2121         if (p->initid > -1)
2122                 ast_sched_del(sched, p->initid);
2123
2124         while((cp = p->packets)) {
2125                 p->packets = p->packets->next;
2126                 if (cp->retransid > -1) {
2127                         ast_sched_del(sched, cp->retransid);
2128                 }
2129                 free(cp);
2130         }
2131         if (p->chanvars) {
2132                 ast_variables_destroy(p->chanvars);
2133                 p->chanvars = NULL;
2134         }
2135         ast_mutex_destroy(&p->lock);
2136         free(p);
2137 }
2138
2139 /*--- update_call_counter: Handle call_limit for SIP users ---*/
2140 /* Note: This is going to be replaced by app_groupcount */
2141 /* Thought: For realtime, we should propably update storage with inuse counter... */
2142 static int update_call_counter(struct sip_pvt *fup, int event)
2143 {
2144         char name[256];
2145         int *inuse, *call_limit;
2146         int outgoing = ast_test_flag(fup, SIP_OUTGOING);
2147         struct sip_user *u = NULL;
2148         struct sip_peer *p = NULL;
2149
2150         if (option_debug > 2)
2151                 ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
2152         /* Test if we need to check call limits, in order to avoid 
2153            realtime lookups if we do not need it */
2154         if (!ast_test_flag(fup, SIP_CALL_LIMIT))
2155                 return 0;
2156
2157         ast_copy_string(name, fup->username, sizeof(name));
2158
2159         /* Check the list of users */
2160         u = find_user(name, 1);
2161         if (u) {
2162                 inuse = &u->inUse;
2163                 call_limit = &u->call_limit;
2164                 p = NULL;
2165         } else {
2166                 /* Try to find peer */
2167                 if (!p)
2168                         p = find_peer(fup->peername, NULL, 1);
2169                 if (p) {
2170                         inuse = &p->inUse;
2171                         call_limit = &p->call_limit;
2172                         ast_copy_string(name, fup->peername, sizeof(name));
2173                 } else {
2174                         if (option_debug > 1)
2175                                 ast_log(LOG_DEBUG, "%s is not a local user, no call limit\n", name);
2176                         return 0;
2177                 }
2178         }
2179         switch(event) {
2180                 /* incoming and outgoing affects the inUse counter */
2181                 case DEC_CALL_LIMIT:
2182                         if ( *inuse > 0 ) {
2183                                 (*inuse)--;
2184                         } else {
2185                                 *inuse = 0;
2186                         }
2187                         if (option_debug > 1 || sipdebug) {
2188                                 ast_log(LOG_DEBUG, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
2189                         }
2190                         break;
2191                 case INC_CALL_LIMIT:
2192                         if (*call_limit > 0 ) {
2193                                 if (*inuse >= *call_limit) {
2194                                         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);
2195                                         /* inc inUse as well */
2196                                         if ( event == INC_CALL_LIMIT ) {
2197                                                 (*inuse)++;
2198                                         }
2199                                         if (u)
2200                                                 ASTOBJ_UNREF(u,sip_destroy_user);
2201                                         else
2202                                                 ASTOBJ_UNREF(p,sip_destroy_peer);
2203                                         return -1; 
2204                                 }
2205                         }
2206                         (*inuse)++;
2207                         if (option_debug > 1 || sipdebug) {
2208                                 ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
2209                         }
2210                         break;
2211                 default:
2212                         ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
2213         }
2214         if (u)
2215                 ASTOBJ_UNREF(u,sip_destroy_user);
2216         else
2217                 ASTOBJ_UNREF(p,sip_destroy_peer);
2218         return 0;
2219 }
2220
2221 /*--- sip_destroy: Destroy SIP call structure ---*/
2222 static void sip_destroy(struct sip_pvt *p)
2223 {
2224         ast_mutex_lock(&iflock);
2225         __sip_destroy(p, 1);
2226         ast_mutex_unlock(&iflock);
2227 }
2228
2229
2230 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
2231
2232 /*--- hangup_sip2cause: Convert SIP hangup causes to Asterisk hangup causes ---*/
2233 static int hangup_sip2cause(int cause)
2234 {
2235 /* Possible values taken from causes.h */
2236
2237         switch(cause) {
2238                 case 403:       /* Not found */
2239                         return AST_CAUSE_CALL_REJECTED;
2240                 case 404:       /* Not found */
2241                         return AST_CAUSE_UNALLOCATED;
2242                 case 408:       /* No reaction */
2243                         return AST_CAUSE_NO_USER_RESPONSE;
2244                 case 480:       /* No answer */
2245                         return AST_CAUSE_FAILURE;
2246                 case 483:       /* Too many hops */
2247                         return AST_CAUSE_NO_ANSWER;
2248                 case 486:       /* Busy everywhere */
2249                         return AST_CAUSE_BUSY;
2250                 case 488:       /* No codecs approved */
2251                         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2252                 case 500:       /* Server internal failure */
2253                         return AST_CAUSE_FAILURE;
2254                 case 501:       /* Call rejected */
2255                         return AST_CAUSE_FACILITY_REJECTED;
2256                 case 502:       
2257                         return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2258                 case 503:       /* Service unavailable */
2259                         return AST_CAUSE_CONGESTION;
2260                 default:
2261                         return AST_CAUSE_NORMAL;
2262         }
2263         /* Never reached */
2264         return 0;
2265 }
2266
2267
2268 /*--- hangup_cause2sip: Convert Asterisk hangup causes to SIP codes ---*/
2269 /* Possible values from causes.h
2270         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
2271         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
2272
2273         In addition to these, a lot of PRI codes is defined in causes.h 
2274         ...should we take care of them too ?
2275         
2276         Quote RFC 3398
2277
2278    ISUP Cause value                        SIP response
2279    ----------------                        ------------
2280    1  unallocated number                   404 Not Found
2281    2  no route to network                  404 Not found
2282    3  no route to destination              404 Not found
2283    16 normal call clearing                 --- (*)
2284    17 user busy                            486 Busy here
2285    18 no user responding                   408 Request Timeout
2286    19 no answer from the user              480 Temporarily unavailable
2287    20 subscriber absent                    480 Temporarily unavailable
2288    21 call rejected                        403 Forbidden (+)
2289    22 number changed (w/o diagnostic)      410 Gone
2290    22 number changed (w/ diagnostic)       301 Moved Permanently
2291    23 redirection to new destination       410 Gone
2292    26 non-selected user clearing           404 Not Found (=)
2293    27 destination out of order             502 Bad Gateway
2294    28 address incomplete                   484 Address incomplete
2295    29 facility rejected                    501 Not implemented
2296    31 normal unspecified                   480 Temporarily unavailable
2297 */
2298 static char *hangup_cause2sip(int cause)
2299 {
2300         switch(cause)
2301         {
2302                 case AST_CAUSE_UNALLOCATED:             /* 1 */
2303                 case AST_CAUSE_NO_ROUTE_DESTINATION:    /* 3 IAX2: Can't find extension in context */
2304                 case AST_CAUSE_NO_ROUTE_TRANSIT_NET:    /* 2 */
2305                         return "404 Not Found";
2306                 case AST_CAUSE_CONGESTION:              /* 34 */
2307                 case AST_CAUSE_SWITCH_CONGESTION:       /* 42 */
2308                         return "503 Service Unavailable";
2309                 case AST_CAUSE_NO_USER_RESPONSE:        /* 18 */
2310                         return "408 Request Timeout";
2311                 case AST_CAUSE_NO_ANSWER:               /* 19 */
2312                         return "480 Temporarily unavailable";
2313                 case AST_CAUSE_CALL_REJECTED:           /* 21 */
2314                         return "403 Forbidden";
2315                 case AST_CAUSE_NUMBER_CHANGED:          /* 22 */
2316                         return "410 Gone";
2317                 case AST_CAUSE_NORMAL_UNSPECIFIED:      /* 31 */
2318                         return "480 Temporarily unavailable";
2319                 case AST_CAUSE_INVALID_NUMBER_FORMAT:
2320                         return "484 Address incomplete";
2321                 case AST_CAUSE_USER_BUSY:
2322                         return "486 Busy here";
2323                 case AST_CAUSE_FAILURE:
2324                         return "500 Server internal failure";
2325                 case AST_CAUSE_FACILITY_REJECTED:       /* 29 */
2326                         return "501 Not Implemented";
2327                 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
2328                         return "503 Service Unavailable";
2329                 /* Used in chan_iax2 */
2330                 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
2331                         return "502 Bad Gateway";
2332                 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:       /* Can't find codec to connect to host */
2333                         return "488 Not Acceptable Here";
2334                         
2335                 case AST_CAUSE_NOTDEFINED:
2336                 default:
2337                         ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
2338                         return NULL;
2339         }
2340
2341         /* Never reached */
2342         return 0;
2343 }
2344
2345
2346 /*--- sip_hangup: Hangup SIP call ---*/
2347 /* Part of PBX interface */
2348 static int sip_hangup(struct ast_channel *ast)
2349 {
2350         struct sip_pvt *p = ast->tech_pvt;
2351         int needcancel = 0;
2352         struct ast_flags locflags = {0};
2353
2354         if (!p) {
2355                 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
2356                 return 0;
2357         }
2358         if (option_debug)
2359                 ast_log(LOG_DEBUG, "Hangup call %s, SIP callid %s)\n", ast->name, p->callid);
2360
2361         ast_mutex_lock(&p->lock);
2362 #ifdef OSP_SUPPORT
2363         if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
2364                 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
2365         }
2366 #endif  
2367         ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter\n", p->username);
2368         update_call_counter(p, DEC_CALL_LIMIT);
2369         /* Determine how to disconnect */
2370         if (p->owner != ast) {
2371                 ast_log(LOG_WARNING, "Huh?  We aren't the owner? Can't hangup call.\n");
2372                 ast_mutex_unlock(&p->lock);
2373                 return 0;
2374         }
2375         /* If the call is not UP, we need to send CANCEL instead of BYE */
2376         if (ast->_state != AST_STATE_UP)
2377                 needcancel = 1;
2378
2379         /* Disconnect */
2380         p = ast->tech_pvt;
2381         if (p->vad) {
2382                 ast_dsp_free(p->vad);
2383         }
2384         p->owner = NULL;
2385         ast->tech_pvt = NULL;
2386
2387         ast_mutex_lock(&usecnt_lock);
2388         usecnt--;
2389         ast_mutex_unlock(&usecnt_lock);
2390         ast_update_use_count();
2391
2392         ast_set_flag(&locflags, SIP_NEEDDESTROY);       
2393
2394         /* Start the process if it's not already started */
2395         if (!ast_test_flag(p, SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
2396                 if (needcancel) {       /* Outgoing call, not up */
2397                         if (ast_test_flag(p, SIP_OUTGOING)) {
2398                                 transmit_request_with_auth(p, SIP_CANCEL, p->ocseq, 1, 0);
2399                                 /* Actually don't destroy us yet, wait for the 487 on our original 
2400                                    INVITE, but do set an autodestruct just in case we never get it. */
2401                                 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
2402                                 sip_scheddestroy(p, 15000);
2403                                 /* stop retransmitting an INVITE that has not received a response */
2404                                 __sip_pretend_ack(p);
2405                                 if ( p->initid != -1 ) {
2406                                         /* channel still up - reverse dec of inUse counter
2407                                            only if the channel is not auto-congested */
2408                                         update_call_counter(p, INC_CALL_LIMIT);
2409                                 }
2410                         } else {        /* Incoming call, not up */
2411                                 char *res;
2412                                 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
2413                                         transmit_response_reliable(p, res, &p->initreq, 1);
2414                                 } else 
2415                                         transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
2416                         }
2417                 } else {        /* Call is in UP state, send BYE */
2418                         if (!p->pendinginvite) {
2419                                 /* Send a hangup */
2420                                 transmit_request_with_auth(p, SIP_BYE, 0, 1, 1);
2421                         } else {
2422                                 /* Note we will need a BYE when this all settles out
2423                                    but we can't send one while we have "INVITE" outstanding. */
2424                                 ast_set_flag(p, SIP_PENDINGBYE);        
2425                                 ast_clear_flag(p, SIP_NEEDREINVITE);    
2426                         }
2427                 }
2428         }
2429         ast_copy_flags(p, (&locflags), SIP_NEEDDESTROY);        
2430         ast_mutex_unlock(&p->lock);
2431         return 0;
2432 }
2433
2434 /*--- sip_answer: Answer SIP call , send 200 OK on Invite ---*/
2435 /* Part of PBX interface */
2436 static int sip_answer(struct ast_channel *ast)
2437 {
2438         int res = 0,fmt;
2439         char *codec;
2440         struct sip_pvt *p = ast->tech_pvt;
2441
2442         ast_mutex_lock(&p->lock);
2443         if (ast->_state != AST_STATE_UP) {
2444 #ifdef OSP_SUPPORT      
2445                 time(&p->ospstart);
2446 #endif
2447         
2448                 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
2449                 if (codec) {
2450                         fmt=ast_getformatbyname(codec);
2451                         if (fmt) {
2452                                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
2453                                 if (p->jointcapability & fmt) {
2454                                         p->jointcapability &= fmt;
2455                                         p->capability &= fmt;
2456                                 } else
2457                                         ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
2458                         } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
2459                 }
2460
2461                 ast_setstate(ast, AST_STATE_UP);
2462                 if (option_debug)
2463                         ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
2464                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
2465         }
2466         ast_mutex_unlock(&p->lock);
2467         return res;
2468 }
2469
2470 /*--- sip_write: Send frame to media channel (rtp) ---*/
2471 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
2472 {
2473         struct sip_pvt *p = ast->tech_pvt;
2474         int res = 0;
2475         switch (frame->frametype) {
2476         case AST_FRAME_VOICE:
2477                 if (!(frame->subclass & ast->nativeformats)) {
2478                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
2479                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
2480                         return 0;
2481                 }
2482                 if (p) {
2483                         ast_mutex_lock(&p->lock);
2484                         if (p->rtp) {
2485                                 /* If channel is not up, activate early media session */
2486                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2487                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2488                                         ast_set_flag(p, SIP_PROGRESS_SENT);     
2489                                 }
2490                                 time(&p->lastrtptx);
2491                                 res =  ast_rtp_write(p->rtp, frame);
2492                         }
2493                         ast_mutex_unlock(&p->lock);
2494                 }
2495                 break;
2496         case AST_FRAME_VIDEO:
2497                 if (p) {
2498                         ast_mutex_lock(&p->lock);
2499                         if (p->vrtp) {
2500                                 /* Activate video early media */
2501                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2502                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2503                                         ast_set_flag(p, SIP_PROGRESS_SENT);     
2504                                 }
2505                                 time(&p->lastrtptx);
2506                                 res =  ast_rtp_write(p->vrtp, frame);
2507                         }
2508                         ast_mutex_unlock(&p->lock);
2509                 }
2510                 break;
2511         case AST_FRAME_IMAGE:
2512                 return 0;
2513                 break;
2514         default: 
2515                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
2516                 return 0;
2517         }
2518
2519         return res;
2520 }
2521
2522 /*--- sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
2523         Basically update any ->owner links ----*/
2524 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
2525 {
2526         struct sip_pvt *p = newchan->tech_pvt;
2527         ast_mutex_lock(&p->lock);
2528         if (p->owner != oldchan) {
2529                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
2530                 ast_mutex_unlock(&p->lock);
2531                 return -1;
2532         }
2533         p->owner = newchan;
2534         ast_mutex_unlock(&p->lock);
2535         return 0;
2536 }
2537
2538 /*--- sip_senddigit: Send DTMF character on SIP channel */
2539 /*    within one call, we're able to transmit in many methods simultaneously */
2540 static int sip_senddigit(struct ast_channel *ast, char digit)
2541 {
2542         struct sip_pvt *p = ast->tech_pvt;
2543         int res = 0;
2544         ast_mutex_lock(&p->lock);
2545         switch (ast_test_flag(p, SIP_DTMF)) {
2546         case SIP_DTMF_INFO:
2547                 transmit_info_with_digit(p, digit);
2548                 break;
2549         case SIP_DTMF_RFC2833:
2550                 if (p->rtp)
2551                         ast_rtp_senddigit(p->rtp, digit);
2552                 break;
2553         case SIP_DTMF_INBAND:
2554                 res = -1;
2555                 break;
2556         }
2557         ast_mutex_unlock(&p->lock);
2558         return res;
2559 }
2560
2561 #define DEFAULT_MAX_FORWARDS    70
2562
2563
2564 /*--- sip_transfer: Transfer SIP call */
2565 static int sip_transfer(struct ast_channel *ast, const char *dest)
2566 {
2567         struct sip_pvt *p = ast->tech_pvt;
2568         int res;
2569
2570         ast_mutex_lock(&p->lock);
2571         if (ast->_state == AST_STATE_RING)
2572                 res = sip_sipredirect(p, dest);
2573         else
2574                 res = transmit_refer(p, dest);
2575         ast_mutex_unlock(&p->lock);
2576         return res;
2577 }
2578
2579 /*--- sip_indicate: Play indication to user */
2580 /* With SIP a lot of indications is sent as messages, letting the device play
2581    the indication - busy signal, congestion etc */
2582 static int sip_indicate(struct ast_channel *ast, int condition)
2583 {
2584         struct sip_pvt *p = ast->tech_pvt;
2585         int res = 0;
2586
2587         ast_mutex_lock(&p->lock);
2588         switch(condition) {
2589         case AST_CONTROL_RINGING:
2590                 if (ast->_state == AST_STATE_RING) {
2591                         if (!ast_test_flag(p, SIP_PROGRESS_SENT) ||
2592                             (ast_test_flag(p, SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
2593                                 /* Send 180 ringing if out-of-band seems reasonable */
2594                                 transmit_response(p, "180 Ringing", &p->initreq);
2595                                 ast_set_flag(p, SIP_RINGING);
2596                                 if (ast_test_flag(p, SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
2597                                         break;
2598                         } else {
2599                                 /* Well, if it's not reasonable, just send in-band */
2600                         }
2601                 }
2602                 res = -1;
2603                 break;
2604         case AST_CONTROL_BUSY:
2605                 if (ast->_state != AST_STATE_UP) {
2606                         transmit_response(p, "486 Busy Here", &p->initreq);
2607                         ast_set_flag(p, SIP_ALREADYGONE);       
2608                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2609                         break;
2610                 }
2611                 res = -1;
2612                 break;
2613         case AST_CONTROL_CONGESTION:
2614                 if (ast->_state != AST_STATE_UP) {
2615                         transmit_response(p, "503 Service Unavailable", &p->initreq);
2616                         ast_set_flag(p, SIP_ALREADYGONE);       
2617                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2618                         break;
2619                 }
2620                 res = -1;
2621                 break;
2622         case AST_CONTROL_PROGRESS:
2623         case AST_CONTROL_PROCEEDING:
2624                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2625                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2626                         ast_set_flag(p, SIP_PROGRESS_SENT);     
2627                         break;
2628                 }
2629                 res = -1;
2630                 break;
2631         case AST_CONTROL_HOLD:  /* The other part of the bridge are put on hold */
2632                 if (sipdebug)
2633                         ast_log(LOG_DEBUG, "Bridged channel now on hold%s\n", p->callid);
2634                 res = -1;
2635                 break;
2636         case AST_CONTROL_UNHOLD:        /* The other part of the bridge are back from hold */
2637                 if (sipdebug)
2638                         ast_log(LOG_DEBUG, "Bridged channel is back from hold, let's talk! : %s\n", p->callid);
2639                 res = -1;
2640                 break;
2641         case AST_CONTROL_VIDUPDATE:     /* Request a video frame update */
2642                 if (p->vrtp && !ast_test_flag(p, SIP_NOVIDEO)) {
2643                         transmit_info_with_vidupdate(p);
2644                         res = 0;
2645                 } else
2646                         res = -1;
2647                 break;
2648         case -1:
2649                 res = -1;
2650                 break;
2651         default:
2652                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
2653                 res = -1;
2654                 break;
2655         }
2656         ast_mutex_unlock(&p->lock);
2657         return res;
2658 }
2659
2660
2661
2662 /*--- sip_new: Initiate a call in the SIP channel */
2663 /*      called from sip_request_call (calls from the pbx ) */
2664 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
2665 {
2666         struct ast_channel *tmp;
2667         struct ast_variable *v = NULL;
2668         int fmt;
2669 #ifdef OSP_SUPPORT
2670         char iabuf[INET_ADDRSTRLEN];
2671         char peer[MAXHOSTNAMELEN];
2672 #endif  
2673         
2674         ast_mutex_unlock(&i->lock);
2675         /* Don't hold a sip pvt lock while we allocate a channel */
2676         tmp = ast_channel_alloc(1);
2677         ast_mutex_lock(&i->lock);
2678         if (!tmp) {
2679                 ast_log(LOG_WARNING, "Unable to allocate SIP channel structure\n");
2680                 return NULL;
2681         }
2682         tmp->tech = &sip_tech;
2683         /* Select our native format based on codec preference until we receive
2684            something from another device to the contrary. */
2685         ast_mutex_lock(&i->lock);
2686         if (i->jointcapability)
2687                 tmp->nativeformats = ast_codec_choose(&i->prefs, i->jointcapability, 1);
2688         else if (i->capability)
2689                 tmp->nativeformats = ast_codec_choose(&i->prefs, i->capability, 1);
2690         else
2691                 tmp->nativeformats = ast_codec_choose(&i->prefs, global_capability, 1);
2692         ast_mutex_unlock(&i->lock);
2693         fmt = ast_best_codec(tmp->nativeformats);
2694
2695         if (title)
2696                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
2697         else if (strchr(i->fromdomain,':'))
2698                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2699         else
2700                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2701
2702         tmp->type = channeltype;
2703         if (ast_test_flag(i, SIP_DTMF) ==  SIP_DTMF_INBAND) {
2704                 i->vad = ast_dsp_new();
2705                 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2706                 if (relaxdtmf)
2707                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2708         }
2709         if (i->rtp) {
2710                 tmp->fds[0] = ast_rtp_fd(i->rtp);
2711                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
2712         }
2713         if (i->vrtp) {
2714                 tmp->fds[2] = ast_rtp_fd(i->vrtp);
2715                 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2716         }
2717         if (state == AST_STATE_RING)
2718                 tmp->rings = 1;
2719         tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2720         tmp->writeformat = fmt;
2721         tmp->rawwriteformat = fmt;
2722         tmp->readformat = fmt;
2723         tmp->rawreadformat = fmt;
2724         tmp->tech_pvt = i;
2725
2726         tmp->callgroup = i->callgroup;
2727         tmp->pickupgroup = i->pickupgroup;
2728         tmp->cid.cid_pres = i->callingpres;
2729         if (!ast_strlen_zero(i->accountcode))
2730                 ast_copy_string(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode));
2731         if (i->amaflags)
2732                 tmp->amaflags = i->amaflags;
2733         if (!ast_strlen_zero(i->language))
2734                 ast_copy_string(tmp->language, i->language, sizeof(tmp->language));
2735         if (!ast_strlen_zero(i->musicclass))
2736                 ast_copy_string(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass));
2737         i->owner = tmp;
2738         ast_mutex_lock(&usecnt_lock);
2739         usecnt++;
2740         ast_mutex_unlock(&usecnt_lock);
2741         ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
2742         ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
2743         if (!ast_strlen_zero(i->cid_num)) 
2744                 tmp->cid.cid_num = strdup(i->cid_num);
2745         if (!ast_strlen_zero(i->cid_name))
2746                 tmp->cid.cid_name = strdup(i->cid_name);
2747         if (!ast_strlen_zero(i->rdnis))
2748                 tmp->cid.cid_rdnis = strdup(i->rdnis);
2749         if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2750                 tmp->cid.cid_dnid = strdup(i->exten);
2751         tmp->priority = 1;
2752         if (!ast_strlen_zero(i->uri)) {
2753                 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
2754         }
2755         if (!ast_strlen_zero(i->domain)) {
2756                 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2757         }
2758         if (!ast_strlen_zero(i->useragent)) {
2759                 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2760         }
2761         if (!ast_strlen_zero(i->callid)) {
2762                 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2763         }
2764 #ifdef OSP_SUPPORT
2765         snprintf(peer, sizeof(peer), "[%s]:%d", ast_inet_ntoa(iabuf, sizeof(iabuf), i->sa.sin_addr), ntohs(i->sa.sin_port));
2766         pbx_builtin_setvar_helper(tmp, "OSPPEER", peer);
2767 #endif
2768         ast_setstate(tmp, state);
2769         if (state != AST_STATE_DOWN) {
2770                 if (ast_pbx_start(tmp)) {
2771                         ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2772                         ast_hangup(tmp);
2773                         tmp = NULL;
2774                 }
2775         }
2776         /* Set channel variables for this call from configuration */
2777         for (v = i->chanvars ; v ; v = v->next)
2778                 pbx_builtin_setvar_helper(tmp,v->name,v->value);
2779                                 
2780         return tmp;
2781 }
2782
2783 /*--- get_sdp_by_line: Reads one line of SIP message body */
2784 static char* get_sdp_by_line(char* line, char *name, int nameLen)
2785 {
2786         if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2787                 return ast_skip_blanks(line + nameLen + 1);
2788         }
2789         return "";
2790 }
2791
2792 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2793    but the name wrongly applies _only_ sdp */
2794 static char *get_sdp(struct sip_request *req, char *name) 
2795 {
2796         int x;
2797         int len = strlen(name);
2798         char *r;
2799
2800         for (x=0; x<req->lines; x++) {
2801                 r = get_sdp_by_line(req->line[x], name, len);
2802                 if (r[0] != '\0')
2803                         return r;
2804         }
2805         return "";
2806 }
2807
2808
2809 static void sdpLineNum_iterator_init(int* iterator) 
2810 {
2811         *iterator = 0;
2812 }
2813
2814 static char* get_sdp_iterate(int* iterator,
2815                              struct sip_request *req, char *name)
2816 {
2817         int len = strlen(name);
2818         char *r;
2819
2820         while (*iterator < req->lines) {
2821                 r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2822                 if (r[0] != '\0')
2823                         return r;
2824         }
2825         return "";
2826 }
2827
2828 static char *find_alias(const char *name, char *_default)
2829 {
2830         int x;
2831         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++) 
2832                 if (!strcasecmp(aliases[x].fullname, name))
2833                         return aliases[x].shortname;
2834         return _default;
2835 }
2836
2837 static char *__get_header(struct sip_request *req, char *name, int *start)
2838 {
2839         int pass;
2840
2841         /*
2842          * Technically you can place arbitrary whitespace both before and after the ':' in
2843          * a header, although RFC3261 clearly says you shouldn't before, and place just
2844          * one afterwards.  If you shouldn't do it, what absolute idiot decided it was 
2845          * a good idea to say you can do it, and if you can do it, why in the hell would.
2846          * you say you shouldn't.
2847          * Anyways, pedanticsipchecking controls whether we allow spaces before ':',
2848          * and we always allow spaces after that for compatibility.
2849          */
2850         for (pass = 0; name && pass < 2;pass++) {
2851                 int x, len = strlen(name);
2852                 for (x=*start; x<req->headers; x++) {
2853                         if (!strncasecmp(req->header[x], name, len)) {
2854                                 char *r = req->header[x] + len; /* skip name */
2855                                 if (pedanticsipchecking)
2856                                         r = ast_skip_blanks(r);
2857
2858                                 if (*r == ':') {
2859                                         *start = x+1;
2860                                         return ast_skip_blanks(r+1);
2861                                 }
2862                         }
2863                 }
2864                 if (pass == 0) /* Try aliases */
2865                         name = find_alias(name, NULL);
2866         }
2867
2868         /* Don't return NULL, so get_header is always a valid pointer */
2869         return "";
2870 }
2871
2872 /*--- get_header: Get header from SIP request ---*/
2873 static char *get_header(struct sip_request *req, char *name)
2874 {
2875         int start = 0;
2876         return __get_header(req, name, &start);
2877 }
2878
2879 /*--- sip_rtp_read: Read RTP from network ---*/
2880 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2881 {
2882         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
2883         struct ast_frame *f;
2884         static struct ast_frame null_frame = { AST_FRAME_NULL, };
2885         
2886         if (!p->rtp) {
2887                 /* We have no RTP allocated for this channel */
2888                 return &null_frame;
2889         }
2890
2891         switch(ast->fdno) {
2892         case 0:
2893                 f = ast_rtp_read(p->rtp);       /* RTP Audio */
2894                 break;
2895         case 1:
2896                 f = ast_rtcp_read(p->rtp);      /* RTCP Control Channel */
2897                 break;
2898         case 2:
2899                 f = ast_rtp_read(p->vrtp);      /* RTP Video */
2900                 break;
2901         case 3:
2902                 f = ast_rtcp_read(p->vrtp);     /* RTCP Control Channel for video */
2903                 break;
2904         default:
2905                 f = &null_frame;
2906         }
2907         /* Don't forward RFC2833 if we're not supposed to */
2908         if (f && (f->frametype == AST_FRAME_DTMF) && (ast_test_flag(p, SIP_DTMF) != SIP_DTMF_RFC2833))
2909                 return &null_frame;
2910         if (p->owner) {
2911                 /* We already hold the channel lock */
2912                 if (f->frametype == AST_FRAME_VOICE) {
2913                         if (f->subclass != p->owner->nativeformats) {
2914                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2915                                 p->owner->nativeformats = f->subclass;
2916                                 ast_set_read_format(p->owner, p->owner->readformat);
2917                                 ast_set_write_format(p->owner, p->owner->writeformat);
2918                         }
2919                         if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
2920                                 f = ast_dsp_process(p->owner, p->vad, f);
2921                                 if (f && (f->frametype == AST_FRAME_DTMF)) 
2922                                         ast_log(LOG_DEBUG, "* Detected inband DTMF '%c'\n", f->subclass);
2923                         }
2924                 }
2925         }
2926         return f;
2927 }
2928
2929 /*--- sip_read: Read SIP RTP from channel */
2930 static struct ast_frame *sip_read(struct ast_channel *ast)
2931 {
2932         struct ast_frame *fr;
2933         struct sip_pvt *p = ast->tech_pvt;
2934         ast_mutex_lock(&p->lock);
2935         fr = sip_rtp_read(ast, p);
2936         time(&p->lastrtprx);
2937         ast_mutex_unlock(&p->lock);
2938         return fr;
2939 }
2940
2941 /*--- build_callid: Build SIP CALLID header ---*/
2942 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
2943 {
2944         int res;
2945         int val;
2946         int x;
2947         char iabuf[INET_ADDRSTRLEN];
2948         for (x=0; x<4; x++) {
2949                 val = rand();
2950                 res = snprintf(callid, len, "%08x", val);
2951                 len -= res;
2952                 callid += res;
2953         }
2954         if (!ast_strlen_zero(fromdomain))
2955                 snprintf(callid, len, "@%s", fromdomain);
2956         else
2957         /* It's not important that we really use our right IP here... */
2958                 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2959 }
2960
2961 static void make_our_tag(char *tagbuf, size_t len)
2962 {
2963         snprintf(tagbuf, len, "as%08x", rand());
2964 }
2965
2966 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2967 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method)
2968 {
2969         struct sip_pvt *p;
2970
2971         if (!(p = calloc(1, sizeof(*p))))
2972                 return NULL;
2973
2974         ast_mutex_init(&p->lock);
2975
2976         p->method = intended_method;
2977         p->initid = -1;
2978         p->autokillid = -1;
2979         p->subscribed = NONE;
2980         p->stateid = -1;
2981         p->prefs = prefs;
2982         if (intended_method != SIP_OPTIONS)     /* Peerpoke has it's own system */
2983                 p->timer_t1 = 500;      /* Default SIP retransmission timer T1 (RFC 3261) */
2984 #ifdef OSP_SUPPORT
2985         p->osphandle = -1;
2986         p->osptimelimit = 0;
2987 #endif  
2988         if (sin) {
2989                 memcpy(&p->sa, sin, sizeof(p->sa));
2990                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2991                         memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2992         } else {
2993                 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2994         }
2995
2996         p->branch = rand();     
2997         make_our_tag(p->tag, sizeof(p->tag));
2998         /* Start with 101 instead of 1 */
2999         p->ocseq = 101;
3000
3001         if (sip_methods[intended_method].need_rtp) {
3002                 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
3003                 if (videosupport)
3004                         p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
3005                 if (!p->rtp || (videosupport && !p->vrtp)) {
3006                         ast_log(LOG_WARNING, "Unable to create RTP audio %s session: %s\n", videosupport ? "and video" : "", strerror(errno));
3007                         ast_mutex_destroy(&p->lock);
3008                         if (p->chanvars) {
3009                                 ast_variables_destroy(p->chanvars);
3010                                 p->chanvars = NULL;
3011                         }
3012                         free(p);
3013                         return NULL;
3014                 }
3015                 ast_rtp_settos(p->rtp, tos);
3016                 if (p->vrtp)
3017                         ast_rtp_settos(p->vrtp, tos);
3018                 p->rtptimeout = global_rtptimeout;
3019                 p->rtpholdtimeout = global_rtpholdtimeout;
3020                 p->rtpkeepalive = global_rtpkeepalive;
3021         }
3022
3023         if (useglobal_nat && sin) {
3024                 /* Setup NAT structure according to global settings if we have an address */
3025                 ast_copy_flags(p, &global_flags, SIP_NAT);
3026                 memcpy(&p->recv, sin, sizeof(p->recv));
3027                 if (p->rtp)
3028                         ast_rtp_setnat(p->rtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
3029                 if (p->vrtp)
3030                         ast_rtp_setnat(p->vrtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
3031         }
3032
3033         if (p->method != SIP_REGISTER)
3034                 ast_copy_string(p->fromdomain, default_fromdomain, sizeof(p->fromdomain));
3035         build_via(p, p->via, sizeof(p->via));
3036         if (!callid)
3037                 build_callid(p->callid, sizeof(p->callid), p->ourip, p->fromdomain);
3038         else
3039                 ast_copy_string(p->callid, callid, sizeof(p->callid));
3040         ast_copy_flags(p, (&global_flags), SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_SENDRPID | SIP_DTMF | SIP_REINVITE | SIP_PROG_INBAND | SIP_OSPAUTH);
3041         /* Assign default music on hold class */
3042         strcpy(p->musicclass, global_musicclass);
3043         p->capability = global_capability;
3044         if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_RFC2833) || (ast_test_flag(p, SIP_DTMF) == SIP_DTMF_AUTO))
3045                 p->noncodeccapability |= AST_RTP_DTMF;
3046         strcpy(p->context, default_context);
3047
3048         /* Add to active dialog list */
3049         ast_mutex_lock(&iflock);
3050         p->next = iflist;
3051         iflist = p;
3052         ast_mutex_unlock(&iflock);
3053         if (option_debug)
3054                 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");
3055         return p;
3056 }
3057
3058 /*--- find_call: Connect incoming SIP message to current dialog or create new dialog structure */
3059 /*               Called by handle_request ,sipsock_read */
3060 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
3061 {
3062         struct sip_pvt *p;
3063         char *callid;
3064         char tmp[256];
3065         char *tag = "", *c;
3066
3067         callid = get_header(req, "Call-ID");
3068
3069         if (pedanticsipchecking) {
3070                 /* In principle Call-ID's uniquely identify a call, but with a forking SIP proxy
3071                    we need more to identify a branch - so we have to check branch, from
3072                    and to tags to identify a call leg.
3073                      For Asterisk to behave correctly, you need to turn on pedanticsipchecking
3074       &