don't try to reference through pvt if it is NULL (issue #5089)
[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         struct sip_invite_param *options;       /* Options for INVITE */
632 } *iflist = NULL;
633
634 #define FLAG_RESPONSE (1 << 0)
635 #define FLAG_FATAL (1 << 1)
636
637 /* sip packet - read in sipsock_read, transmitted in send_request */
638 struct sip_pkt {
639         struct sip_pkt *next;                   /* Next packet */
640         int retrans;                            /* Retransmission number */
641         int method;                             /* SIP method for this packet */
642         int seqno;                              /* Sequence number */
643         unsigned int flags;                     /* non-zero if this is a response packet (e.g. 200 OK) */
644         struct sip_pvt *owner;                  /* Owner call */
645         int retransid;                          /* Retransmission ID */
646         int timer_a;                            /* SIP timer A, retransmission timer */
647         int timer_t1;                           /* SIP Timer T1, estimated RTT or 500 ms */
648         int packetlen;                          /* Length of packet */
649         char data[0];
650 };      
651
652 /* Structure for SIP user data. User's place calls to us */
653 struct sip_user {
654         /* Users who can access various contexts */
655         ASTOBJ_COMPONENTS(struct sip_user);
656         char secret[80];                /* Password */
657         char md5secret[80];             /* Password in md5 */
658         char context[AST_MAX_CONTEXT];  /* Default context for incoming calls */
659         char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
660         char cid_num[80];               /* Caller ID num */
661         char cid_name[80];              /* Caller ID name */
662         char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
663         char language[MAX_LANGUAGE];    /* Default language for this user */
664         char musicclass[MAX_MUSICCLASS];/* Music on Hold class */
665         char useragent[256];            /* User agent in SIP request */
666         struct ast_codec_pref prefs;    /* codec prefs */
667         ast_group_t callgroup;          /* Call group */
668         ast_group_t pickupgroup;        /* Pickup Group */
669         unsigned int flags;             /* SIP flags */ 
670         unsigned int sipoptions;        /* Supported SIP options */
671         struct ast_flags flags_page2;   /* SIP_PAGE2 flags */
672         int amaflags;                   /* AMA flags for billing */
673         int callingpres;                /* Calling id presentation */
674         int capability;                 /* Codec capability */
675         int inUse;                      /* Number of calls in use */
676         int call_limit;                 /* Limit of concurrent calls */
677         int outUse;                     /* disabled */
678         struct ast_ha *ha;              /* ACL setting */
679         struct ast_variable *chanvars;  /* Variables to set for channel created by user */
680 };
681
682 /* Structure for SIP peer data, we place calls to peers if registred  or fixed IP address (host) */
683 struct sip_peer {
684         ASTOBJ_COMPONENTS(struct sip_peer);     /* name, refcount, objflags,  object pointers */
685                                         /* peer->name is the unique name of this object */
686         char secret[80];                /* Password */
687         char md5secret[80];             /* Password in MD5 */
688         struct sip_auth *auth;          /* Realm authentication list */
689         char context[AST_MAX_CONTEXT];  /* Default context for incoming calls */
690         char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
691         char username[80];              /* Temporary username until registration */ 
692         char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
693         int amaflags;                   /* AMA Flags (for billing) */
694         char tohost[MAXHOSTNAMELEN];    /* If not dynamic, IP address */
695         char regexten[AST_MAX_EXTENSION]; /* Extension to register (if regcontext is used) */
696         char fromuser[80];              /* From: user when calling this peer */
697         char fromdomain[MAXHOSTNAMELEN];        /* From: domain when calling this peer */
698         char fullcontact[256];          /* Contact registred with us (not in sip.conf) */
699         char cid_num[80];               /* Caller ID num */
700         char cid_name[80];              /* Caller ID name */
701         int callingpres;                /* Calling id presentation */
702         int inUse;                      /* Number of calls in use */
703         int call_limit;                 /* Limit of concurrent calls */
704         int outUse;                     /* disabled */
705         char vmexten[AST_MAX_EXTENSION];        /* Dialplan extension for MWI notify message*/
706         char mailbox[AST_MAX_EXTENSION]; /* Mailbox setting for MWI checks */
707         char language[MAX_LANGUAGE];    /* Default language for prompts */
708         char musicclass[MAX_MUSICCLASS];/* Music on Hold class */
709         char useragent[256];            /* User agent in SIP request (saved from registration) */
710         struct ast_codec_pref prefs;    /* codec prefs */
711         int lastmsgssent;
712         time_t  lastmsgcheck;           /* Last time we checked for MWI */
713         unsigned int flags;             /* SIP flags */ 
714         unsigned int sipoptions;        /* Supported SIP options */
715         struct ast_flags flags_page2;   /* SIP_PAGE2 flags */
716         int expire;                     /* When to expire this peer registration */
717         int expiry;                     /* Duration of registration */
718         int capability;                 /* Codec capability */
719         int rtptimeout;                 /* RTP timeout */
720         int rtpholdtimeout;             /* RTP Hold Timeout */
721         int rtpkeepalive;               /* Send RTP packets for keepalive */
722         ast_group_t callgroup;          /* Call group */
723         ast_group_t pickupgroup;        /* Pickup group */
724         struct ast_dnsmgr_entry *dnsmgr;/* DNS refresh manager for peer */
725         struct sockaddr_in addr;        /* IP address of peer */
726         struct in_addr mask;
727
728         /* Qualification */
729         struct sip_pvt *call;           /* Call pointer */
730         int pokeexpire;                 /* When to expire poke (qualify= checking) */
731         int lastms;                     /* How long last response took (in ms), or -1 for no response */
732         int maxms;                      /* Max ms we will accept for the host to be up, 0 to not monitor */
733         struct timeval ps;              /* Ping send time */
734         
735         struct sockaddr_in defaddr;     /* Default IP address, used until registration */
736         struct ast_ha *ha;              /* Access control list */
737         struct ast_variable *chanvars;  /* Variables to set for channel created by user */
738         int lastmsg;
739 };
740
741 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
742 static int sip_reloading = 0;
743
744 /* States for outbound registrations (with register= lines in sip.conf */
745 #define REG_STATE_UNREGISTERED          0
746 #define REG_STATE_REGSENT               1
747 #define REG_STATE_AUTHSENT              2
748 #define REG_STATE_REGISTERED            3
749 #define REG_STATE_REJECTED              4
750 #define REG_STATE_TIMEOUT               5
751 #define REG_STATE_NOAUTH                6
752 #define REG_STATE_FAILED                7
753
754
755 /* sip_registry: Registrations with other SIP proxies */
756 struct sip_registry {
757         ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
758         int portno;                     /* Optional port override */
759         char username[80];              /* Who we are registering as */
760         char authuser[80];              /* Who we *authenticate* as */
761         char hostname[MAXHOSTNAMELEN];  /* Domain or host we register to */
762         char secret[80];                /* Password or key name in []'s */      
763         char md5secret[80];
764         char contact[256];              /* Contact extension */
765         char random[80];
766         int expire;                     /* Sched ID of expiration */
767         int regattempts;                /* Number of attempts (since the last success) */
768         int timeout;                    /* sched id of sip_reg_timeout */
769         int refresh;                    /* How often to refresh */
770         struct sip_pvt *call;           /* create a sip_pvt structure for each outbound "registration call" in progress */
771         int regstate;                   /* Registration state (see above) */
772         int callid_valid;               /* 0 means we haven't chosen callid for this registry yet. */
773         char callid[80];                /* Global CallID for this registry */
774         unsigned int ocseq;             /* Sequence number we got to for REGISTERs for this registry */
775         struct sockaddr_in us;          /* Who the server thinks we are */
776         
777                                         /* Saved headers */
778         char realm[MAXHOSTNAMELEN];     /* Authorization realm */
779         char nonce[256];                /* Authorization nonce */
780         char domain[MAXHOSTNAMELEN];    /* Authorization domain */
781         char opaque[256];               /* Opaque nonsense */
782         char qop[80];                   /* Quality of Protection. */
783  
784         char lastmsg[256];              /* Last Message sent/received */
785 };
786
787 /*--- The user list: Users and friends ---*/
788 static struct ast_user_list {
789         ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
790 } userl;
791
792 /*--- The peer list: Peers and Friends ---*/
793 static struct ast_peer_list {
794         ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
795 } peerl;
796
797 /*--- The register list: Other SIP proxys we register with and call ---*/
798 static struct ast_register_list {
799         ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
800         int recheck;
801 } regl;
802
803
804 static int __sip_do_register(struct sip_registry *r);
805
806 static int sipsock  = -1;
807
808
809 static struct sockaddr_in bindaddr;
810 static struct sockaddr_in externip;
811 static char externhost[MAXHOSTNAMELEN] = "";
812 static time_t externexpire = 0;
813 static int externrefresh = 10;
814 static struct ast_ha *localaddr;
815
816 /* The list of manual NOTIFY types we know how to send */
817 struct ast_config *notify_types;
818
819 static struct sip_auth *authl;          /* Authentication list */
820
821
822 static struct ast_frame  *sip_read(struct ast_channel *ast);
823 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
824 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
825 static int transmit_response_with_unsupported(struct sip_pvt *p, char *msg, struct sip_request *req, char *unsupported);
826 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *rand, int reliable, char *header, int stale);
827 static int transmit_request(struct sip_pvt *p, int sipmethod, int inc, int reliable, int newbranch);
828 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int inc, int reliable, int newbranch);
829 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sendsdp, int init);
830 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
831 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
832 static int transmit_info_with_vidupdate(struct sip_pvt *p);
833 static int transmit_message_with_text(struct sip_pvt *p, const char *text);
834 static int transmit_refer(struct sip_pvt *p, const char *dest);
835 static int sip_sipredirect(struct sip_pvt *p, const char *dest);
836 static struct sip_peer *temp_peer(const char *name);
837 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, int sipmethod, int init);
838 static void free_old_route(struct sip_route *route);
839 static int build_reply_digest(struct sip_pvt *p, int method, char *digest, int digest_len);
840 static int update_call_counter(struct sip_pvt *fup, int event);
841 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int realtime);
842 static struct sip_user *build_user(const char *name, struct ast_variable *v, int realtime);
843 static int sip_do_reload(void);
844 static int expire_register(void *data);
845 static int callevents = 0;
846
847 static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause);
848 static int sip_devicestate(void *data);
849 static int sip_sendtext(struct ast_channel *ast, const char *text);
850 static int sip_call(struct ast_channel *ast, char *dest, int timeout);
851 static int sip_hangup(struct ast_channel *ast);
852 static int sip_answer(struct ast_channel *ast);
853 static struct ast_frame *sip_read(struct ast_channel *ast);
854 static int sip_write(struct ast_channel *ast, struct ast_frame *frame);
855 static int sip_indicate(struct ast_channel *ast, int condition);
856 static int sip_transfer(struct ast_channel *ast, const char *dest);
857 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
858 static int sip_senddigit(struct ast_channel *ast, char digit);
859 static int clear_realm_authentication(struct sip_auth *authlist);                            /* Clear realm authentication list (at reload) */
860 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno);   /* Add realm authentication in list */
861 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, char *realm);         /* Find authentication for a specific realm */
862 static void append_date(struct sip_request *req);       /* Append date to SIP packet */
863 static int determine_firstline_parts(struct sip_request *req);
864 static void sip_dump_history(struct sip_pvt *dialog);   /* Dump history to LOG_DEBUG at end of dialog, before destroying data */
865 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
866 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int substate);
867
868 /* Definition of this channel for channel registration */
869 static const struct ast_channel_tech sip_tech = {
870         .type = channeltype,
871         .description = "Session Initiation Protocol (SIP)",
872         .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
873         .properties = AST_CHAN_TP_WANTSJITTER,
874         .requester = sip_request_call,
875         .devicestate = sip_devicestate,
876         .call = sip_call,
877         .hangup = sip_hangup,
878         .answer = sip_answer,
879         .read = sip_read,
880         .write = sip_write,
881         .write_video = sip_write,
882         .indicate = sip_indicate,
883         .transfer = sip_transfer,
884         .fixup = sip_fixup,
885         .send_digit = sip_senddigit,
886         .bridge = ast_rtp_bridge,
887         .send_text = sip_sendtext,
888 };
889
890 /*--- find_sip_method: Find SIP method from header */
891 int find_sip_method(char *msg)
892 {
893         int i, res = 0;
894         
895         if (!msg || ast_strlen_zero(msg))
896                 return 0;
897
898         /* Strictly speaking, SIP methods are case SENSITIVE, but we don't check */
899         /* following Jon Postel's rule: Be gentle in what you accept, strict with what you send */
900         for (i = 1; (i < (sizeof(sip_methods) / sizeof(sip_methods[0]))) && !res; i++) {
901                 if (!strcasecmp(sip_methods[i].text, msg)) 
902                         res = sip_methods[i].id;
903         }
904         return res;
905 }
906
907 /*--- parse_sip_options: Parse supported header in incoming packet */
908 unsigned int parse_sip_options(struct sip_pvt *pvt, char *supported)
909 {
910         char *next = NULL;
911         char *sep = NULL;
912         char *temp = ast_strdupa(supported);
913         int i;
914         unsigned int profile = 0;
915
916         if (!supported || ast_strlen_zero(supported) )
917                 return 0;
918
919         if (option_debug > 2 && sipdebug)
920                 ast_log(LOG_DEBUG, "Begin: parsing SIP \"Supported: %s\"\n", supported);
921
922         next = temp;
923         while (next) {
924                 char res=0;
925                 if ( (sep = strchr(next, ',')) != NULL) {
926                         *sep = '\0';
927                         sep++;
928                 }
929                 while (*next == ' ')    /* Skip spaces */
930                         next++;
931                 if (option_debug > 2 && sipdebug)
932                         ast_log(LOG_DEBUG, "Found SIP option: -%s-\n", next);
933                 for (i=0; (i < (sizeof(sip_options) / sizeof(sip_options[0]))) && !res; i++) {
934                         if (!strcasecmp(next, sip_options[i].text)) {
935                                 profile |= sip_options[i].id;
936                                 res = 1;
937                                 if (option_debug > 2 && sipdebug)
938                                         ast_log(LOG_DEBUG, "Matched SIP option: %s\n", next);
939                         }
940                 }
941                 if (!res) 
942                         if (option_debug > 2 && sipdebug)
943                                 ast_log(LOG_DEBUG, "Found no match for SIP option: %s (Please file bug report!)\n", next);
944                 next = sep;
945         }
946         if (pvt) {
947                 pvt->sipoptions = profile;
948                 if (option_debug)
949                         ast_log(LOG_DEBUG, "* SIP extension value: %d for call %s\n", profile, pvt->callid);
950         }
951         return profile;
952 }
953
954 /*--- sip_debug_test_addr: See if we pass debug IP filter */
955 static inline int sip_debug_test_addr(struct sockaddr_in *addr) 
956 {
957         if (sipdebug == 0)
958                 return 0;
959         if (debugaddr.sin_addr.s_addr) {
960                 if (((ntohs(debugaddr.sin_port) != 0)
961                         && (debugaddr.sin_port != addr->sin_port))
962                         || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
963                         return 0;
964         }
965         return 1;
966 }
967
968 /*--- sip_debug_test_pvt: Test PVT for debugging output */
969 static inline int sip_debug_test_pvt(struct sip_pvt *p) 
970 {
971         if (sipdebug == 0)
972                 return 0;
973         return sip_debug_test_addr(((ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE) ? &p->recv : &p->sa));
974 }
975
976
977 /*--- __sip_xmit: Transmit SIP message ---*/
978 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
979 {
980         int res;
981         char iabuf[INET_ADDRSTRLEN];
982
983         if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
984                 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
985         else
986                 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
987         if (res != len) {
988                 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));
989         }
990         return res;
991 }
992
993 static void sip_destroy(struct sip_pvt *p);
994
995 /*--- build_via: Build a Via header for a request ---*/
996 static void build_via(struct sip_pvt *p, char *buf, int len)
997 {
998         char iabuf[INET_ADDRSTRLEN];
999
1000         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
1001         if (ast_test_flag(p, SIP_NAT) & SIP_NAT_RFC3581)
1002                 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x;rport", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
1003         else /* Work around buggy UNIDEN UIP200 firmware */
1004                 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
1005 }
1006
1007 /*--- ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
1008 /* Only used for outbound registrations */
1009 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
1010 {
1011         /*
1012          * Using the localaddr structure built up with localnet statements
1013          * apply it to their address to see if we need to substitute our
1014          * externip or can get away with our internal bindaddr
1015          */
1016         struct sockaddr_in theirs;
1017         theirs.sin_addr = *them;
1018         if (localaddr && externip.sin_addr.s_addr &&
1019            ast_apply_ha(localaddr, &theirs)) {
1020                 char iabuf[INET_ADDRSTRLEN];
1021                 if (externexpire && (time(NULL) >= externexpire)) {
1022                         struct ast_hostent ahp;
1023                         struct hostent *hp;
1024                         time(&externexpire);
1025                         externexpire += externrefresh;
1026                         if ((hp = ast_gethostbyname(externhost, &ahp))) {
1027                                 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
1028                         } else
1029                                 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
1030                 }
1031                 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
1032                 ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
1033                 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
1034         }
1035         else if (bindaddr.sin_addr.s_addr)
1036                 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
1037         else
1038                 return ast_ouraddrfor(them, us);
1039         return 0;
1040 }
1041
1042 /*--- append_history: Append to SIP dialog history */
1043 /*      Always returns 0 */
1044 static int append_history(struct sip_pvt *p, char *event, char *data)
1045 {
1046         struct sip_history *hist, *prev;
1047         char *c;
1048
1049         if (!recordhistory || !p)
1050                 return 0;
1051         if(!(hist = malloc(sizeof(struct sip_history)))) {
1052                 ast_log(LOG_WARNING, "Can't allocate memory for history");
1053                 return 0;
1054         }
1055         memset(hist, 0, sizeof(struct sip_history));
1056         snprintf(hist->event, sizeof(hist->event), "%-15s %s", event, data);
1057         /* Trim up nicely */
1058         c = hist->event;
1059         while(*c) {
1060                 if ((*c == '\r') || (*c == '\n')) {
1061                         *c = '\0';
1062                         break;
1063                 }
1064                 c++;
1065         }
1066         /* Enqueue into history */
1067         prev = p->history;
1068         if (prev) {
1069                 while(prev->next)
1070                         prev = prev->next;
1071                 prev->next = hist;
1072         } else {
1073                 p->history = hist;
1074         }
1075         return 0;
1076 }
1077
1078 /*--- retrans_pkt: Retransmit SIP message if no answer ---*/
1079 static int retrans_pkt(void *data)
1080 {
1081         struct sip_pkt *pkt=data, *prev, *cur = NULL;
1082         char iabuf[INET_ADDRSTRLEN];
1083         int reschedule = DEFAULT_RETRANS;
1084
1085         /* Lock channel */
1086         ast_mutex_lock(&pkt->owner->lock);
1087
1088         if (pkt->retrans < MAX_RETRANS) {
1089                 char buf[80];
1090
1091                 pkt->retrans++;
1092                 if (!pkt->timer_t1) {   /* Re-schedule using timer_a and timer_t1 */
1093                         if (sipdebug && option_debug > 3)
1094                                 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);
1095                 } else {
1096                         int siptimer_a;
1097
1098                         if (sipdebug && option_debug > 3)
1099                                 ast_log(LOG_DEBUG, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n", pkt->retransid, pkt->retrans, sip_methods[pkt->method].text, pkt->method);
1100                         if (!pkt->timer_a)
1101                                 pkt->timer_a = 2 ;
1102                         else
1103                                 pkt->timer_a = 2 * pkt->timer_a;
1104  
1105                         /* For non-invites, a maximum of 4 secs */
1106                         if (pkt->method != SIP_INVITE && pkt->timer_a > 4000)
1107                                 pkt->timer_a = 4000;
1108                         siptimer_a = pkt->timer_t1 * pkt->timer_a;      /* Double each time */
1109                 
1110                         /* Reschedule re-transmit */
1111                         reschedule = siptimer_a;
1112                         if (option_debug > 3)
1113                                 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);
1114                 } 
1115
1116                 if (pkt->owner && sip_debug_test_pvt(pkt->owner)) {
1117                         if (ast_test_flag(pkt->owner, SIP_NAT) & SIP_NAT_ROUTE)
1118                                 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);
1119                         else
1120                                 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);
1121                 }
1122                 snprintf(buf, sizeof(buf), "ReTx %d", reschedule);
1123
1124                 append_history(pkt->owner, buf, pkt->data);
1125                 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
1126                 ast_mutex_unlock(&pkt->owner->lock);
1127                 return  reschedule;
1128         } 
1129         /* Too many retries */
1130         if (pkt->owner && pkt->method != SIP_OPTIONS) {
1131                 if (ast_test_flag(pkt, FLAG_FATAL) || sipdebug) /* Tell us if it's critical or if we're debugging */
1132                         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");
1133         } else {
1134                 if (pkt->method == SIP_OPTIONS && sipdebug)
1135                         ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s) \n", pkt->owner->callid);
1136         }
1137         append_history(pkt->owner, "MaxRetries", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
1138                 
1139         pkt->retransid = -1;
1140
1141         if (ast_test_flag(pkt, FLAG_FATAL)) {
1142                 while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
1143                         ast_mutex_unlock(&pkt->owner->lock);
1144                         usleep(1);
1145                         ast_mutex_lock(&pkt->owner->lock);
1146                 }
1147                 if (pkt->owner->owner) {
1148                         ast_set_flag(pkt->owner, SIP_ALREADYGONE);
1149                         ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet.\n", pkt->owner->callid);
1150                         ast_queue_hangup(pkt->owner->owner);
1151                         ast_mutex_unlock(&pkt->owner->owner->lock);
1152                 } else {
1153                         /* If no channel owner, destroy now */
1154                         ast_set_flag(pkt->owner, SIP_NEEDDESTROY);      
1155                 }
1156         }
1157         /* In any case, go ahead and remove the packet */
1158         prev = NULL;
1159         cur = pkt->owner->packets;
1160         while(cur) {
1161                 if (cur == pkt)
1162                         break;
1163                 prev = cur;
1164                 cur = cur->next;
1165         }
1166         if (cur) {
1167                 if (prev)
1168                         prev->next = cur->next;
1169                 else
1170                         pkt->owner->packets = cur->next;
1171                 ast_mutex_unlock(&pkt->owner->lock);
1172                 free(cur);
1173                 pkt = NULL;
1174         } else
1175                 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
1176         if (pkt)
1177                 ast_mutex_unlock(&pkt->owner->lock);
1178         return 0;
1179 }
1180
1181 /*--- __sip_reliable_xmit: transmit packet with retransmits ---*/
1182 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod)
1183 {
1184         struct sip_pkt *pkt;
1185         int siptimer_a = DEFAULT_RETRANS;
1186
1187         pkt = malloc(sizeof(struct sip_pkt) + len + 1);
1188         if (!pkt)
1189                 return -1;
1190         memset(pkt, 0, sizeof(struct sip_pkt));
1191         memcpy(pkt->data, data, len);
1192         pkt->method = sipmethod;
1193         pkt->packetlen = len;
1194         pkt->next = p->packets;
1195         pkt->owner = p;
1196         pkt->seqno = seqno;
1197         pkt->flags = resp;
1198         pkt->data[len] = '\0';
1199         pkt->timer_t1 = p->timer_t1;    /* Set SIP timer T1 */
1200         if (fatal)
1201                 ast_set_flag(pkt, FLAG_FATAL);
1202         if (pkt->timer_t1)
1203                 siptimer_a = pkt->timer_t1 * 2;
1204
1205         /* Schedule retransmission */
1206         pkt->retransid = ast_sched_add_variable(sched, siptimer_a, retrans_pkt, pkt, 1);
1207         if (option_debug > 3 && sipdebug)
1208                 ast_log(LOG_DEBUG, "*** SIP TIMER: Initalizing retransmit timer on packet: Id  #%d\n", pkt->retransid);
1209         pkt->next = p->packets;
1210         p->packets = pkt;
1211
1212         __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);      /* Send packet */
1213         if (sipmethod == SIP_INVITE) {
1214                 /* Note this is a pending invite */
1215                 p->pendinginvite = seqno;
1216         }
1217         return 0;
1218 }
1219
1220 /*--- __sip_autodestruct: Kill a call (called by scheduler) ---*/
1221 static int __sip_autodestruct(void *data)
1222 {
1223         struct sip_pvt *p = data;
1224
1225         p->autokillid = -1;
1226
1227         /* If this is a subscription, tell the phone that we got a timeout */
1228         if (p->subscribed) {
1229                 p->subscribed = TIMEOUT;
1230                 transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1, 1);      /* Send first notification */
1231                 p->subscribed = NONE;
1232                 append_history(p, "Subscribestatus", "timeout");
1233                 return 10000;   /* Reschedule this destruction so that we know that it's gone */
1234         }
1235         ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
1236         append_history(p, "AutoDestroy", "");
1237         if (p->owner) {
1238                 ast_log(LOG_WARNING, "Autodestruct on call '%s' with owner in place\n", p->callid);
1239                 ast_queue_hangup(p->owner);
1240         } else {
1241                 sip_destroy(p);
1242         }
1243         return 0;
1244 }
1245
1246 /*--- sip_scheddestroy: Schedule destruction of SIP call ---*/
1247 static int sip_scheddestroy(struct sip_pvt *p, int ms)
1248 {
1249         char tmp[80];
1250         if (sip_debug_test_pvt(p))
1251                 ast_verbose("Scheduling destruction of call '%s' in %d ms\n", p->callid, ms);
1252         if (recordhistory) {
1253                 snprintf(tmp, sizeof(tmp), "%d ms", ms);
1254                 append_history(p, "SchedDestroy", tmp);
1255         }
1256
1257         if (p->autokillid > -1)
1258                 ast_sched_del(sched, p->autokillid);
1259         p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
1260         return 0;
1261 }
1262
1263 /*--- sip_cancel_destroy: Cancel destruction of SIP call ---*/
1264 static int sip_cancel_destroy(struct sip_pvt *p)
1265 {
1266         if (p->autokillid > -1)
1267                 ast_sched_del(sched, p->autokillid);
1268         append_history(p, "CancelDestroy", "");
1269         p->autokillid = -1;
1270         return 0;
1271 }
1272
1273 /*--- __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
1274 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
1275 {
1276         struct sip_pkt *cur, *prev = NULL;
1277         int res = -1;
1278         int resetinvite = 0;
1279         /* Just in case... */
1280         char *msg;
1281
1282         msg = sip_methods[sipmethod].text;
1283
1284         cur = p->packets;
1285         while(cur) {
1286                 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
1287                         ((ast_test_flag(cur, FLAG_RESPONSE)) || 
1288                          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
1289                         ast_mutex_lock(&p->lock);
1290                         if (!resp && (seqno == p->pendinginvite)) {
1291                                 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
1292                                 p->pendinginvite = 0;
1293                                 resetinvite = 1;
1294                         }
1295                         /* this is our baby */
1296                         if (prev)
1297                                 prev->next = cur->next;
1298                         else
1299                                 p->packets = cur->next;
1300                         if (cur->retransid > -1) {
1301                                 if (sipdebug && option_debug > 3)
1302                                         ast_log(LOG_DEBUG, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
1303                                 ast_sched_del(sched, cur->retransid);
1304                         }
1305                         free(cur);
1306                         ast_mutex_unlock(&p->lock);
1307                         res = 0;
1308                         break;
1309                 }
1310                 prev = cur;
1311                 cur = cur->next;
1312         }
1313         ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: Match %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
1314         return res;
1315 }
1316
1317 /* Pretend to ack all packets */
1318 static int __sip_pretend_ack(struct sip_pvt *p)
1319 {
1320         struct sip_pkt *cur=NULL;
1321
1322         while(p->packets) {
1323                 if (cur == p->packets) {
1324                         ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
1325                         return -1;
1326                 }
1327                 cur = p->packets;
1328                 if (cur->method)
1329                         __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), cur->method);
1330                 else {  /* Unknown packet type */
1331                         char *c;
1332                         char method[128]="";
1333                         ast_copy_string(method, p->packets->data, sizeof(method));
1334                         c = ast_skip_blanks(method); /* XXX what ? */
1335                         *c = '\0';
1336                         __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), find_sip_method(method));
1337                 }
1338         }
1339         return 0;
1340 }
1341
1342 /*--- __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
1343 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
1344 {
1345         struct sip_pkt *cur;
1346         int res = -1;
1347         char *msg = sip_methods[sipmethod].text;
1348
1349         cur = p->packets;
1350         while(cur) {
1351                 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
1352                         ((ast_test_flag(cur, FLAG_RESPONSE)) || 
1353                          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
1354                         /* this is our baby */
1355                         if (cur->retransid > -1) {
1356                                 if (option_debug > 3 && sipdebug)
1357                                         ast_log(LOG_DEBUG, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, msg);
1358                                 ast_sched_del(sched, cur->retransid);
1359                         }
1360                         cur->retransid = -1;
1361                         res = 0;
1362                         break;
1363                 }
1364                 cur = cur->next;
1365         }
1366         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");
1367         return res;
1368 }
1369
1370 static void parse_request(struct sip_request *req);
1371 static char *get_header(struct sip_request *req, char *name);
1372 static void copy_request(struct sip_request *dst,struct sip_request *src);
1373
1374 /*--- parse_copy: Copy SIP request, parse it */
1375 static void parse_copy(struct sip_request *dst, struct sip_request *src)
1376 {
1377         memset(dst, 0, sizeof(*dst));
1378         memcpy(dst->data, src->data, sizeof(dst->data));
1379         dst->len = src->len;
1380         parse_request(dst);
1381 }
1382
1383 /*--- send_response: Transmit response on SIP request---*/
1384 static int send_response(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
1385 {
1386         int res;
1387         char iabuf[INET_ADDRSTRLEN];
1388         struct sip_request tmp;
1389         char tmpmsg[80];
1390
1391         if (sip_debug_test_pvt(p)) {
1392                 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
1393                         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);
1394                 else
1395                         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);
1396         }
1397         if (reliable) {
1398                 if (recordhistory) {
1399                         parse_copy(&tmp, req);
1400                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1401                         append_history(p, "TxRespRel", tmpmsg);
1402                 }
1403                 res = __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable > 1), req->method);
1404         } else {
1405                 if (recordhistory) {
1406                         parse_copy(&tmp, req);
1407                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1408                         append_history(p, "TxResp", tmpmsg);
1409                 }
1410                 res = __sip_xmit(p, req->data, req->len);
1411         }
1412         if (res > 0)
1413                 return 0;
1414         return res;
1415 }
1416
1417 /*--- send_request: Send SIP Request to the other part of the dialogue ---*/
1418 static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
1419 {
1420         int res;
1421         char iabuf[INET_ADDRSTRLEN];
1422         struct sip_request tmp;
1423         char tmpmsg[80];
1424
1425         if (sip_debug_test_pvt(p)) {
1426                 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
1427                         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);
1428                 else
1429                         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);
1430         }
1431         if (reliable) {
1432                 if (recordhistory) {
1433                         parse_copy(&tmp, req);
1434                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1435                         append_history(p, "TxReqRel", tmpmsg);
1436                 }
1437                 res = __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1), req->method);
1438         } else {
1439                 if (recordhistory) {
1440                         parse_copy(&tmp, req);
1441                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1442                         append_history(p, "TxReq", tmpmsg);
1443                 }
1444                 res = __sip_xmit(p, req->data, req->len);
1445         }
1446         return res;
1447 }
1448
1449 /*--- get_in_brackets: Pick out text in brackets from character string ---*/
1450 /* returns pointer to terminated stripped string. modifies input string. */
1451 static char *get_in_brackets(char *tmp)
1452 {
1453         char *parse;
1454         char *first_quote;
1455         char *first_bracket;
1456         char *second_bracket;
1457         char last_char;
1458
1459         parse = tmp;
1460         while (1) {
1461                 first_quote = strchr(parse, '"');
1462                 first_bracket = strchr(parse, '<');
1463                 if (first_quote && first_bracket && (first_quote < first_bracket)) {
1464                         last_char = '\0';
1465                         for (parse = first_quote + 1; *parse; parse++) {
1466                                 if ((*parse == '"') && (last_char != '\\'))
1467                                         break;
1468                                 last_char = *parse;
1469                         }
1470                         if (!*parse) {
1471                                 ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
1472                                 return tmp;
1473                         }
1474                         parse++;
1475                         continue;
1476                 }
1477                 if (first_bracket) {
1478                         second_bracket = strchr(first_bracket + 1, '>');
1479                         if (second_bracket) {
1480                                 *second_bracket = '\0';
1481                                 return first_bracket + 1;
1482                         } else {
1483                                 ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
1484                                 return tmp;
1485                         }
1486                 }
1487                 return tmp;
1488         }
1489 }
1490
1491 /*--- sip_sendtext: Send SIP MESSAGE text within a call ---*/
1492 /*      Called from PBX core text message functions */
1493 static int sip_sendtext(struct ast_channel *ast, const char *text)
1494 {
1495         struct sip_pvt *p = ast->tech_pvt;
1496         int debug=sip_debug_test_pvt(p);
1497
1498         if (debug)
1499                 ast_verbose("Sending text %s on %s\n", text, ast->name);
1500         if (!p)
1501                 return -1;
1502         if (!text || ast_strlen_zero(text))
1503                 return 0;
1504         if (debug)
1505                 ast_verbose("Really sending text %s on %s\n", text, ast->name);
1506         transmit_message_with_text(p, text);
1507         return 0;       
1508 }
1509
1510 /*--- realtime_update_peer: Update peer object in realtime storage ---*/
1511 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, int expirey)
1512 {
1513         char port[10] = "";
1514         char ipaddr[20] = "";
1515         char regseconds[20] = "0";
1516         
1517         if (expirey) {  /* Registration */
1518                 time_t nowtime;
1519                 time(&nowtime);
1520                 nowtime += expirey;
1521                 snprintf(regseconds, sizeof(regseconds), "%ld", nowtime);       /* Expiration time */
1522                 ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
1523                 snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
1524         }
1525         ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, NULL);
1526 }
1527
1528 /*--- register_peer_exten: Automatically add peer extension to dial plan ---*/
1529 static void register_peer_exten(struct sip_peer *peer, int onoff)
1530 {
1531         char multi[256]="";
1532         char *stringp, *ext;
1533         if (!ast_strlen_zero(regcontext)) {
1534                 ast_copy_string(multi, ast_strlen_zero(peer->regexten) ? peer->name : peer->regexten, sizeof(multi));
1535                 stringp = multi;
1536                 while((ext = strsep(&stringp, "&"))) {
1537                         if (onoff)
1538                                 ast_add_extension(regcontext, 1, ext, 1, NULL, NULL, "Noop", strdup(peer->name), free, channeltype);
1539                         else
1540                                 ast_context_remove_extension(regcontext, ext, 1, NULL);
1541                 }
1542         }
1543 }
1544
1545 /*--- sip_destroy_peer: Destroy peer object from memory */
1546 static void sip_destroy_peer(struct sip_peer *peer)
1547 {
1548         /* Delete it, it needs to disappear */
1549         if (peer->call)
1550                 sip_destroy(peer->call);
1551         if (peer->chanvars) {
1552                 ast_variables_destroy(peer->chanvars);
1553                 peer->chanvars = NULL;
1554         }
1555         if (peer->expire > -1)
1556                 ast_sched_del(sched, peer->expire);
1557         if (peer->pokeexpire > -1)
1558                 ast_sched_del(sched, peer->pokeexpire);
1559         register_peer_exten(peer, 0);
1560         ast_free_ha(peer->ha);
1561         if (ast_test_flag(peer, SIP_SELFDESTRUCT))
1562                 apeerobjs--;
1563         else if (ast_test_flag(peer, SIP_REALTIME))
1564                 rpeerobjs--;
1565         else
1566                 speerobjs--;
1567         clear_realm_authentication(peer->auth);
1568         peer->auth = (struct sip_auth *) NULL;
1569         if (peer->dnsmgr)
1570                 ast_dnsmgr_release(peer->dnsmgr);
1571         free(peer);
1572 }
1573
1574 /*--- update_peer: Update peer data in database (if used) ---*/
1575 static void update_peer(struct sip_peer *p, int expiry)
1576 {
1577         if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTUPDATE) &&
1578                 (ast_test_flag(p, SIP_REALTIME) || 
1579                  ast_test_flag(&(p->flags_page2), SIP_PAGE2_RTCACHEFRIENDS))) {
1580                 realtime_update_peer(p->name, &p->addr, p->username, expiry);
1581         }
1582 }
1583
1584
1585 /*--- realtime_peer: Get peer from realtime storage ---*/
1586 /* Checks the "sippeers" realtime family from extconfig.conf */
1587 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1588 {
1589         struct sip_peer *peer=NULL;
1590         struct ast_variable *var;
1591         struct ast_variable *tmp;
1592         char *newpeername = (char *) peername;
1593         char iabuf[80] = "";
1594
1595         /* First check on peer name */
1596         if (newpeername) 
1597                 var = ast_load_realtime("sippeers", "name", peername, NULL);
1598         else if (sin) { /* Then check on IP address */
1599                 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
1600                 var = ast_load_realtime("sippeers", "ipaddr", iabuf, NULL);
1601         } else
1602                 return NULL;
1603
1604         if (!var)
1605                 return NULL;
1606
1607         tmp = var;
1608         /* If this is type=user, then skip this object. */
1609         while(tmp) {
1610                 if (!strcasecmp(tmp->name, "type") &&
1611                     !strcasecmp(tmp->value, "user")) {
1612                         ast_variables_destroy(var);
1613                         return NULL;
1614                 } else if (!newpeername && !strcasecmp(tmp->name, "name")) {
1615                         newpeername = tmp->value;
1616                 }
1617                 tmp = tmp->next;
1618         }
1619         
1620         if (!newpeername) {     /* Did not find peer in realtime */
1621                 ast_log(LOG_WARNING, "Cannot Determine peer name ip=%s\n", iabuf);
1622                 ast_variables_destroy(var);
1623                 return (struct sip_peer *) NULL;
1624         }
1625                 
1626         /* Peer found in realtime, now build it in memory */
1627         peer = build_peer(newpeername, var, !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS));
1628
1629         if (!peer) {
1630                 ast_variables_destroy(var);
1631                 return (struct sip_peer *) NULL;
1632         }
1633         if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1634                 /* Cache peer */
1635                 ast_copy_flags((&peer->flags_page2),(&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
1636                 if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR)) {
1637                         if (peer->expire > -1) {
1638                                 ast_sched_del(sched, peer->expire);
1639                         }
1640                         peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, (void *)peer);
1641                 }
1642                 ASTOBJ_CONTAINER_LINK(&peerl,peer);
1643         } else {
1644                 ast_set_flag(peer, SIP_REALTIME);
1645         }
1646         ast_variables_destroy(var);
1647         return peer;
1648 }
1649
1650 /*--- sip_addrcmp: Support routine for find_peer ---*/
1651 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
1652 {
1653         /* We know name is the first field, so we can cast */
1654         struct sip_peer *p = (struct sip_peer *)name;
1655         return  !(!inaddrcmp(&p->addr, sin) || 
1656                                         (ast_test_flag(p, SIP_INSECURE_PORT) &&
1657                                         (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
1658 }
1659
1660 /*--- find_peer: Locate peer by name or ip address */
1661 /*      This is used on incoming SIP message to find matching peer on ip
1662         or outgoing message to find matching peer on name */
1663 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
1664 {
1665         struct sip_peer *p = NULL;
1666
1667         if (peer)
1668                 p = ASTOBJ_CONTAINER_FIND(&peerl,peer);
1669         else
1670                 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl,sin,name,sip_addr_hashfunc,1,sip_addrcmp);
1671
1672         if (!p && realtime) {
1673                 p = realtime_peer(peer, sin);
1674         }
1675
1676         return p;
1677 }
1678
1679 /*--- sip_destroy_user: Remove user object from in-memory storage ---*/
1680 static void sip_destroy_user(struct sip_user *user)
1681 {
1682         ast_free_ha(user->ha);
1683         if (user->chanvars) {
1684                 ast_variables_destroy(user->chanvars);
1685                 user->chanvars = NULL;
1686         }
1687         if (ast_test_flag(user, SIP_REALTIME))
1688                 ruserobjs--;
1689         else
1690                 suserobjs--;
1691         free(user);
1692 }
1693
1694 /*--- realtime_user: Load user from realtime storage ---*/
1695 /* Loads user from "sipusers" category in realtime (extconfig.conf) */
1696 /* Users are matched on From: user name (the domain in skipped) */
1697 static struct sip_user *realtime_user(const char *username)
1698 {
1699         struct ast_variable *var;
1700         struct ast_variable *tmp;
1701         struct sip_user *user = NULL;
1702
1703         var = ast_load_realtime("sipusers", "name", username, NULL);
1704
1705         if (!var)
1706                 return NULL;
1707
1708         tmp = var;
1709         while (tmp) {
1710                 if (!strcasecmp(tmp->name, "type") &&
1711                         !strcasecmp(tmp->value, "peer")) {
1712                         ast_variables_destroy(var);
1713                         return NULL;
1714                 }
1715                 tmp = tmp->next;
1716         }
1717         
1718
1719
1720         user = build_user(username, var, !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS));
1721         
1722         if (!user) {    /* No user found */
1723                 ast_variables_destroy(var);
1724                 return NULL;
1725         }
1726
1727         if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1728                 ast_set_flag((&user->flags_page2), SIP_PAGE2_RTCACHEFRIENDS);
1729                 suserobjs++;
1730                 ASTOBJ_CONTAINER_LINK(&userl,user);
1731         } else {
1732                 /* Move counter from s to r... */
1733                 suserobjs--;
1734                 ruserobjs++;
1735                 ast_set_flag(user, SIP_REALTIME);
1736         }
1737         ast_variables_destroy(var);
1738         return user;
1739 }
1740
1741 /*--- find_user: Locate user by name ---*/
1742 /* Locates user by name (From: sip uri user name part) first
1743    from in-memory list (static configuration) then from 
1744    realtime storage (defined in extconfig.conf) */
1745 static struct sip_user *find_user(const char *name, int realtime)
1746 {
1747         struct sip_user *u = NULL;
1748         u = ASTOBJ_CONTAINER_FIND(&userl,name);
1749         if (!u && realtime) {
1750                 u = realtime_user(name);
1751         }
1752         return u;
1753 }
1754
1755 /*--- create_addr_from_peer: create address structure from peer reference ---*/
1756 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer)
1757 {
1758         char *callhost;
1759
1760         if ((peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr) &&
1761             (!peer->maxms || ((peer->lastms >= 0)  && (peer->lastms <= peer->maxms)))) {
1762                 if (peer->addr.sin_addr.s_addr) {
1763                         r->sa.sin_family = peer->addr.sin_family;
1764                         r->sa.sin_addr = peer->addr.sin_addr;
1765                         r->sa.sin_port = peer->addr.sin_port;
1766                 } else {
1767                         r->sa.sin_family = peer->defaddr.sin_family;
1768                         r->sa.sin_addr = peer->defaddr.sin_addr;
1769                         r->sa.sin_port = peer->defaddr.sin_port;
1770                 }
1771                 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1772         } else {
1773                 return -1;
1774         }
1775
1776         ast_copy_flags(r, peer,
1777                        SIP_PROMISCREDIR | SIP_USEREQPHONE | SIP_DTMF | SIP_NAT | SIP_REINVITE |
1778                        SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
1779         r->capability = peer->capability;
1780         if (r->rtp) {
1781                 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1782                 ast_rtp_setnat(r->rtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1783         }
1784         if (r->vrtp) {
1785                 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1786                 ast_rtp_setnat(r->vrtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1787         }
1788         ast_copy_string(r->peername, peer->username, sizeof(r->peername));
1789         ast_copy_string(r->authname, peer->username, sizeof(r->authname));
1790         ast_copy_string(r->username, peer->username, sizeof(r->username));
1791         ast_copy_string(r->peersecret, peer->secret, sizeof(r->peersecret));
1792         ast_copy_string(r->peermd5secret, peer->md5secret, sizeof(r->peermd5secret));
1793         ast_copy_string(r->tohost, peer->tohost, sizeof(r->tohost));
1794         ast_copy_string(r->fullcontact, peer->fullcontact, sizeof(r->fullcontact));
1795         if (!r->initreq.headers && !ast_strlen_zero(peer->fromdomain)) {
1796                 if ((callhost = strchr(r->callid, '@'))) {
1797                         strncpy(callhost + 1, peer->fromdomain, sizeof(r->callid) - (callhost - r->callid) - 2);
1798                 }
1799         }
1800         if (ast_strlen_zero(r->tohost)) {
1801                 if (peer->addr.sin_addr.s_addr)
1802                         ast_inet_ntoa(r->tohost, sizeof(r->tohost), peer->addr.sin_addr);
1803                 else
1804                         ast_inet_ntoa(r->tohost, sizeof(r->tohost), peer->defaddr.sin_addr);
1805         }
1806         if (!ast_strlen_zero(peer->fromdomain))
1807                 ast_copy_string(r->fromdomain, peer->fromdomain, sizeof(r->fromdomain));
1808         if (!ast_strlen_zero(peer->fromuser))
1809                 ast_copy_string(r->fromuser, peer->fromuser, sizeof(r->fromuser));
1810         r->maxtime = peer->maxms;
1811         r->callgroup = peer->callgroup;
1812         r->pickupgroup = peer->pickupgroup;
1813         /* Set timer T1 to RTT for this peer (if known by qualify=) */
1814         if (peer->maxms && peer->lastms)
1815                 r->timer_t1 = peer->lastms;
1816         if (ast_test_flag(r, SIP_DTMF) == SIP_DTMF_RFC2833)
1817                 r->noncodeccapability |= AST_RTP_DTMF;
1818         else
1819                 r->noncodeccapability &= ~AST_RTP_DTMF;
1820         ast_copy_string(r->context, peer->context,sizeof(r->context));
1821         r->rtptimeout = peer->rtptimeout;
1822         r->rtpholdtimeout = peer->rtpholdtimeout;
1823         r->rtpkeepalive = peer->rtpkeepalive;
1824         if (peer->call_limit)
1825                 ast_set_flag(r, SIP_CALL_LIMIT);
1826
1827         return 0;
1828 }
1829
1830 /*--- create_addr: create address structure from peer name ---*/
1831 /*      Or, if peer not found, find it in the global DNS */
1832 /*      returns TRUE (-1) on failure, FALSE on success */
1833 static int create_addr(struct sip_pvt *dialog, char *opeer)
1834 {
1835         struct hostent *hp;
1836         struct ast_hostent ahp;
1837         struct sip_peer *p;
1838         int found=0;
1839         char *port;
1840         int portno;
1841         char host[MAXHOSTNAMELEN], *hostn;
1842         char peer[256]="";
1843
1844         ast_copy_string(peer, opeer, sizeof(peer));
1845         port = strchr(peer, ':');
1846         if (port) {
1847                 *port = '\0';
1848                 port++;
1849         }
1850         dialog->sa.sin_family = AF_INET;
1851         dialog->timer_t1 = 500; /* Default SIP retransmission timer T1 (RFC 3261) */
1852         p = find_peer(peer, NULL, 1);
1853
1854         if (p) {
1855                 found++;
1856                 if (create_addr_from_peer(dialog, p))
1857                         ASTOBJ_UNREF(p, sip_destroy_peer);
1858         }
1859         if (!p) {
1860                 if (found)
1861                         return -1;
1862
1863                 hostn = peer;
1864                 if (port)
1865                         portno = atoi(port);
1866                 else
1867                         portno = DEFAULT_SIP_PORT;
1868                 if (srvlookup) {
1869                         char service[MAXHOSTNAMELEN];
1870                         int tportno;
1871                         int ret;
1872                         snprintf(service, sizeof(service), "_sip._udp.%s", peer);
1873                         ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
1874                         if (ret > 0) {
1875                                 hostn = host;
1876                                 portno = tportno;
1877                         }
1878                 }
1879                 hp = ast_gethostbyname(hostn, &ahp);
1880                 if (hp) {
1881                         ast_copy_string(dialog->tohost, peer, sizeof(dialog->tohost));
1882                         memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr));
1883                         dialog->sa.sin_port = htons(portno);
1884                         memcpy(&dialog->recv, &dialog->sa, sizeof(dialog->recv));
1885                         return 0;
1886                 } else {
1887                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
1888                         return -1;
1889                 }
1890         } else {
1891                 ASTOBJ_UNREF(p, sip_destroy_peer);
1892                 return 0;
1893         }
1894 }
1895
1896 /*--- auto_congest: Scheduled congestion on a call ---*/
1897 static int auto_congest(void *nothing)
1898 {
1899         struct sip_pvt *p = nothing;
1900         ast_mutex_lock(&p->lock);
1901         p->initid = -1;
1902         if (p->owner) {
1903                 if (!ast_mutex_trylock(&p->owner->lock)) {
1904                         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
1905                         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
1906                         ast_mutex_unlock(&p->owner->lock);
1907                 }
1908         }
1909         ast_mutex_unlock(&p->lock);
1910         return 0;
1911 }
1912
1913
1914
1915
1916 /*--- sip_call: Initiate SIP call from PBX ---*/
1917 /*      used from the dial() application      */
1918 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
1919 {
1920         int res;
1921         struct sip_pvt *p;
1922 #ifdef OSP_SUPPORT
1923         char *osphandle = NULL;
1924 #endif  
1925         struct varshead *headp;
1926         struct ast_var_t *current;
1927         
1928
1929         
1930         p = ast->tech_pvt;
1931         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1932                 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
1933                 return -1;
1934         }
1935
1936
1937         /* Check whether there is vxml_url, distinctive ring variables */
1938
1939         headp=&ast->varshead;
1940         AST_LIST_TRAVERSE(headp,current,entries) {
1941                 /* Check whether there is a VXML_URL variable */
1942                 if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
1943                         p->options->vxml_url = ast_var_value(current);
1944                 } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
1945                         /* Check whether there is a ALERT_INFO variable */
1946                         p->options->distinctive_ring = ast_var_value(current);
1947                 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
1948                         /* Check whether there is a variable with a name starting with SIPADDHEADER */
1949                         p->options->addsipheaders = 1;
1950                 }
1951
1952                 
1953 #ifdef OSP_SUPPORT
1954                 else if (!p->options->osptoken && !strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1955                         p->options->osptoken = ast_var_value(current);
1956                 } else if (!osphandle && !strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1957                         osphandle = ast_var_value(current);
1958                 }
1959 #endif
1960         }
1961         
1962         res = 0;
1963         ast_set_flag(p, SIP_OUTGOING);
1964 #ifdef OSP_SUPPORT
1965         if (!p->options->osptoken || !osphandle || (sscanf(osphandle, "%d", &p->osphandle) != 1)) {
1966                 /* Force Disable OSP support */
1967                 ast_log(LOG_DEBUG, "Disabling OSP support for this call. osptoken = %s, osphandle = %s\n", p->options->osptoken, osphandle);
1968                 p->options->osptoken = NULL;
1969                 osphandle = NULL;
1970                 p->osphandle = -1;
1971         }
1972 #endif
1973         ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
1974         res = update_call_counter(p, INC_CALL_LIMIT);
1975         if ( res != -1 ) {
1976                 p->callingpres = ast->cid.cid_pres;
1977                 p->jointcapability = p->capability;
1978                 transmit_invite(p, SIP_INVITE, 1, 1);
1979                 if (p->maxtime) {
1980                         /* Initialize auto-congest time */
1981                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
1982                 }
1983         }
1984         return res;
1985 }
1986
1987 /*--- sip_registry_destroy: Destroy registry object ---*/
1988 /*      Objects created with the register= statement in static configuration */
1989 static void sip_registry_destroy(struct sip_registry *reg)
1990 {
1991         /* Really delete */
1992         if (reg->call) {
1993                 /* Clear registry before destroying to ensure
1994                    we don't get reentered trying to grab the registry lock */
1995                 reg->call->registry = NULL;
1996                 sip_destroy(reg->call);
1997         }
1998         if (reg->expire > -1)
1999                 ast_sched_del(sched, reg->expire);
2000         if (reg->timeout > -1)
2001                 ast_sched_del(sched, reg->timeout);
2002         regobjs--;
2003         free(reg);
2004         
2005 }
2006
2007 /*---  __sip_destroy: Execute destrucion of call structure, release memory---*/
2008 static void __sip_destroy(struct sip_pvt *p, int lockowner)
2009 {
2010         struct sip_pvt *cur, *prev = NULL;
2011         struct sip_pkt *cp;
2012         struct sip_history *hist;
2013
2014         if (sip_debug_test_pvt(p))
2015                 ast_verbose("Destroying call '%s'\n", p->callid);
2016
2017         if (dumphistory)
2018                 sip_dump_history(p);
2019
2020         if (p->options)
2021                 free(p->options);
2022
2023         if (p->stateid > -1)
2024                 ast_extension_state_del(p->stateid, NULL);
2025         if (p->initid > -1)
2026                 ast_sched_del(sched, p->initid);
2027         if (p->autokillid > -1)
2028                 ast_sched_del(sched, p->autokillid);
2029
2030         if (p->rtp) {
2031                 ast_rtp_destroy(p->rtp);
2032         }
2033         if (p->vrtp) {
2034                 ast_rtp_destroy(p->vrtp);
2035         }
2036         if (p->route) {
2037                 free_old_route(p->route);
2038                 p->route = NULL;
2039         }
2040         if (p->registry) {
2041                 if (p->registry->call == p)
2042                         p->registry->call = NULL;
2043                 ASTOBJ_UNREF(p->registry,sip_registry_destroy);
2044         }
2045         /* Unlink us from the owner if we have one */
2046         if (p->owner) {
2047                 if (lockowner)
2048                         ast_mutex_lock(&p->owner->lock);
2049                 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
2050                 p->owner->tech_pvt = NULL;
2051                 if (lockowner)
2052                         ast_mutex_unlock(&p->owner->lock);
2053         }
2054         /* Clear history */
2055         while(p->history) {
2056                 hist = p->history;
2057                 p->history = p->history->next;
2058                 free(hist);
2059         }
2060
2061         cur = iflist;
2062         while(cur) {
2063                 if (cur == p) {
2064                         if (prev)
2065                                 prev->next = cur->next;
2066                         else
2067                                 iflist = cur->next;
2068                         break;
2069                 }
2070                 prev = cur;
2071                 cur = cur->next;
2072         }
2073         if (!cur) {
2074                 ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
2075                 return;
2076         } 
2077         if (p->initid > -1)
2078                 ast_sched_del(sched, p->initid);
2079
2080         while((cp = p->packets)) {
2081                 p->packets = p->packets->next;
2082                 if (cp->retransid > -1) {
2083                         ast_sched_del(sched, cp->retransid);
2084                 }
2085                 free(cp);
2086         }
2087         if (p->chanvars) {
2088                 ast_variables_destroy(p->chanvars);
2089                 p->chanvars = NULL;
2090         }
2091         ast_mutex_destroy(&p->lock);
2092         free(p);
2093 }
2094
2095 /*--- update_call_counter: Handle call_limit for SIP users ---*/
2096 /* Note: This is going to be replaced by app_groupcount */
2097 /* Thought: For realtime, we should propably update storage with inuse counter... */
2098 static int update_call_counter(struct sip_pvt *fup, int event)
2099 {
2100         char name[256] = "";
2101         int *inuse, *call_limit;
2102         int outgoing = ast_test_flag(fup, SIP_OUTGOING);
2103         struct sip_user *u = NULL;
2104         struct sip_peer *p = NULL;
2105
2106         if (option_debug > 2)
2107                 ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
2108         /* Test if we need to check call limits, in order to avoid 
2109            realtime lookups if we do not need it */
2110         if (!ast_test_flag(fup, SIP_CALL_LIMIT))
2111                 return 0;
2112
2113         ast_copy_string(name, fup->username, sizeof(name));
2114
2115         /* Check the list of users */
2116         u = find_user(name, 1);
2117         if (u) {
2118                 inuse = &u->inUse;
2119                 call_limit = &u->call_limit;
2120                 p = NULL;
2121         } else {
2122                 /* Try to find peer */
2123                 if (!p)
2124                         p = find_peer(fup->peername, NULL, 1);
2125                 if (p) {
2126                         inuse = &p->inUse;
2127                         call_limit = &p->call_limit;
2128                         ast_copy_string(name, fup->peername, sizeof(name));
2129                 } else {
2130                         if (option_debug > 1)
2131                                 ast_log(LOG_DEBUG, "%s is not a local user, no call limit\n", name);
2132                         return 0;
2133                 }
2134         }
2135         switch(event) {
2136                 /* incoming and outgoing affects the inUse counter */
2137                 case DEC_CALL_LIMIT:
2138                         if ( *inuse > 0 ) {
2139                                 (*inuse)--;
2140                         } else {
2141                                 *inuse = 0;
2142                         }
2143                         ast_log(LOG_ERROR, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
2144                         break;
2145                 case INC_CALL_LIMIT:
2146                         if (*call_limit > 0 ) {
2147                                 if (*inuse >= *call_limit) {
2148                                         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);
2149                                         /* inc inUse as well */
2150                                         if ( event == INC_CALL_LIMIT ) {
2151                                                 (*inuse)++;
2152                                         }
2153                                         if (u)
2154                                                 ASTOBJ_UNREF(u,sip_destroy_user);
2155                                         else
2156                                                 ASTOBJ_UNREF(p,sip_destroy_peer);
2157                                         return -1; 
2158                                 }
2159                         }
2160                         (*inuse)++;
2161                         ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
2162                         break;
2163                 default:
2164                         ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
2165         }
2166         if (u)
2167                 ASTOBJ_UNREF(u,sip_destroy_user);
2168         else
2169                 ASTOBJ_UNREF(p,sip_destroy_peer);
2170         return 0;
2171 }
2172
2173 /*--- sip_destroy: Destroy SIP call structure ---*/
2174 static void sip_destroy(struct sip_pvt *p)
2175 {
2176         ast_mutex_lock(&iflock);
2177         __sip_destroy(p, 1);
2178         ast_mutex_unlock(&iflock);
2179 }
2180
2181
2182 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
2183
2184 /*--- hangup_sip2cause: Convert SIP hangup causes to Asterisk hangup causes ---*/
2185 static int hangup_sip2cause(int cause)
2186 {
2187 /* Possible values taken from causes.h */
2188
2189         switch(cause) {
2190                 case 403:       /* Not found */
2191                         return AST_CAUSE_CALL_REJECTED;
2192                 case 404:       /* Not found */
2193                         return AST_CAUSE_UNALLOCATED;
2194                 case 408:       /* No reaction */
2195                         return AST_CAUSE_NO_USER_RESPONSE;
2196                 case 480:       /* No answer */
2197                         return AST_CAUSE_FAILURE;
2198                 case 483:       /* Too many hops */
2199                         return AST_CAUSE_NO_ANSWER;
2200                 case 486:       /* Busy everywhere */
2201                         return AST_CAUSE_BUSY;
2202                 case 488:       /* No codecs approved */
2203                         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2204                 case 500:       /* Server internal failure */
2205                         return AST_CAUSE_FAILURE;
2206                 case 501:       /* Call rejected */
2207                         return AST_CAUSE_FACILITY_REJECTED;
2208                 case 502:       
2209                         return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2210                 case 503:       /* Service unavailable */
2211                         return AST_CAUSE_CONGESTION;
2212                 default:
2213                         return AST_CAUSE_NORMAL;
2214         }
2215         /* Never reached */
2216         return 0;
2217 }
2218
2219
2220 /*--- hangup_cause2sip: Convert Asterisk hangup causes to SIP codes ---*/
2221 /* Possible values from causes.h
2222         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
2223         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
2224
2225         In addition to these, a lot of PRI codes is defined in causes.h 
2226         ...should we take care of them too ?
2227         
2228         Quote RFC 3398
2229
2230    ISUP Cause value                        SIP response
2231    ----------------                        ------------
2232    1  unallocated number                   404 Not Found
2233    2  no route to network                  404 Not found
2234    3  no route to destination              404 Not found
2235    16 normal call clearing                 --- (*)
2236    17 user busy                            486 Busy here
2237    18 no user responding                   408 Request Timeout
2238    19 no answer from the user              480 Temporarily unavailable
2239    20 subscriber absent                    480 Temporarily unavailable
2240    21 call rejected                        403 Forbidden (+)
2241    22 number changed (w/o diagnostic)      410 Gone
2242    22 number changed (w/ diagnostic)       301 Moved Permanently
2243    23 redirection to new destination       410 Gone
2244    26 non-selected user clearing           404 Not Found (=)
2245    27 destination out of order             502 Bad Gateway
2246    28 address incomplete                   484 Address incomplete
2247    29 facility rejected                    501 Not implemented
2248    31 normal unspecified                   480 Temporarily unavailable
2249 */
2250 static char *hangup_cause2sip(int cause)
2251 {
2252         switch(cause)
2253         {
2254                 case AST_CAUSE_UNALLOCATED:             /* 1 */
2255                 case AST_CAUSE_NO_ROUTE_DESTINATION:    /* 3 IAX2: Can't find extension in context */
2256                 case AST_CAUSE_NO_ROUTE_TRANSIT_NET:    /* 2 */
2257                         return "404 Not Found";
2258                 case AST_CAUSE_CONGESTION:              /* 34 */
2259                 case AST_CAUSE_SWITCH_CONGESTION:       /* 42 */
2260                         return "503 Service Unavailable";
2261                 case AST_CAUSE_NO_USER_RESPONSE:        /* 18 */
2262                         return "408 Request Timeout";
2263                 case AST_CAUSE_NO_ANSWER:               /* 19 */
2264                         return "480 Temporarily unavailable";
2265                 case AST_CAUSE_CALL_REJECTED:           /* 21 */
2266                         return "403 Forbidden";
2267                 case AST_CAUSE_NUMBER_CHANGED:          /* 22 */
2268                         return "410 Gone";
2269                 case AST_CAUSE_NORMAL_UNSPECIFIED:      /* 31 */
2270                         return "480 Temporarily unavailable";
2271                 case AST_CAUSE_INVALID_NUMBER_FORMAT:
2272                         return "484 Address incomplete";
2273                 case AST_CAUSE_USER_BUSY:
2274                         return "486 Busy here";
2275                 case AST_CAUSE_FAILURE:
2276                         return "500 Server internal failure";
2277                 case AST_CAUSE_FACILITY_REJECTED:       /* 29 */
2278                         return "501 Not Implemented";
2279                 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
2280                         return "503 Service Unavailable";
2281                 /* Used in chan_iax2 */
2282                 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
2283                         return "502 Bad Gateway";
2284                 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:       /* Can't find codec to connect to host */
2285                         return "488 Not Acceptable Here";
2286                         
2287                 case AST_CAUSE_NOTDEFINED:
2288                 default:
2289                         ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
2290                         return NULL;
2291         }
2292
2293         /* Never reached */
2294         return 0;
2295 }
2296
2297
2298 /*--- sip_hangup: Hangup SIP call ---*/
2299 /* Part of PBX interface */
2300 static int sip_hangup(struct ast_channel *ast)
2301 {
2302         struct sip_pvt *p = ast->tech_pvt;
2303         int needcancel = 0;
2304         struct ast_flags locflags = {0};
2305
2306         if (!p) {
2307                 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
2308                 return 0;
2309         }
2310         if (option_debug)
2311                 ast_log(LOG_DEBUG, "Hangup call %s, SIP callid %s)\n", ast->name, p->callid);
2312
2313         ast_mutex_lock(&p->lock);
2314 #ifdef OSP_SUPPORT
2315         if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
2316                 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
2317         }
2318 #endif  
2319         ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter\n", p->username);
2320         update_call_counter(p, DEC_CALL_LIMIT);
2321         /* Determine how to disconnect */
2322         if (p->owner != ast) {
2323                 ast_log(LOG_WARNING, "Huh?  We aren't the owner? Can't hangup call.\n");
2324                 ast_mutex_unlock(&p->lock);
2325                 return 0;
2326         }
2327         /* If the call is not UP, we need to send CANCEL instead of BYE */
2328         if (ast->_state != AST_STATE_UP)
2329                 needcancel = 1;
2330
2331         /* Disconnect */
2332         p = ast->tech_pvt;
2333         if (p->vad) {
2334                 ast_dsp_free(p->vad);
2335         }
2336         p->owner = NULL;
2337         ast->tech_pvt = NULL;
2338
2339         ast_mutex_lock(&usecnt_lock);
2340         usecnt--;
2341         ast_mutex_unlock(&usecnt_lock);
2342         ast_update_use_count();
2343
2344         ast_set_flag(&locflags, SIP_NEEDDESTROY);       
2345
2346         /* Start the process if it's not already started */
2347         if (!ast_test_flag(p, SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
2348                 if (needcancel) {       /* Outgoing call, not up */
2349                         if (ast_test_flag(p, SIP_OUTGOING)) {
2350                                 transmit_request_with_auth(p, SIP_CANCEL, p->ocseq, 1, 0);
2351                                 /* Actually don't destroy us yet, wait for the 487 on our original 
2352                                    INVITE, but do set an autodestruct just in case we never get it. */
2353                                 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
2354                                 sip_scheddestroy(p, 15000);
2355                                 /* stop retransmitting an INVITE that has not received a response */
2356                                 __sip_pretend_ack(p);
2357                                 if ( p->initid != -1 ) {
2358                                         /* channel still up - reverse dec of inUse counter
2359                                            only if the channel is not auto-congested */
2360                                         update_call_counter(p, INC_CALL_LIMIT);
2361                                 }
2362                         } else {        /* Incoming call, not up */
2363                                 char *res;
2364                                 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
2365                                         transmit_response_reliable(p, res, &p->initreq, 1);
2366                                 } else 
2367                                         transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
2368                         }
2369                 } else {        /* Call is in UP state, send BYE */
2370                         if (!p->pendinginvite) {
2371                                 /* Send a hangup */
2372                                 transmit_request_with_auth(p, SIP_BYE, 0, 1, 1);
2373                         } else {
2374                                 /* Note we will need a BYE when this all settles out
2375                                    but we can't send one while we have "INVITE" outstanding. */
2376                                 ast_set_flag(p, SIP_PENDINGBYE);        
2377                                 ast_clear_flag(p, SIP_NEEDREINVITE);    
2378                         }
2379                 }
2380         }
2381         ast_copy_flags(p, (&locflags), SIP_NEEDDESTROY);        
2382         ast_mutex_unlock(&p->lock);
2383         return 0;
2384 }
2385
2386 /*--- sip_answer: Answer SIP call , send 200 OK on Invite ---*/
2387 /* Part of PBX interface */
2388 static int sip_answer(struct ast_channel *ast)
2389 {
2390         int res = 0,fmt;
2391         char *codec;
2392         struct sip_pvt *p = ast->tech_pvt;
2393
2394         ast_mutex_lock(&p->lock);
2395         if (ast->_state != AST_STATE_UP) {
2396 #ifdef OSP_SUPPORT      
2397                 time(&p->ospstart);
2398 #endif
2399         
2400                 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
2401                 if (codec) {
2402                         fmt=ast_getformatbyname(codec);
2403                         if (fmt) {
2404                                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
2405                                 if (p->jointcapability & fmt) {
2406                                         p->jointcapability &= fmt;
2407                                         p->capability &= fmt;
2408                                 } else
2409                                         ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
2410                         } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
2411                 }
2412
2413                 ast_setstate(ast, AST_STATE_UP);
2414                 if (option_debug)
2415                         ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
2416                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
2417         }
2418         ast_mutex_unlock(&p->lock);
2419         return res;
2420 }
2421
2422 /*--- sip_write: Send frame to media channel (rtp) ---*/
2423 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
2424 {
2425         struct sip_pvt *p = ast->tech_pvt;
2426         int res = 0;
2427         switch (frame->frametype) {
2428         case AST_FRAME_VOICE:
2429                 if (!(frame->subclass & ast->nativeformats)) {
2430                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
2431                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
2432                         return 0;
2433                 }
2434                 if (p) {
2435                         ast_mutex_lock(&p->lock);
2436                         if (p->rtp) {
2437                                 /* If channel is not up, activate early media session */
2438                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2439                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2440                                         ast_set_flag(p, SIP_PROGRESS_SENT);     
2441                                 }
2442                                 time(&p->lastrtptx);
2443                                 res =  ast_rtp_write(p->rtp, frame);
2444                         }
2445                         ast_mutex_unlock(&p->lock);
2446                 }
2447                 break;
2448         case AST_FRAME_VIDEO:
2449                 if (p) {
2450                         ast_mutex_lock(&p->lock);
2451                         if (p->vrtp) {
2452                                 /* Activate video early media */
2453                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2454                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2455                                         ast_set_flag(p, SIP_PROGRESS_SENT);     
2456                                 }
2457                                 time(&p->lastrtptx);
2458                                 res =  ast_rtp_write(p->vrtp, frame);
2459                         }
2460                         ast_mutex_unlock(&p->lock);
2461                 }
2462                 break;
2463         case AST_FRAME_IMAGE:
2464                 return 0;
2465                 break;
2466         default: 
2467                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
2468                 return 0;
2469         }
2470
2471         return res;
2472 }
2473
2474 /*--- sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
2475         Basically update any ->owner links ----*/
2476 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
2477 {
2478         struct sip_pvt *p = newchan->tech_pvt;
2479         ast_mutex_lock(&p->lock);
2480         if (p->owner != oldchan) {
2481                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
2482                 ast_mutex_unlock(&p->lock);
2483                 return -1;
2484         }
2485         p->owner = newchan;
2486         ast_mutex_unlock(&p->lock);
2487         return 0;
2488 }
2489
2490 /*--- sip_senddigit: Send DTMF character on SIP channel */
2491 /*    within one call, we're able to transmit in many methods simultaneously */
2492 static int sip_senddigit(struct ast_channel *ast, char digit)
2493 {
2494         struct sip_pvt *p = ast->tech_pvt;
2495         int res = 0;
2496         ast_mutex_lock(&p->lock);
2497         switch (ast_test_flag(p, SIP_DTMF)) {
2498         case SIP_DTMF_INFO:
2499                 transmit_info_with_digit(p, digit);
2500                 break;
2501         case SIP_DTMF_RFC2833:
2502                 if (p->rtp)
2503                         ast_rtp_senddigit(p->rtp, digit);
2504                 break;
2505         case SIP_DTMF_INBAND:
2506                 res = -1;
2507                 break;
2508         }
2509         ast_mutex_unlock(&p->lock);
2510         return res;
2511 }
2512
2513 #define DEFAULT_MAX_FORWARDS    70
2514
2515
2516 /*--- sip_transfer: Transfer SIP call */
2517 static int sip_transfer(struct ast_channel *ast, const char *dest)
2518 {
2519         struct sip_pvt *p = ast->tech_pvt;
2520         int res;
2521
2522         ast_mutex_lock(&p->lock);
2523         if (ast->_state == AST_STATE_RING)
2524                 res = sip_sipredirect(p, dest);
2525         else
2526                 res = transmit_refer(p, dest);
2527         ast_mutex_unlock(&p->lock);
2528         return res;
2529 }
2530
2531 /*--- sip_indicate: Play indication to user */
2532 /* With SIP a lot of indications is sent as messages, letting the device play
2533    the indication - busy signal, congestion etc */
2534 static int sip_indicate(struct ast_channel *ast, int condition)
2535 {
2536         struct sip_pvt *p = ast->tech_pvt;
2537         int res = 0;
2538
2539         ast_mutex_lock(&p->lock);
2540         switch(condition) {
2541         case AST_CONTROL_RINGING:
2542                 if (ast->_state == AST_STATE_RING) {
2543                         if (!ast_test_flag(p, SIP_PROGRESS_SENT) ||
2544                             (ast_test_flag(p, SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
2545                                 /* Send 180 ringing if out-of-band seems reasonable */
2546                                 transmit_response(p, "180 Ringing", &p->initreq);
2547                                 ast_set_flag(p, SIP_RINGING);
2548                                 if (ast_test_flag(p, SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
2549                                         break;
2550                         } else {
2551                                 /* Well, if it's not reasonable, just send in-band */
2552                         }
2553                 }
2554                 res = -1;
2555                 break;
2556         case AST_CONTROL_BUSY:
2557                 if (ast->_state != AST_STATE_UP) {
2558                         transmit_response(p, "486 Busy Here", &p->initreq);
2559                         ast_set_flag(p, SIP_ALREADYGONE);       
2560                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2561                         break;
2562                 }
2563                 res = -1;
2564                 break;
2565         case AST_CONTROL_CONGESTION:
2566                 if (ast->_state != AST_STATE_UP) {
2567                         transmit_response(p, "503 Service Unavailable", &p->initreq);
2568                         ast_set_flag(p, SIP_ALREADYGONE);       
2569                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2570                         break;
2571                 }
2572                 res = -1;
2573                 break;
2574         case AST_CONTROL_PROGRESS:
2575         case AST_CONTROL_PROCEEDING:
2576                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2577                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2578                         ast_set_flag(p, SIP_PROGRESS_SENT);     
2579                         break;
2580                 }
2581                 res = -1;
2582                 break;
2583         case AST_CONTROL_HOLD:  /* The other part of the bridge are put on hold */
2584                 if (sipdebug)
2585                         ast_log(LOG_DEBUG, "Bridged channel now on hold%s\n", p->callid);
2586                 res = -1;
2587                 break;
2588         case AST_CONTROL_UNHOLD:        /* The other part of the bridge are back from hold */
2589                 if (sipdebug)
2590                         ast_log(LOG_DEBUG, "Bridged channel is back from hold, let's talk! : %s\n", p->callid);
2591                 res = -1;
2592                 break;
2593         case AST_CONTROL_VIDUPDATE:     /* Request a video frame update */
2594                 if (p->vrtp && !ast_test_flag(p, SIP_NOVIDEO)) {
2595                         transmit_info_with_vidupdate(p);
2596                         res = 0;
2597                 } else
2598                         res = -1;
2599                 break;
2600         case -1:
2601                 res = -1;
2602                 break;
2603         default:
2604                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
2605                 res = -1;
2606                 break;
2607         }
2608         ast_mutex_unlock(&p->lock);
2609         return res;
2610 }
2611
2612
2613
2614 /*--- sip_new: Initiate a call in the SIP channel */
2615 /*      called from sip_request_call (calls from the pbx ) */
2616 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
2617 {
2618         struct ast_channel *tmp;
2619         struct ast_variable *v = NULL;
2620         int fmt;
2621         
2622         ast_mutex_unlock(&i->lock);
2623         /* Don't hold a sip pvt lock while we allocate a channel */
2624         tmp = ast_channel_alloc(1);
2625         ast_mutex_lock(&i->lock);
2626         if (!tmp) {
2627                 ast_log(LOG_WARNING, "Unable to allocate SIP channel structure\n");
2628                 return NULL;
2629         }
2630         tmp->tech = &sip_tech;
2631         /* Select our native format based on codec preference until we receive
2632            something from another device to the contrary. */
2633         ast_mutex_lock(&i->lock);
2634         if (i->jointcapability)
2635                 tmp->nativeformats = ast_codec_choose(&i->prefs, i->jointcapability, 1);
2636         else if (i->capability)
2637                 tmp->nativeformats = ast_codec_choose(&i->prefs, i->capability, 1);
2638         else
2639                 tmp->nativeformats = ast_codec_choose(&i->prefs, global_capability, 1);
2640         ast_mutex_unlock(&i->lock);
2641         fmt = ast_best_codec(tmp->nativeformats);
2642
2643         if (title)
2644                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
2645         else if (strchr(i->fromdomain,':'))
2646                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2647         else
2648                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2649
2650         tmp->type = channeltype;
2651         if (ast_test_flag(i, SIP_DTMF) ==  SIP_DTMF_INBAND) {
2652                 i->vad = ast_dsp_new();
2653                 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2654                 if (relaxdtmf)
2655                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2656         }
2657         tmp->fds[0] = ast_rtp_fd(i->rtp);
2658         tmp->fds[1] = ast_rtcp_fd(i->rtp);
2659         if (i->vrtp) {
2660                 tmp->fds[2] = ast_rtp_fd(i->vrtp);
2661                 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2662         }
2663         if (state == AST_STATE_RING)
2664                 tmp->rings = 1;
2665         tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2666         tmp->writeformat = fmt;
2667         tmp->rawwriteformat = fmt;
2668         tmp->readformat = fmt;
2669         tmp->rawreadformat = fmt;
2670         tmp->tech_pvt = i;
2671
2672         tmp->callgroup = i->callgroup;
2673         tmp->pickupgroup = i->pickupgroup;
2674         tmp->cid.cid_pres = i->callingpres;
2675         if (!ast_strlen_zero(i->accountcode))
2676                 ast_copy_string(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode));
2677         if (i->amaflags)
2678                 tmp->amaflags = i->amaflags;
2679         if (!ast_strlen_zero(i->language))
2680                 ast_copy_string(tmp->language, i->language, sizeof(tmp->language));
2681         if (!ast_strlen_zero(i->musicclass))
2682                 ast_copy_string(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass));
2683         i->owner = tmp;
2684         ast_mutex_lock(&usecnt_lock);
2685         usecnt++;
2686         ast_mutex_unlock(&usecnt_lock);
2687         ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
2688         ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
2689         if (!ast_strlen_zero(i->cid_num)) 
2690                 tmp->cid.cid_num = strdup(i->cid_num);
2691         if (!ast_strlen_zero(i->cid_name))
2692                 tmp->cid.cid_name = strdup(i->cid_name);
2693         if (!ast_strlen_zero(i->rdnis))
2694                 tmp->cid.cid_rdnis = strdup(i->rdnis);
2695         if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2696                 tmp->cid.cid_dnid = strdup(i->exten);
2697         tmp->priority = 1;
2698         if (!ast_strlen_zero(i->uri)) {
2699                 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
2700         }
2701         if (!ast_strlen_zero(i->domain)) {
2702                 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2703         }
2704         if (!ast_strlen_zero(i->useragent)) {
2705                 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2706         }
2707         if (!ast_strlen_zero(i->callid)) {
2708                 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2709         }
2710         ast_setstate(tmp, state);
2711         if (state != AST_STATE_DOWN) {
2712                 if (ast_pbx_start(tmp)) {
2713                         ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2714                         ast_hangup(tmp);
2715                         tmp = NULL;
2716                 }
2717         }
2718         /* Set channel variables for this call from configuration */
2719         for (v = i->chanvars ; v ; v = v->next)
2720                 pbx_builtin_setvar_helper(tmp,v->name,v->value);
2721                                 
2722         return tmp;
2723 }
2724
2725 /*--- get_sdp_by_line: Reads one line of SIP message body */
2726 static char* get_sdp_by_line(char* line, char *name, int nameLen)
2727 {
2728         if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2729                 return ast_skip_blanks(line + nameLen + 1);
2730         }
2731         return "";
2732 }
2733
2734 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2735    but the name wrongly applies _only_ sdp */
2736 static char *get_sdp(struct sip_request *req, char *name) 
2737 {
2738         int x;
2739         int len = strlen(name);
2740         char *r;
2741
2742         for (x=0; x<req->lines; x++) {
2743                 r = get_sdp_by_line(req->line[x], name, len);
2744                 if (r[0] != '\0')
2745                         return r;
2746         }
2747         return "";
2748 }
2749
2750
2751 static void sdpLineNum_iterator_init(int* iterator) 
2752 {
2753         *iterator = 0;
2754 }
2755
2756 static char* get_sdp_iterate(int* iterator,
2757                              struct sip_request *req, char *name)
2758 {
2759         int len = strlen(name);
2760         char *r;
2761
2762         while (*iterator < req->lines) {
2763                 r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2764                 if (r[0] != '\0')
2765                         return r;
2766         }
2767         return "";
2768 }
2769
2770 static char *find_alias(const char *name, char *_default)
2771 {
2772         int x;
2773         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++) 
2774                 if (!strcasecmp(aliases[x].fullname, name))
2775                         return aliases[x].shortname;
2776         return _default;
2777 }
2778
2779 static char *__get_header(struct sip_request *req, char *name, int *start)
2780 {
2781         int pass;
2782
2783         /*
2784          * Technically you can place arbitrary whitespace both before and after the ':' in
2785          * a header, although RFC3261 clearly says you shouldn't before, and place just
2786          * one afterwards.  If you shouldn't do it, what absolute idiot decided it was 
2787          * a good idea to say you can do it, and if you can do it, why in the hell would.
2788          * you say you shouldn't.
2789          * Anyways, pedanticsipchecking controls whether we allow spaces before ':',
2790          * and we always allow spaces after that for compatibility.
2791          */
2792         for (pass = 0; name && pass < 2;pass++) {
2793                 int x, len = strlen(name);
2794                 for (x=*start; x<req->headers; x++) {
2795                         if (!strncasecmp(req->header[x], name, len)) {
2796                                 char *r = req->header[x] + len; /* skip name */
2797                                 if (pedanticsipchecking)
2798                                         r = ast_skip_blanks(r);
2799
2800                                 if (*r == ':') {
2801                                         *start = x+1;
2802                                         return ast_skip_blanks(r+1);
2803                                 }
2804                         }
2805                 }
2806                 if (pass == 0) /* Try aliases */
2807                         name = find_alias(name, NULL);
2808         }
2809
2810         /* Don't return NULL, so get_header is always a valid pointer */
2811         return "";
2812 }
2813
2814 /*--- get_header: Get header from SIP request ---*/
2815 static char *get_header(struct sip_request *req, char *name)
2816 {
2817         int start = 0;
2818         return __get_header(req, name, &start);
2819 }
2820
2821 /*--- sip_rtp_read: Read RTP from network ---*/
2822 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2823 {
2824         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
2825         struct ast_frame *f;
2826         static struct ast_frame null_frame = { AST_FRAME_NULL, };
2827         switch(ast->fdno) {
2828         case 0:
2829                 f = ast_rtp_read(p->rtp);       /* RTP Audio */
2830                 break;
2831         case 1:
2832                 f = ast_rtcp_read(p->rtp);      /* RTCP Control Channel */
2833                 break;
2834         case 2:
2835                 f = ast_rtp_read(p->vrtp);      /* RTP Video */
2836                 break;
2837         case 3:
2838                 f = ast_rtcp_read(p->vrtp);     /* RTCP Control Channel for video */
2839                 break;
2840         default:
2841                 f = &null_frame;
2842         }
2843         /* Don't forward RFC2833 if we're not supposed to */
2844         if (f && (f->frametype == AST_FRAME_DTMF) && (ast_test_flag(p, SIP_DTMF) != SIP_DTMF_RFC2833))
2845                 return &null_frame;
2846         if (p->owner) {
2847                 /* We already hold the channel lock */
2848                 if (f->frametype == AST_FRAME_VOICE) {
2849                         if (f->subclass != p->owner->nativeformats) {
2850                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2851                                 p->owner->nativeformats = f->subclass;
2852                                 ast_set_read_format(p->owner, p->owner->readformat);
2853                                 ast_set_write_format(p->owner, p->owner->writeformat);
2854                         }
2855                         if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
2856                                 f = ast_dsp_process(p->owner, p->vad, f);
2857                                 if (f && (f->frametype == AST_FRAME_DTMF)) 
2858                                         ast_log(LOG_DEBUG, "* Detected inband DTMF '%c'\n", f->subclass);
2859                         }
2860                 }
2861         }
2862         return f;
2863 }
2864
2865 /*--- sip_read: Read SIP RTP from channel */
2866 static struct ast_frame *sip_read(struct ast_channel *ast)
2867 {
2868         struct ast_frame *fr;
2869         struct sip_pvt *p = ast->tech_pvt;
2870         ast_mutex_lock(&p->lock);
2871         fr = sip_rtp_read(ast, p);
2872         time(&p->lastrtprx);
2873         ast_mutex_unlock(&p->lock);
2874         return fr;
2875 }
2876
2877 /*--- build_callid: Build SIP CALLID header ---*/
2878 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
2879 {
2880         int res;
2881         int val;
2882         int x;
2883         char iabuf[INET_ADDRSTRLEN];
2884         for (x=0; x<4; x++) {
2885                 val = rand();
2886                 res = snprintf(callid, len, "%08x", val);
2887                 len -= res;
2888                 callid += res;
2889         }
2890         if (!ast_strlen_zero(fromdomain))
2891                 snprintf(callid, len, "@%s", fromdomain);
2892         else
2893         /* It's not important that we really use our right IP here... */
2894                 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2895 }
2896
2897 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2898 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method)
2899 {
2900         struct sip_pvt *p;
2901
2902         p = malloc(sizeof(struct sip_pvt));
2903         if (!p)
2904                 return NULL;
2905         /* Keep track of stuff */
2906         memset(p, 0, sizeof(struct sip_pvt));
2907         ast_mutex_init(&p->lock);
2908
2909         p->method = intended_method;
2910         p->initid = -1;
2911         p->autokillid = -1;
2912         p->subscribed = NONE;
2913         p->stateid = -1;
2914         p->prefs = prefs;
2915         if (intended_method != SIP_OPTIONS)     /* Peerpoke has it's own system */
2916                 p->timer_t1 = 500;      /* Default SIP retransmission timer T1 (RFC 3261) */
2917 #ifdef OSP_SUPPORT
2918         p->osphandle = -1;
2919 #endif  
2920         if (sin) {
2921                 memcpy(&p->sa, sin, sizeof(p->sa));
2922                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2923                         memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2924         } else {
2925                 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2926         }
2927
2928         p->branch = rand();     
2929         p->tag = rand();
2930         /* Start with 101 instead of 1 */
2931         p->ocseq = 101;
2932
2933         if (sip_methods[intended_method].need_rtp) {
2934                 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2935                 if (videosupport)
2936                         p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2937                 if (!p->rtp) {
2938                         ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
2939                         ast_mutex_destroy(&p->lock);
2940                         if (p->chanvars) {
2941                                 ast_variables_destroy(p->chanvars);
2942                                 p->chanvars = NULL;
2943                         }
2944                         free(p);
2945                         return NULL;
2946                 }
2947                 ast_rtp_settos(p->rtp, tos);
2948                 if (p->vrtp)
2949                         ast_rtp_settos(p->vrtp, tos);
2950                 p->rtptimeout = global_rtptimeout;
2951                 p->rtpholdtimeout = global_rtpholdtimeout;
2952                 p->rtpkeepalive = global_rtpkeepalive;
2953         }
2954
2955         if (useglobal_nat && sin) {
2956                 /* Setup NAT structure according to global settings if we have an address */
2957                 ast_copy_flags(p, &global_flags, SIP_NAT);
2958                 memcpy(&p->recv, sin, sizeof(p->recv));
2959                 if (p->rtp)
2960                         ast_rtp_setnat(p->rtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2961                 if (p->vrtp)
2962                         ast_rtp_setnat(p->vrtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2963         }
2964
2965         if (p->method != SIP_REGISTER)
2966                 ast_copy_string(p->fromdomain, default_fromdomain, sizeof(p->fromdomain));
2967         build_via(p, p->via, sizeof(p->via));
2968         if (!callid)
2969                 build_callid(p->callid, sizeof(p->callid), p->ourip, p->fromdomain);
2970         else
2971                 ast_copy_string(p->callid, callid, sizeof(p->callid));
2972         ast_copy_flags(p, (&global_flags), SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_DTMF | SIP_REINVITE | SIP_PROG_INBAND | SIP_OSPAUTH);
2973         /* Assign default music on hold class */
2974         strcpy(p->musicclass, global_musicclass);
2975         p->capability = global_capability;
2976         if (ast_test_flag(p, SIP_DTMF) == SIP_DTMF_RFC2833)
2977                 p->noncodeccapability |= AST_RTP_DTMF;
2978         strcpy(p->context, default_context);
2979
2980         /* Add to active dialog list */
2981         ast_mutex_lock(&iflock);
2982         p->next = iflist;
2983         iflist = p;
2984         ast_mutex_unlock(&iflock);
2985         if (option_debug)
2986                 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");
2987         return p;
2988 }
2989
2990 /*--- find_call: Connect incoming SIP message to current dialog or create new dialog structure */
2991 /*               Called by handle_request ,sipsock_read */
2992 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
2993 {
2994         struct sip_pvt *p;
2995         char *callid;
2996         char tmp[256] = "";
2997         char *tag = "", *c;
2998
2999         callid = get_header(req, "Call-ID");
3000
3001         if (pedanticsipchecking) {
3002                 /* In principle Call-ID's uniquely identify a call, but with a forking SIP proxy
3003                    we need more to identify a branch - so we have to check branch, from
3004                    and to tags to identify a call leg.
3005                      For Asterisk to behave correctly, you need to turn on pedanticsipchecking
3006                    in sip.conf
3007                    */
3008                 if (req->method == SIP_RESPONSE)
3009                         ast_copy_string(tmp, get_header(req, "To"), sizeof(tmp));
3010                 else
3011                         ast_copy_string(tmp, get_header(req, "From"), sizeof(tmp));
3012                 tag = strcasestr(tmp, "tag=");
3013                 if (tag) {
3014                         tag += 4;
3015                         c = strchr(tag, ';');
3016                         if (c)
3017                                 *c = '\0';
3018                 }
3019                         
3020         }
3021                 
3022         ast_mutex_lock(&iflock);
3023         p = iflist;
3024         while(p) {
3025                 int found = 0;
3026                 if (req->method == SIP_REGISTER)
3027                         found = (!strcmp(p->callid, callid));
3028                 else 
3029                         found = (!strcmp(p->callid, callid) && 
3030                         (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) ;
3031                 if (found) {
3032                         /* Found the call */
3033                         ast_mutex_lock(&p->lock);
3034                         ast_mutex_unlock(&iflock);
3035                         return p;
3036                 }
3037                 p = p->next;
3038         }
3039         ast_mutex_unlock(&iflock);
3040         p = sip_alloc(callid, sin, 1, intended_method);
3041         if (p)
3042                 ast_mutex_lock(&p->lock);
3043         return p;
3044 }
3045
3046 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
3047 static int sip_register(char *value, int lineno)
3048 {
3049         struct sip_registry *reg;
3050         char copy[256] = "";
3051         char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
3052         char *porta=NULL;
3053         char *contact=NULL;
3054         char *stringp=NULL;
3055         
3056         if (!value)
3057                 return -1;
3058         ast_copy_string(copy, value, sizeof(copy));
3059         stringp=copy;
3060         username = stringp;
3061         hostname = strrchr(stringp, '@');
3062         if (hostname) {
3063                 *hostname = '\0';
3064                 hostname++;
3065         }
3066         if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {