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