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