factor out INVITE response handling in its own function (issue #5127)
[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 *uri_options;
446         char *vxml_url;
447         char *auth;
448         char *authheader;
449 };
450
451 struct sip_route {
452         struct sip_route *next;
453         char hop[0];
454 };
455
456 /* sip_history: Structure for saving transactions within a SIP dialog */
457 struct sip_history {
458         char event[80];
459         struct sip_history *next;
460 };
461
462 /* sip_auth: Creadentials for authentication to other SIP services */
463 struct sip_auth {
464         char realm[AST_MAX_EXTENSION];  /* Realm in which these credentials are valid */
465         char username[256];             /* Username */
466         char secret[256];               /* Secret */
467         char md5secret[256];            /* MD5Secret */
468         struct sip_auth *next;          /* Next auth structure in list */
469 };
470
471 #define SIP_ALREADYGONE         (1 << 0)        /* Whether or not we've already been destroyed by our peer */
472 #define SIP_NEEDDESTROY         (1 << 1)        /* if we need to be destroyed */
473 #define SIP_NOVIDEO             (1 << 2)        /* Didn't get video in invite, don't offer */
474 #define SIP_RINGING             (1 << 3)        /* Have sent 180 ringing */
475 #define SIP_PROGRESS_SENT       (1 << 4)        /* Have sent 183 message progress */
476 #define SIP_NEEDREINVITE        (1 << 5)        /* Do we need to send another reinvite? */
477 #define SIP_PENDINGBYE          (1 << 6)        /* Need to send bye after we ack? */
478 #define SIP_GOTREFER            (1 << 7)        /* Got a refer? */
479 #define SIP_PROMISCREDIR        (1 << 8)        /* Promiscuous redirection */
480 #define SIP_TRUSTRPID           (1 << 9)        /* Trust RPID headers? */
481 #define SIP_USEREQPHONE         (1 << 10)       /* Add user=phone to numeric URI. Default off */
482 #define SIP_REALTIME            (1 << 11)       /* Flag for realtime users */
483 #define SIP_USECLIENTCODE       (1 << 12)       /* Trust X-ClientCode info message */
484 #define SIP_OUTGOING            (1 << 13)       /* Is this an outgoing call? */
485 #define SIP_SELFDESTRUCT        (1 << 14)       
486 #define SIP_DYNAMIC             (1 << 15)       /* Is this a dynamic peer? */
487 /* --- Choices for DTMF support in SIP channel */
488 #define SIP_DTMF                (3 << 16)       /* three settings, uses two bits */
489 #define SIP_DTMF_RFC2833        (0 << 16)       /* RTP DTMF */
490 #define SIP_DTMF_INBAND         (1 << 16)       /* Inband audio, only for ULAW/ALAW */
491 #define SIP_DTMF_INFO           (2 << 16)       /* SIP Info messages */
492 #define SIP_DTMF_AUTO           (3 << 16)       /* AUTO switch between rfc2833 and in-band DTMF */
493 /* NAT settings */
494 #define SIP_NAT                 (3 << 18)       /* four settings, uses two bits */
495 #define SIP_NAT_NEVER           (0 << 18)       /* No nat support */
496 #define SIP_NAT_RFC3581         (1 << 18)
497 #define SIP_NAT_ROUTE           (2 << 18)
498 #define SIP_NAT_ALWAYS          (3 << 18)
499 /* re-INVITE related settings */
500 #define SIP_REINVITE            (3 << 20)       /* two bits used */
501 #define SIP_CAN_REINVITE        (1 << 20)       /* allow peers to be reinvited to send media directly p2p */
502 #define SIP_REINVITE_UPDATE     (2 << 20)       /* use UPDATE (RFC3311) when reinviting this peer */
503 /* "insecure" settings */
504 #define SIP_INSECURE_PORT       (1 << 22)       /* don't require matching port for incoming requests */
505 #define SIP_INSECURE_INVITE     (1 << 23)       /* don't require authentication for incoming INVITEs */
506 /* Sending PROGRESS in-band settings */
507 #define SIP_PROG_INBAND         (3 << 24)       /* three settings, uses two bits */
508 #define SIP_PROG_INBAND_NEVER   (0 << 24)
509 #define SIP_PROG_INBAND_NO      (1 << 24)
510 #define SIP_PROG_INBAND_YES     (2 << 24)
511 /* Open Settlement Protocol authentication */
512 #define SIP_OSPAUTH             (3 << 26)       /* three settings, uses two bits */
513 #define SIP_OSPAUTH_NO          (0 << 26)
514 #define SIP_OSPAUTH_YES         (1 << 26)
515 #define SIP_OSPAUTH_EXCLUSIVE   (2 << 26)
516 /* Call states */
517 #define SIP_CALL_ONHOLD         (1 << 28)        
518 #define SIP_CALL_LIMIT          (1 << 29)
519
520 /* a new page of flags for peer */
521 #define SIP_PAGE2_RTCACHEFRIENDS        (1 << 0)
522 #define SIP_PAGE2_RTUPDATE              (1 << 1)
523 #define SIP_PAGE2_RTAUTOCLEAR           (1 << 2)
524 #define SIP_PAGE2_RTIGNOREREGEXPIRE       (1 << 3)
525
526 static int global_rtautoclear = 120;
527
528 /* sip_pvt: PVT structures are used for each SIP conversation, ie. a call  */
529 static struct sip_pvt {
530         ast_mutex_t lock;                       /* Channel private lock */
531         int method;                             /* SIP method of this packet */
532         char callid[80];                        /* Global CallID */
533         char randdata[80];                      /* Random data */
534         struct ast_codec_pref prefs;            /* codec prefs */
535         unsigned int ocseq;                     /* Current outgoing seqno */
536         unsigned int icseq;                     /* Current incoming seqno */
537         ast_group_t callgroup;                  /* Call group */
538         ast_group_t pickupgroup;                /* Pickup group */
539         int lastinvite;                         /* Last Cseq of invite */
540         unsigned int flags;                     /* SIP_ flags */        
541         int timer_t1;                           /* SIP timer T1, ms rtt */
542         unsigned int sipoptions;                /* Supported SIP sipoptions on the other end */
543         int capability;                         /* Special capability (codec) */
544         int jointcapability;                    /* Supported capability at both ends (codecs ) */
545         int peercapability;                     /* Supported peer capability */
546         int prefcodec;                          /* Preferred codec (outbound only) */
547         int noncodeccapability;
548         int callingpres;                        /* Calling presentation */
549         int authtries;                          /* Times we've tried to authenticate */
550         int expiry;                             /* How long we take to expire */
551         int branch;                             /* One random number */
552         int tag;                                /* Another random number */
553         int sessionid;                          /* SDP Session ID */
554         int sessionversion;                     /* SDP Session Version */
555         struct sockaddr_in sa;                  /* Our peer */
556         struct sockaddr_in redirip;             /* Where our RTP should be going if not to us */
557         struct sockaddr_in vredirip;            /* Where our Video RTP should be going if not to us */
558         int redircodecs;                        /* Redirect codecs */
559         struct sockaddr_in recv;                /* Received as */
560         struct in_addr ourip;                   /* Our IP */
561         struct ast_channel *owner;              /* Who owns us */
562         char exten[AST_MAX_EXTENSION];          /* Extension where to start */
563         char refer_to[AST_MAX_EXTENSION];       /* Place to store REFER-TO extension */
564         char referred_by[AST_MAX_EXTENSION];    /* Place to store REFERRED-BY extension */
565         char refer_contact[AST_MAX_EXTENSION];  /* Place to store Contact info from a REFER extension */
566         struct sip_pvt *refer_call;             /* Call we are referring */
567         struct sip_route *route;                /* Head of linked list of routing steps (fm Record-Route) */
568         int route_persistant;                   /* Is this the "real" route? */
569         char from[256];                         /* The From: header */
570         char useragent[256];                    /* User agent in SIP request */
571         char context[AST_MAX_CONTEXT];          /* Context for this call */
572         char subscribecontext[AST_MAX_CONTEXT]; /* Subscribecontext */
573         char fromdomain[MAXHOSTNAMELEN];        /* Domain to show in the from field */
574         char fromuser[AST_MAX_EXTENSION];       /* User to show in the user field */
575         char fromname[AST_MAX_EXTENSION];       /* Name to show in the user field */
576         char tohost[MAXHOSTNAMELEN];            /* Host we should put in the "to" field */
577         char language[MAX_LANGUAGE];            /* Default language for this call */
578         char musicclass[MAX_MUSICCLASS];          /* Music on Hold class */
579         char rdnis[256];                        /* Referring DNIS */
580         char theirtag[256];                     /* Their tag */
581         char username[256];                     /* [user] name */
582         char peername[256];                     /* [peer] name, not set if [user] */
583         char authname[256];                     /* Who we use for authentication */
584         char uri[256];                          /* Original requested URI */
585         char okcontacturi[256];                 /* URI from the 200 OK on INVITE */
586         char peersecret[256];                   /* Password */
587         char peermd5secret[256];
588         struct sip_auth *peerauth;              /* Realm authentication */
589         char cid_num[256];                      /* Caller*ID */
590         char cid_name[256];                     /* Caller*ID */
591         char via[256];                          /* Via: header */
592         char fullcontact[128];                  /* The Contact: that the UA registers with us */
593         char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
594         char our_contact[256];                  /* Our contact header */
595         char realm[MAXHOSTNAMELEN];             /* Authorization realm */
596         char nonce[256];                        /* Authorization nonce */
597         char opaque[256];                       /* Opaque nonsense */
598         char qop[80];                           /* Quality of Protection, since SIP wasn't complicated enough yet. */
599         char domain[MAXHOSTNAMELEN];            /* Authorization domain */
600         char lastmsg[256];                      /* Last Message sent/received */
601         int amaflags;                           /* AMA Flags */
602         int pendinginvite;                      /* Any pending invite */
603 #ifdef OSP_SUPPORT
604         int osphandle;                          /* OSP Handle for call */
605         time_t ospstart;                        /* OSP Start time */
606 #endif
607         struct sip_request initreq;             /* Initial request */
608         
609         int maxtime;                            /* Max time for first response */
610         int maxforwards;                        /* keep the max-forwards info */
611         int initid;                             /* Auto-congest ID if appropriate */
612         int autokillid;                         /* Auto-kill ID */
613         time_t lastrtprx;                       /* Last RTP received */
614         time_t lastrtptx;                       /* Last RTP sent */
615         int rtptimeout;                         /* RTP timeout time */
616         int rtpholdtimeout;                     /* RTP timeout when on hold */
617         int rtpkeepalive;                       /* Send RTP packets for keepalive */
618         enum subscriptiontype subscribed;       /* Is this call a subscription?  */
619         int stateid;
620         int laststate;                          /* Last known extension state */
621         int dialogver;
622         
623         struct ast_dsp *vad;                    /* Voice Activation Detection dsp */
624         
625         struct sip_peer *peerpoke;              /* If this calls is to poke a peer, which one */
626         struct sip_registry *registry;          /* If this is a REGISTER call, to which registry */
627         struct ast_rtp *rtp;                    /* RTP Session */
628         struct ast_rtp *vrtp;                   /* Video RTP session */
629         struct sip_pkt *packets;                /* Packets scheduled for re-transmission */
630         struct sip_history *history;            /* History of this SIP dialog */
631         struct ast_variable *chanvars;          /* Channel variables to set for call */
632         struct sip_pvt *next;                   /* Next call in chain */
633         struct sip_invite_param *options;       /* Options for INVITE */
634 } *iflist = NULL;
635
636 #define FLAG_RESPONSE (1 << 0)
637 #define FLAG_FATAL (1 << 1)
638
639 /* sip packet - read in sipsock_read, transmitted in send_request */
640 struct sip_pkt {
641         struct sip_pkt *next;                   /* Next packet */
642         int retrans;                            /* Retransmission number */
643         int method;                             /* SIP method for this packet */
644         int seqno;                              /* Sequence number */
645         unsigned int flags;                     /* non-zero if this is a response packet (e.g. 200 OK) */
646         struct sip_pvt *owner;                  /* Owner call */
647         int retransid;                          /* Retransmission ID */
648         int timer_a;                            /* SIP timer A, retransmission timer */
649         int timer_t1;                           /* SIP Timer T1, estimated RTT or 500 ms */
650         int packetlen;                          /* Length of packet */
651         char data[0];
652 };      
653
654 /* Structure for SIP user data. User's place calls to us */
655 struct sip_user {
656         /* Users who can access various contexts */
657         ASTOBJ_COMPONENTS(struct sip_user);
658         char secret[80];                /* Password */
659         char md5secret[80];             /* Password in md5 */
660         char context[AST_MAX_CONTEXT];  /* Default context for incoming calls */
661         char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
662         char cid_num[80];               /* Caller ID num */
663         char cid_name[80];              /* Caller ID name */
664         char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
665         char language[MAX_LANGUAGE];    /* Default language for this user */
666         char musicclass[MAX_MUSICCLASS];/* Music on Hold class */
667         char useragent[256];            /* User agent in SIP request */
668         struct ast_codec_pref prefs;    /* codec prefs */
669         ast_group_t callgroup;          /* Call group */
670         ast_group_t pickupgroup;        /* Pickup Group */
671         unsigned int flags;             /* SIP flags */ 
672         unsigned int sipoptions;        /* Supported SIP options */
673         struct ast_flags flags_page2;   /* SIP_PAGE2 flags */
674         int amaflags;                   /* AMA flags for billing */
675         int callingpres;                /* Calling id presentation */
676         int capability;                 /* Codec capability */
677         int inUse;                      /* Number of calls in use */
678         int call_limit;                 /* Limit of concurrent calls */
679         struct ast_ha *ha;              /* ACL setting */
680         struct ast_variable *chanvars;  /* Variables to set for channel created by user */
681 };
682
683 /* Structure for SIP peer data, we place calls to peers if registred  or fixed IP address (host) */
684 struct sip_peer {
685         ASTOBJ_COMPONENTS(struct sip_peer);     /* name, refcount, objflags,  object pointers */
686                                         /* peer->name is the unique name of this object */
687         char secret[80];                /* Password */
688         char md5secret[80];             /* Password in MD5 */
689         struct sip_auth *auth;          /* Realm authentication list */
690         char context[AST_MAX_CONTEXT];  /* Default context for incoming calls */
691         char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
692         char username[80];              /* Temporary username until registration */ 
693         char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
694         int amaflags;                   /* AMA Flags (for billing) */
695         char tohost[MAXHOSTNAMELEN];    /* If not dynamic, IP address */
696         char regexten[AST_MAX_EXTENSION]; /* Extension to register (if regcontext is used) */
697         char fromuser[80];              /* From: user when calling this peer */
698         char fromdomain[MAXHOSTNAMELEN];        /* From: domain when calling this peer */
699         char fullcontact[256];          /* Contact registred with us (not in sip.conf) */
700         char cid_num[80];               /* Caller ID num */
701         char cid_name[80];              /* Caller ID name */
702         int callingpres;                /* Calling id presentation */
703         int inUse;                      /* Number of calls in use */
704         int call_limit;                 /* Limit of concurrent calls */
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, const char *event, const 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) || (ast_test_flag(r, SIP_DTMF) == SIP_DTMF_AUTO))
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->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
1945                        p->options->uri_options = ast_var_value(current);
1946                 } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
1947                         /* Check whether there is a ALERT_INFO variable */
1948                         p->options->distinctive_ring = ast_var_value(current);
1949                 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
1950                         /* Check whether there is a variable with a name starting with SIPADDHEADER */
1951                         p->options->addsipheaders = 1;
1952                 }
1953
1954                 
1955 #ifdef OSP_SUPPORT
1956                 else if (!p->options->osptoken && !strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1957                         p->options->osptoken = ast_var_value(current);
1958                 } else if (!osphandle && !strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1959                         osphandle = ast_var_value(current);
1960                 }
1961 #endif
1962         }
1963         
1964         res = 0;
1965         ast_set_flag(p, SIP_OUTGOING);
1966 #ifdef OSP_SUPPORT
1967         if (!p->options->osptoken || !osphandle || (sscanf(osphandle, "%d", &p->osphandle) != 1)) {
1968                 /* Force Disable OSP support */
1969                 ast_log(LOG_DEBUG, "Disabling OSP support for this call. osptoken = %s, osphandle = %s\n", p->options->osptoken, osphandle);
1970                 p->options->osptoken = NULL;
1971                 osphandle = NULL;
1972                 p->osphandle = -1;
1973         }
1974 #endif
1975         ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
1976         res = update_call_counter(p, INC_CALL_LIMIT);
1977         if ( res != -1 ) {
1978                 p->callingpres = ast->cid.cid_pres;
1979                 p->jointcapability = p->capability;
1980                 transmit_invite(p, SIP_INVITE, 1, 2);
1981                 if (p->maxtime) {
1982                         /* Initialize auto-congest time */
1983                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
1984                 }
1985         }
1986         return res;
1987 }
1988
1989 /*--- sip_registry_destroy: Destroy registry object ---*/
1990 /*      Objects created with the register= statement in static configuration */
1991 static void sip_registry_destroy(struct sip_registry *reg)
1992 {
1993         /* Really delete */
1994         if (reg->call) {
1995                 /* Clear registry before destroying to ensure
1996                    we don't get reentered trying to grab the registry lock */
1997                 reg->call->registry = NULL;
1998                 sip_destroy(reg->call);
1999         }
2000         if (reg->expire > -1)
2001                 ast_sched_del(sched, reg->expire);
2002         if (reg->timeout > -1)
2003                 ast_sched_del(sched, reg->timeout);
2004         regobjs--;
2005         free(reg);
2006         
2007 }
2008
2009 /*---  __sip_destroy: Execute destrucion of call structure, release memory---*/
2010 static void __sip_destroy(struct sip_pvt *p, int lockowner)
2011 {
2012         struct sip_pvt *cur, *prev = NULL;
2013         struct sip_pkt *cp;
2014         struct sip_history *hist;
2015
2016         if (sip_debug_test_pvt(p))
2017                 ast_verbose("Destroying call '%s'\n", p->callid);
2018
2019         if (dumphistory)
2020                 sip_dump_history(p);
2021
2022         if (p->options)
2023                 free(p->options);
2024
2025         if (p->stateid > -1)
2026                 ast_extension_state_del(p->stateid, NULL);
2027         if (p->initid > -1)
2028                 ast_sched_del(sched, p->initid);
2029         if (p->autokillid > -1)
2030                 ast_sched_del(sched, p->autokillid);
2031
2032         if (p->rtp) {
2033                 ast_rtp_destroy(p->rtp);
2034         }
2035         if (p->vrtp) {
2036                 ast_rtp_destroy(p->vrtp);
2037         }
2038         if (p->route) {
2039                 free_old_route(p->route);
2040                 p->route = NULL;
2041         }
2042         if (p->registry) {
2043                 if (p->registry->call == p)
2044                         p->registry->call = NULL;
2045                 ASTOBJ_UNREF(p->registry,sip_registry_destroy);
2046         }
2047         /* Unlink us from the owner if we have one */
2048         if (p->owner) {
2049                 if (lockowner)
2050                         ast_mutex_lock(&p->owner->lock);
2051                 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
2052                 p->owner->tech_pvt = NULL;
2053                 if (lockowner)
2054                         ast_mutex_unlock(&p->owner->lock);
2055         }
2056         /* Clear history */
2057         while(p->history) {
2058                 hist = p->history;
2059                 p->history = p->history->next;
2060                 free(hist);
2061         }
2062
2063         cur = iflist;
2064         while(cur) {
2065                 if (cur == p) {
2066                         if (prev)
2067                                 prev->next = cur->next;
2068                         else
2069                                 iflist = cur->next;
2070                         break;
2071                 }
2072                 prev = cur;
2073                 cur = cur->next;
2074         }
2075         if (!cur) {
2076                 ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
2077                 return;
2078         } 
2079         if (p->initid > -1)
2080                 ast_sched_del(sched, p->initid);
2081
2082         while((cp = p->packets)) {
2083                 p->packets = p->packets->next;
2084                 if (cp->retransid > -1) {
2085                         ast_sched_del(sched, cp->retransid);
2086                 }
2087                 free(cp);
2088         }
2089         if (p->chanvars) {
2090                 ast_variables_destroy(p->chanvars);
2091                 p->chanvars = NULL;
2092         }
2093         ast_mutex_destroy(&p->lock);
2094         free(p);
2095 }
2096
2097 /*--- update_call_counter: Handle call_limit for SIP users ---*/
2098 /* Note: This is going to be replaced by app_groupcount */
2099 /* Thought: For realtime, we should propably update storage with inuse counter... */
2100 static int update_call_counter(struct sip_pvt *fup, int event)
2101 {
2102         char name[256] = "";
2103         int *inuse, *call_limit;
2104         int outgoing = ast_test_flag(fup, SIP_OUTGOING);
2105         struct sip_user *u = NULL;
2106         struct sip_peer *p = NULL;
2107
2108         if (option_debug > 2)
2109                 ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
2110         /* Test if we need to check call limits, in order to avoid 
2111            realtime lookups if we do not need it */
2112         if (!ast_test_flag(fup, SIP_CALL_LIMIT))
2113                 return 0;
2114
2115         ast_copy_string(name, fup->username, sizeof(name));
2116
2117         /* Check the list of users */
2118         u = find_user(name, 1);
2119         if (u) {
2120                 inuse = &u->inUse;
2121                 call_limit = &u->call_limit;
2122                 p = NULL;
2123         } else {
2124                 /* Try to find peer */
2125                 if (!p)
2126                         p = find_peer(fup->peername, NULL, 1);
2127                 if (p) {
2128                         inuse = &p->inUse;
2129                         call_limit = &p->call_limit;
2130                         ast_copy_string(name, fup->peername, sizeof(name));
2131                 } else {
2132                         if (option_debug > 1)
2133                                 ast_log(LOG_DEBUG, "%s is not a local user, no call limit\n", name);
2134                         return 0;
2135                 }
2136         }
2137         switch(event) {
2138                 /* incoming and outgoing affects the inUse counter */
2139                 case DEC_CALL_LIMIT:
2140                         if ( *inuse > 0 ) {
2141                                 (*inuse)--;
2142                         } else {
2143                                 *inuse = 0;
2144                         }
2145                         ast_log(LOG_ERROR, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
2146                         break;
2147                 case INC_CALL_LIMIT:
2148                         if (*call_limit > 0 ) {
2149                                 if (*inuse >= *call_limit) {
2150                                         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);
2151                                         /* inc inUse as well */
2152                                         if ( event == INC_CALL_LIMIT ) {
2153                                                 (*inuse)++;
2154                                         }
2155                                         if (u)
2156                                                 ASTOBJ_UNREF(u,sip_destroy_user);
2157                                         else
2158                                                 ASTOBJ_UNREF(p,sip_destroy_peer);
2159                                         return -1; 
2160                                 }
2161                         }
2162                         (*inuse)++;
2163                         ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
2164                         break;
2165                 default:
2166                         ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
2167         }
2168         if (u)
2169                 ASTOBJ_UNREF(u,sip_destroy_user);
2170         else
2171                 ASTOBJ_UNREF(p,sip_destroy_peer);
2172         return 0;
2173 }
2174
2175 /*--- sip_destroy: Destroy SIP call structure ---*/
2176 static void sip_destroy(struct sip_pvt *p)
2177 {
2178         ast_mutex_lock(&iflock);
2179         __sip_destroy(p, 1);
2180         ast_mutex_unlock(&iflock);
2181 }
2182
2183
2184 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
2185
2186 /*--- hangup_sip2cause: Convert SIP hangup causes to Asterisk hangup causes ---*/
2187 static int hangup_sip2cause(int cause)
2188 {
2189 /* Possible values taken from causes.h */
2190
2191         switch(cause) {
2192                 case 403:       /* Not found */
2193                         return AST_CAUSE_CALL_REJECTED;
2194                 case 404:       /* Not found */
2195                         return AST_CAUSE_UNALLOCATED;
2196                 case 408:       /* No reaction */
2197                         return AST_CAUSE_NO_USER_RESPONSE;
2198                 case 480:       /* No answer */
2199                         return AST_CAUSE_FAILURE;
2200                 case 483:       /* Too many hops */
2201                         return AST_CAUSE_NO_ANSWER;
2202                 case 486:       /* Busy everywhere */
2203                         return AST_CAUSE_BUSY;
2204                 case 488:       /* No codecs approved */
2205                         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2206                 case 500:       /* Server internal failure */
2207                         return AST_CAUSE_FAILURE;
2208                 case 501:       /* Call rejected */
2209                         return AST_CAUSE_FACILITY_REJECTED;
2210                 case 502:       
2211                         return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2212                 case 503:       /* Service unavailable */
2213                         return AST_CAUSE_CONGESTION;
2214                 default:
2215                         return AST_CAUSE_NORMAL;
2216         }
2217         /* Never reached */
2218         return 0;
2219 }
2220
2221
2222 /*--- hangup_cause2sip: Convert Asterisk hangup causes to SIP codes ---*/
2223 /* Possible values from causes.h
2224         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
2225         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
2226
2227         In addition to these, a lot of PRI codes is defined in causes.h 
2228         ...should we take care of them too ?
2229         
2230         Quote RFC 3398
2231
2232    ISUP Cause value                        SIP response
2233    ----------------                        ------------
2234    1  unallocated number                   404 Not Found
2235    2  no route to network                  404 Not found
2236    3  no route to destination              404 Not found
2237    16 normal call clearing                 --- (*)
2238    17 user busy                            486 Busy here
2239    18 no user responding                   408 Request Timeout
2240    19 no answer from the user              480 Temporarily unavailable
2241    20 subscriber absent                    480 Temporarily unavailable
2242    21 call rejected                        403 Forbidden (+)
2243    22 number changed (w/o diagnostic)      410 Gone
2244    22 number changed (w/ diagnostic)       301 Moved Permanently
2245    23 redirection to new destination       410 Gone
2246    26 non-selected user clearing           404 Not Found (=)
2247    27 destination out of order             502 Bad Gateway
2248    28 address incomplete                   484 Address incomplete
2249    29 facility rejected                    501 Not implemented
2250    31 normal unspecified                   480 Temporarily unavailable
2251 */
2252 static char *hangup_cause2sip(int cause)
2253 {
2254         switch(cause)
2255         {
2256                 case AST_CAUSE_UNALLOCATED:             /* 1 */
2257                 case AST_CAUSE_NO_ROUTE_DESTINATION:    /* 3 IAX2: Can't find extension in context */
2258                 case AST_CAUSE_NO_ROUTE_TRANSIT_NET:    /* 2 */
2259                         return "404 Not Found";
2260                 case AST_CAUSE_CONGESTION:              /* 34 */
2261                 case AST_CAUSE_SWITCH_CONGESTION:       /* 42 */
2262                         return "503 Service Unavailable";
2263                 case AST_CAUSE_NO_USER_RESPONSE:        /* 18 */
2264                         return "408 Request Timeout";
2265                 case AST_CAUSE_NO_ANSWER:               /* 19 */
2266                         return "480 Temporarily unavailable";
2267                 case AST_CAUSE_CALL_REJECTED:           /* 21 */
2268                         return "403 Forbidden";
2269                 case AST_CAUSE_NUMBER_CHANGED:          /* 22 */
2270                         return "410 Gone";
2271                 case AST_CAUSE_NORMAL_UNSPECIFIED:      /* 31 */
2272                         return "480 Temporarily unavailable";
2273                 case AST_CAUSE_INVALID_NUMBER_FORMAT:
2274                         return "484 Address incomplete";
2275                 case AST_CAUSE_USER_BUSY:
2276                         return "486 Busy here";
2277                 case AST_CAUSE_FAILURE:
2278                         return "500 Server internal failure";
2279                 case AST_CAUSE_FACILITY_REJECTED:       /* 29 */
2280                         return "501 Not Implemented";
2281                 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
2282                         return "503 Service Unavailable";
2283                 /* Used in chan_iax2 */
2284                 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
2285                         return "502 Bad Gateway";
2286                 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:       /* Can't find codec to connect to host */
2287                         return "488 Not Acceptable Here";
2288                         
2289                 case AST_CAUSE_NOTDEFINED:
2290                 default:
2291                         ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
2292                         return NULL;
2293         }
2294
2295         /* Never reached */
2296         return 0;
2297 }
2298
2299
2300 /*--- sip_hangup: Hangup SIP call ---*/
2301 /* Part of PBX interface */
2302 static int sip_hangup(struct ast_channel *ast)
2303 {
2304         struct sip_pvt *p = ast->tech_pvt;
2305         int needcancel = 0;
2306         struct ast_flags locflags = {0};
2307
2308         if (!p) {
2309                 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
2310                 return 0;
2311         }
2312         if (option_debug)
2313                 ast_log(LOG_DEBUG, "Hangup call %s, SIP callid %s)\n", ast->name, p->callid);
2314
2315         ast_mutex_lock(&p->lock);
2316 #ifdef OSP_SUPPORT
2317         if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
2318                 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
2319         }
2320 #endif  
2321         ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter\n", p->username);
2322         update_call_counter(p, DEC_CALL_LIMIT);
2323         /* Determine how to disconnect */
2324         if (p->owner != ast) {
2325                 ast_log(LOG_WARNING, "Huh?  We aren't the owner? Can't hangup call.\n");
2326                 ast_mutex_unlock(&p->lock);
2327                 return 0;
2328         }
2329         /* If the call is not UP, we need to send CANCEL instead of BYE */
2330         if (ast->_state != AST_STATE_UP)
2331                 needcancel = 1;
2332
2333         /* Disconnect */
2334         p = ast->tech_pvt;
2335         if (p->vad) {
2336                 ast_dsp_free(p->vad);
2337         }
2338         p->owner = NULL;
2339         ast->tech_pvt = NULL;
2340
2341         ast_mutex_lock(&usecnt_lock);
2342         usecnt--;
2343         ast_mutex_unlock(&usecnt_lock);
2344         ast_update_use_count();
2345
2346         ast_set_flag(&locflags, SIP_NEEDDESTROY);       
2347
2348         /* Start the process if it's not already started */
2349         if (!ast_test_flag(p, SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
2350                 if (needcancel) {       /* Outgoing call, not up */
2351                         if (ast_test_flag(p, SIP_OUTGOING)) {
2352                                 transmit_request_with_auth(p, SIP_CANCEL, p->ocseq, 1, 0);
2353                                 /* Actually don't destroy us yet, wait for the 487 on our original 
2354                                    INVITE, but do set an autodestruct just in case we never get it. */
2355                                 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
2356                                 sip_scheddestroy(p, 15000);
2357                                 /* stop retransmitting an INVITE that has not received a response */
2358                                 __sip_pretend_ack(p);
2359                                 if ( p->initid != -1 ) {
2360                                         /* channel still up - reverse dec of inUse counter
2361                                            only if the channel is not auto-congested */
2362                                         update_call_counter(p, INC_CALL_LIMIT);
2363                                 }
2364                         } else {        /* Incoming call, not up */
2365                                 char *res;
2366                                 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
2367                                         transmit_response_reliable(p, res, &p->initreq, 1);
2368                                 } else 
2369                                         transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
2370                         }
2371                 } else {        /* Call is in UP state, send BYE */
2372                         if (!p->pendinginvite) {
2373                                 /* Send a hangup */
2374                                 transmit_request_with_auth(p, SIP_BYE, 0, 1, 1);
2375                         } else {
2376                                 /* Note we will need a BYE when this all settles out
2377                                    but we can't send one while we have "INVITE" outstanding. */
2378                                 ast_set_flag(p, SIP_PENDINGBYE);        
2379                                 ast_clear_flag(p, SIP_NEEDREINVITE);    
2380                         }
2381                 }
2382         }
2383         ast_copy_flags(p, (&locflags), SIP_NEEDDESTROY);        
2384         ast_mutex_unlock(&p->lock);
2385         return 0;
2386 }
2387
2388 /*--- sip_answer: Answer SIP call , send 200 OK on Invite ---*/
2389 /* Part of PBX interface */
2390 static int sip_answer(struct ast_channel *ast)
2391 {
2392         int res = 0,fmt;
2393         char *codec;
2394         struct sip_pvt *p = ast->tech_pvt;
2395
2396         ast_mutex_lock(&p->lock);
2397         if (ast->_state != AST_STATE_UP) {
2398 #ifdef OSP_SUPPORT      
2399                 time(&p->ospstart);
2400 #endif
2401         
2402                 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
2403                 if (codec) {
2404                         fmt=ast_getformatbyname(codec);
2405                         if (fmt) {
2406                                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
2407                                 if (p->jointcapability & fmt) {
2408                                         p->jointcapability &= fmt;
2409                                         p->capability &= fmt;
2410                                 } else
2411                                         ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
2412                         } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
2413                 }
2414
2415                 ast_setstate(ast, AST_STATE_UP);
2416                 if (option_debug)
2417                         ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
2418                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
2419         }
2420         ast_mutex_unlock(&p->lock);
2421         return res;
2422 }
2423
2424 /*--- sip_write: Send frame to media channel (rtp) ---*/
2425 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
2426 {
2427         struct sip_pvt *p = ast->tech_pvt;
2428         int res = 0;
2429         switch (frame->frametype) {
2430         case AST_FRAME_VOICE:
2431                 if (!(frame->subclass & ast->nativeformats)) {
2432                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
2433                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
2434                         return 0;
2435                 }
2436                 if (p) {
2437                         ast_mutex_lock(&p->lock);
2438                         if (p->rtp) {
2439                                 /* If channel is not up, activate early media session */
2440                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2441                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2442                                         ast_set_flag(p, SIP_PROGRESS_SENT);     
2443                                 }
2444                                 time(&p->lastrtptx);
2445                                 res =  ast_rtp_write(p->rtp, frame);
2446                         }
2447                         ast_mutex_unlock(&p->lock);
2448                 }
2449                 break;
2450         case AST_FRAME_VIDEO:
2451                 if (p) {
2452                         ast_mutex_lock(&p->lock);
2453                         if (p->vrtp) {
2454                                 /* Activate video early media */
2455                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2456                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2457                                         ast_set_flag(p, SIP_PROGRESS_SENT);     
2458                                 }
2459                                 time(&p->lastrtptx);
2460                                 res =  ast_rtp_write(p->vrtp, frame);
2461                         }
2462                         ast_mutex_unlock(&p->lock);
2463                 }
2464                 break;
2465         case AST_FRAME_IMAGE:
2466                 return 0;
2467                 break;
2468         default: 
2469                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
2470                 return 0;
2471         }
2472
2473         return res;
2474 }
2475
2476 /*--- sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
2477         Basically update any ->owner links ----*/
2478 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
2479 {
2480         struct sip_pvt *p = newchan->tech_pvt;
2481         ast_mutex_lock(&p->lock);
2482         if (p->owner != oldchan) {
2483                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
2484                 ast_mutex_unlock(&p->lock);
2485                 return -1;
2486         }
2487         p->owner = newchan;
2488         ast_mutex_unlock(&p->lock);
2489         return 0;
2490 }
2491
2492 /*--- sip_senddigit: Send DTMF character on SIP channel */
2493 /*    within one call, we're able to transmit in many methods simultaneously */
2494 static int sip_senddigit(struct ast_channel *ast, char digit)
2495 {
2496         struct sip_pvt *p = ast->tech_pvt;
2497         int res = 0;
2498         ast_mutex_lock(&p->lock);
2499         switch (ast_test_flag(p, SIP_DTMF)) {
2500         case SIP_DTMF_INFO:
2501                 transmit_info_with_digit(p, digit);
2502                 break;
2503         case SIP_DTMF_RFC2833:
2504                 if (p->rtp)
2505                         ast_rtp_senddigit(p->rtp, digit);
2506                 break;
2507         case SIP_DTMF_INBAND:
2508                 res = -1;
2509                 break;
2510         }
2511         ast_mutex_unlock(&p->lock);
2512         return res;
2513 }
2514
2515 #define DEFAULT_MAX_FORWARDS    70
2516
2517
2518 /*--- sip_transfer: Transfer SIP call */
2519 static int sip_transfer(struct ast_channel *ast, const char *dest)
2520 {
2521         struct sip_pvt *p = ast->tech_pvt;
2522         int res;
2523
2524         ast_mutex_lock(&p->lock);
2525         if (ast->_state == AST_STATE_RING)
2526                 res = sip_sipredirect(p, dest);
2527         else
2528                 res = transmit_refer(p, dest);
2529         ast_mutex_unlock(&p->lock);
2530         return res;
2531 }
2532
2533 /*--- sip_indicate: Play indication to user */
2534 /* With SIP a lot of indications is sent as messages, letting the device play
2535    the indication - busy signal, congestion etc */
2536 static int sip_indicate(struct ast_channel *ast, int condition)
2537 {
2538         struct sip_pvt *p = ast->tech_pvt;
2539         int res = 0;
2540
2541         ast_mutex_lock(&p->lock);
2542         switch(condition) {
2543         case AST_CONTROL_RINGING:
2544                 if (ast->_state == AST_STATE_RING) {
2545                         if (!ast_test_flag(p, SIP_PROGRESS_SENT) ||
2546                             (ast_test_flag(p, SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
2547                                 /* Send 180 ringing if out-of-band seems reasonable */
2548                                 transmit_response(p, "180 Ringing", &p->initreq);
2549                                 ast_set_flag(p, SIP_RINGING);
2550                                 if (ast_test_flag(p, SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
2551                                         break;
2552                         } else {
2553                                 /* Well, if it's not reasonable, just send in-band */
2554                         }
2555                 }
2556                 res = -1;
2557                 break;
2558         case AST_CONTROL_BUSY:
2559                 if (ast->_state != AST_STATE_UP) {
2560                         transmit_response(p, "486 Busy Here", &p->initreq);
2561                         ast_set_flag(p, SIP_ALREADYGONE);       
2562                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2563                         break;
2564                 }
2565                 res = -1;
2566                 break;
2567         case AST_CONTROL_CONGESTION:
2568                 if (ast->_state != AST_STATE_UP) {
2569                         transmit_response(p, "503 Service Unavailable", &p->initreq);
2570                         ast_set_flag(p, SIP_ALREADYGONE);       
2571                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2572                         break;
2573                 }
2574                 res = -1;
2575                 break;
2576         case AST_CONTROL_PROGRESS:
2577         case AST_CONTROL_PROCEEDING:
2578                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2579                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2580                         ast_set_flag(p, SIP_PROGRESS_SENT);     
2581                         break;
2582                 }
2583                 res = -1;
2584                 break;
2585         case AST_CONTROL_HOLD:  /* The other part of the bridge are put on hold */
2586                 if (sipdebug)
2587                         ast_log(LOG_DEBUG, "Bridged channel now on hold%s\n", p->callid);
2588                 res = -1;
2589                 break;
2590         case AST_CONTROL_UNHOLD:        /* The other part of the bridge are back from hold */
2591                 if (sipdebug)
2592                         ast_log(LOG_DEBUG, "Bridged channel is back from hold, let's talk! : %s\n", p->callid);
2593                 res = -1;
2594                 break;
2595         case AST_CONTROL_VIDUPDATE:     /* Request a video frame update */
2596                 if (p->vrtp && !ast_test_flag(p, SIP_NOVIDEO)) {
2597                         transmit_info_with_vidupdate(p);
2598                         res = 0;
2599                 } else
2600                         res = -1;
2601                 break;
2602         case -1:
2603                 res = -1;
2604                 break;
2605         default:
2606                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
2607                 res = -1;
2608                 break;
2609         }
2610         ast_mutex_unlock(&p->lock);
2611         return res;
2612 }
2613
2614
2615
2616 /*--- sip_new: Initiate a call in the SIP channel */
2617 /*      called from sip_request_call (calls from the pbx ) */
2618 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
2619 {
2620         struct ast_channel *tmp;
2621         struct ast_variable *v = NULL;
2622         int fmt;
2623         
2624         ast_mutex_unlock(&i->lock);
2625         /* Don't hold a sip pvt lock while we allocate a channel */
2626         tmp = ast_channel_alloc(1);
2627         ast_mutex_lock(&i->lock);
2628         if (!tmp) {
2629                 ast_log(LOG_WARNING, "Unable to allocate SIP channel structure\n");
2630                 return NULL;
2631         }
2632         tmp->tech = &sip_tech;
2633         /* Select our native format based on codec preference until we receive
2634            something from another device to the contrary. */
2635         ast_mutex_lock(&i->lock);
2636         if (i->jointcapability)
2637                 tmp->nativeformats = ast_codec_choose(&i->prefs, i->jointcapability, 1);
2638         else if (i->capability)
2639                 tmp->nativeformats = ast_codec_choose(&i->prefs, i->capability, 1);
2640         else
2641                 tmp->nativeformats = ast_codec_choose(&i->prefs, global_capability, 1);
2642         ast_mutex_unlock(&i->lock);
2643         fmt = ast_best_codec(tmp->nativeformats);
2644
2645         if (title)
2646                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
2647         else if (strchr(i->fromdomain,':'))
2648                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2649         else
2650                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2651
2652         tmp->type = channeltype;
2653         if (ast_test_flag(i, SIP_DTMF) ==  SIP_DTMF_INBAND) {
2654                 i->vad = ast_dsp_new();
2655                 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2656                 if (relaxdtmf)
2657                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2658         }
2659         tmp->fds[0] = ast_rtp_fd(i->rtp);
2660         tmp->fds[1] = ast_rtcp_fd(i->rtp);
2661         if (i->vrtp) {
2662                 tmp->fds[2] = ast_rtp_fd(i->vrtp);
2663                 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2664         }
2665         if (state == AST_STATE_RING)
2666                 tmp->rings = 1;
2667         tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2668         tmp->writeformat = fmt;
2669         tmp->rawwriteformat = fmt;
2670         tmp->readformat = fmt;
2671         tmp->rawreadformat = fmt;
2672         tmp->tech_pvt = i;
2673
2674         tmp->callgroup = i->callgroup;
2675         tmp->pickupgroup = i->pickupgroup;
2676         tmp->cid.cid_pres = i->callingpres;
2677         if (!ast_strlen_zero(i->accountcode))
2678                 ast_copy_string(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode));
2679         if (i->amaflags)
2680                 tmp->amaflags = i->amaflags;
2681         if (!ast_strlen_zero(i->language))
2682                 ast_copy_string(tmp->language, i->language, sizeof(tmp->language));
2683         if (!ast_strlen_zero(i->musicclass))
2684                 ast_copy_string(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass));
2685         i->owner = tmp;
2686         ast_mutex_lock(&usecnt_lock);
2687         usecnt++;
2688         ast_mutex_unlock(&usecnt_lock);
2689         ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
2690         ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
2691         if (!ast_strlen_zero(i->cid_num)) 
2692                 tmp->cid.cid_num = strdup(i->cid_num);
2693         if (!ast_strlen_zero(i->cid_name))
2694                 tmp->cid.cid_name = strdup(i->cid_name);
2695         if (!ast_strlen_zero(i->rdnis))
2696                 tmp->cid.cid_rdnis = strdup(i->rdnis);
2697         if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2698                 tmp->cid.cid_dnid = strdup(i->exten);
2699         tmp->priority = 1;
2700         if (!ast_strlen_zero(i->uri)) {
2701                 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
2702         }
2703         if (!ast_strlen_zero(i->domain)) {
2704                 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2705         }
2706         if (!ast_strlen_zero(i->useragent)) {
2707                 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2708         }
2709         if (!ast_strlen_zero(i->callid)) {
2710                 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2711         }
2712         ast_setstate(tmp, state);
2713         if (state != AST_STATE_DOWN) {
2714                 if (ast_pbx_start(tmp)) {
2715                         ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2716                         ast_hangup(tmp);
2717                         tmp = NULL;
2718                 }
2719         }
2720         /* Set channel variables for this call from configuration */
2721         for (v = i->chanvars ; v ; v = v->next)
2722                 pbx_builtin_setvar_helper(tmp,v->name,v->value);
2723                                 
2724         return tmp;
2725 }
2726
2727 /*--- get_sdp_by_line: Reads one line of SIP message body */
2728 static char* get_sdp_by_line(char* line, char *name, int nameLen)
2729 {
2730         if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2731                 return ast_skip_blanks(line + nameLen + 1);
2732         }
2733         return "";
2734 }
2735
2736 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2737    but the name wrongly applies _only_ sdp */
2738 static char *get_sdp(struct sip_request *req, char *name) 
2739 {
2740         int x;
2741         int len = strlen(name);
2742         char *r;
2743
2744         for (x=0; x<req->lines; x++) {
2745                 r = get_sdp_by_line(req->line[x], name, len);
2746                 if (r[0] != '\0')
2747                         return r;
2748         }
2749         return "";
2750 }
2751
2752
2753 static void sdpLineNum_iterator_init(int* iterator) 
2754 {
2755         *iterator = 0;
2756 }
2757
2758 static char* get_sdp_iterate(int* iterator,
2759                              struct sip_request *req, char *name)
2760 {
2761         int len = strlen(name);
2762         char *r;
2763
2764         while (*iterator < req->lines) {
2765                 r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2766                 if (r[0] != '\0')
2767                         return r;
2768         }
2769         return "";
2770 }
2771
2772 static char *find_alias(const char *name, char *_default)
2773 {
2774         int x;
2775         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++) 
2776                 if (!strcasecmp(aliases[x].fullname, name))
2777                         return aliases[x].shortname;
2778         return _default;
2779 }
2780
2781 static char *__get_header(struct sip_request *req, char *name, int *start)
2782 {
2783         int pass;
2784
2785         /*
2786          * Technically you can place arbitrary whitespace both before and after the ':' in
2787          * a header, although RFC3261 clearly says you shouldn't before, and place just
2788          * one afterwards.  If you shouldn't do it, what absolute idiot decided it was 
2789          * a good idea to say you can do it, and if you can do it, why in the hell would.
2790          * you say you shouldn't.
2791          * Anyways, pedanticsipchecking controls whether we allow spaces before ':',
2792          * and we always allow spaces after that for compatibility.
2793          */
2794         for (pass = 0; name && pass < 2;pass++) {
2795                 int x, len = strlen(name);
2796                 for (x=*start; x<req->headers; x++) {
2797                         if (!strncasecmp(req->header[x], name, len)) {
2798                                 char *r = req->header[x] + len; /* skip name */
2799                                 if (pedanticsipchecking)
2800                                         r = ast_skip_blanks(r);
2801
2802                                 if (*r == ':') {
2803                                         *start = x+1;
2804                                         return ast_skip_blanks(r+1);
2805                                 }
2806                         }
2807                 }
2808                 if (pass == 0) /* Try aliases */
2809                         name = find_alias(name, NULL);
2810         }
2811
2812         /* Don't return NULL, so get_header is always a valid pointer */
2813         return "";
2814 }
2815
2816 /*--- get_header: Get header from SIP request ---*/
2817 static char *get_header(struct sip_request *req, char *name)
2818 {
2819         int start = 0;
2820         return __get_header(req, name, &start);
2821 }
2822
2823 /*--- sip_rtp_read: Read RTP from network ---*/
2824 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2825 {
2826         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
2827         struct ast_frame *f;
2828         static struct ast_frame null_frame = { AST_FRAME_NULL, };
2829         switch(ast->fdno) {
2830         case 0:
2831                 f = ast_rtp_read(p->rtp);       /* RTP Audio */
2832                 break;
2833         case 1:
2834                 f = ast_rtcp_read(p->rtp);      /* RTCP Control Channel */
2835                 break;
2836         case 2:
2837                 f = ast_rtp_read(p->vrtp);      /* RTP Video */
2838                 break;
2839         case 3:
2840                 f = ast_rtcp_read(p->vrtp);     /* RTCP Control Channel for video */
2841                 break;
2842         default:
2843                 f = &null_frame;
2844         }
2845         /* Don't forward RFC2833 if we're not supposed to */
2846         if (f && (f->frametype == AST_FRAME_DTMF) && (ast_test_flag(p, SIP_DTMF) != SIP_DTMF_RFC2833))
2847                 return &null_frame;
2848         if (p->owner) {
2849                 /* We already hold the channel lock */
2850                 if (f->frametype == AST_FRAME_VOICE) {
2851                         if (f->subclass != p->owner->nativeformats) {
2852                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2853                                 p->owner->nativeformats = f->subclass;
2854                                 ast_set_read_format(p->owner, p->owner->readformat);
2855                                 ast_set_write_format(p->owner, p->owner->writeformat);
2856                         }
2857                         if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
2858                                 f = ast_dsp_process(p->owner, p->vad, f);
2859                                 if (f && (f->frametype == AST_FRAME_DTMF)) 
2860                                         ast_log(LOG_DEBUG, "* Detected inband DTMF '%c'\n", f->subclass);
2861                         }
2862                 }
2863         }
2864         return f;
2865 }
2866
2867 /*--- sip_read: Read SIP RTP from channel */
2868 static struct ast_frame *sip_read(struct ast_channel *ast)
2869 {
2870         struct ast_frame *fr;
2871         struct sip_pvt *p = ast->tech_pvt;
2872         ast_mutex_lock(&p->lock);
2873         fr = sip_rtp_read(ast, p);
2874         time(&p->lastrtprx);
2875         ast_mutex_unlock(&p->lock);
2876         return fr;
2877 }
2878
2879 /*--- build_callid: Build SIP CALLID header ---*/
2880 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
2881 {
2882         int res;
2883         int val;
2884         int x;
2885         char iabuf[INET_ADDRSTRLEN];
2886         for (x=0; x<4; x++) {
2887                 val = rand();
2888                 res = snprintf(callid, len, "%08x", val);
2889                 len -= res;
2890                 callid += res;
2891         }
2892         if (!ast_strlen_zero(fromdomain))
2893                 snprintf(callid, len, "@%s", fromdomain);
2894         else
2895         /* It's not important that we really use our right IP here... */
2896                 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2897 }
2898
2899 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2900 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method)
2901 {
2902         struct sip_pvt *p;
2903
2904         p = malloc(sizeof(struct sip_pvt));
2905         if (!p)
2906                 return NULL;
2907         /* Keep track of stuff */
2908         memset(p, 0, sizeof(struct sip_pvt));
2909         ast_mutex_init(&p->lock);
2910
2911         p->method = intended_method;
2912         p->initid = -1;
2913         p->autokillid = -1;
2914         p->subscribed = NONE;
2915         p->stateid = -1;
2916         p->prefs = prefs;
2917         if (intended_method != SIP_OPTIONS)     /* Peerpoke has it's own system */
2918                 p->timer_t1 = 500;      /* Default SIP retransmission timer T1 (RFC 3261) */
2919 #ifdef OSP_SUPPORT
2920         p->osphandle = -1;
2921 #endif  
2922         if (sin) {
2923                 memcpy(&p->sa, sin, sizeof(p->sa));
2924                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2925                         memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2926         } else {
2927                 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2928         }
2929
2930         p->branch = rand();     
2931         p->tag = rand();
2932         /* Start with 101 instead of 1 */
2933         p->ocseq = 101;
2934
2935         if (sip_methods[intended_method].need_rtp) {
2936                 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2937                 if (videosupport)
2938                         p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2939                 if (!p->rtp) {
2940                         ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
2941                         ast_mutex_destroy(&p->lock);
2942                         if (p->chanvars) {
2943                                 ast_variables_destroy(p->chanvars);
2944                                 p->chanvars = NULL;
2945                         }
2946                         free(p);
2947                         return NULL;
2948                 }
2949                 ast_rtp_settos(p->rtp, tos);
2950                 if (p->vrtp)
2951                         ast_rtp_settos(p->vrtp, tos);
2952                 p->rtptimeout = global_rtptimeout;
2953                 p->rtpholdtimeout = global_rtpholdtimeout;
2954                 p->rtpkeepalive = global_rtpkeepalive;
2955         }
2956
2957         if (useglobal_nat && sin) {
2958                 /* Setup NAT structure according to global settings if we have an address */
2959                 ast_copy_flags(p, &global_flags, SIP_NAT);
2960                 memcpy(&p->recv, sin, sizeof(p->recv));
2961                 if (p->rtp)
2962                         ast_rtp_setnat(p->rtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2963                 if (p->vrtp)
2964                         ast_rtp_setnat(p->vrtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2965         }
2966
2967         if (p->method != SIP_REGISTER)
2968                 ast_copy_string(p->fromdomain, default_fromdomain, sizeof(p->fromdomain));
2969         build_via(p, p->via, sizeof(p->via));
2970         if (!callid)
2971                 build_callid(p->callid, sizeof(p->callid), p->ourip, p->fromdomain);
2972         else
2973                 ast_copy_string(p->callid, callid, sizeof(p->callid));
2974         ast_copy_flags(p, (&global_flags), SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_DTMF | SIP_REINVITE | SIP_PROG_INBAND | SIP_OSPAUTH);
2975         /* Assign default music on hold class */
2976         strcpy(p->musicclass, global_musicclass);
2977         p->capability = global_capability;
2978         if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_RFC2833) || (ast_test_flag(p, SIP_DTMF) == SIP_DTMF_AUTO))
2979                 p->noncodeccapability |= AST_RTP_DTMF;
2980         strcpy(p->context, default_context);
2981
2982         /* Add to active dialog list */
2983         ast_mutex_lock(&iflock);
2984         p->next = iflist;
2985         iflist = p;
2986         ast_mutex_unlock(&iflock);
2987         if (option_debug)
2988                 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");
2989         return p;
2990 }
2991
2992 /*--- find_call: Connect incoming SIP message to current dialog or create new dialog structure */
2993 /*               Called by handle_request ,sipsock_read */
2994 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
2995 {
2996         struct sip_pvt *p;
2997         char *callid;
2998         char tmp[256] = "";
2999         char *tag = "", *c;
3000
3001         callid = get_header(req, "Call-ID");
3002
3003         if (pedanticsipchecking) {
3004                 /* In principle Call-ID's uniquely identify a call, but with a forking SIP proxy
3005                    we need more to identify a branch - so we have to check branch, from
3006                    and to tags to identify a call leg.
3007                      For Asterisk to behave correctly, you need to turn on pedanticsipchecking
3008                    in sip.conf
3009                    */
3010                 if (req->method == SIP_RESPONSE)
3011                         ast_copy_string(tmp, get_header(req, "To"), sizeof(tmp));
3012                 else
3013                         ast_copy_string(tmp, get_header(req, "From"), sizeof(tmp));
3014                 tag = strcasestr(tmp, "tag=");
3015                 if (tag) {
3016                         tag += 4;
3017                         c = strchr(tag, ';');
3018                         if (c)
3019                                 *c = '\0';
3020                 }
3021                         
3022         }
3023                 
3024         ast_mutex_lock(&iflock);
3025         p = iflist;
3026         while(p) {
3027                 int found = 0;
3028                 if (req->method == SIP_REGISTER)
3029                         found = (!strcmp(p->callid, callid));
3030                 else 
3031                         found = (!strcmp(p->callid, callid) && 
3032                         (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) ;
3033                 if (found) {
3034                         /* Found the call */
3035                         ast_mutex_lock(&p->lock);
3036                         ast_mutex_unlock(&iflock);
3037                         return p;
3038                 }
3039                 p = p->next;
3040         }
3041         ast_mutex_unlock(&iflock);
3042         p = sip_alloc(callid, sin, 1, intended_method);
3043         if (p)
3044                 ast_mutex_lock(&p->lock);
3045         return p;
3046 }
3047
3048 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
3049 static int sip_register(char *value, int lineno)
3050 {
3051         struct sip_registry *reg;
3052         char copy[256] = "";
3053         char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
3054         char *porta=NULL;
3055         char *contact=NULL;
3056         char *stringp=NULL;
3057         
3058         if (!value)
3059                 return -1;
3060         ast_copy_string(copy, value, sizeof(copy));
3061         stringp=copy;
3062         username = stringp;
3063         hostname = strrchr(stringp, '@');
3064         if (hostname) {
3065                 *hostname = '\0';