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