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