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