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