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