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