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