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