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