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