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