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