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