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