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