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