only set the QOS variables if the pvt has an owner so that they are not
[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  * \todo VIA branch tag transaction checking
36  * \todo Transaction support
37  *
38  * \ingroup channel_drivers
39  *
40  * \par Overview of the handling of SIP sessions
41  * The SIP channel handles several types of SIP sessions, or dialogs,
42  * not all of them being "telephone calls".
43  * - Incoming calls that will be sent to the PBX core
44  * - Outgoing calls, generated by the PBX
45  * - SIP subscriptions and notifications of states and voicemail messages
46  * - SIP registrations, both inbound and outbound
47  * - SIP peer management (peerpoke, OPTIONS)
48  * - SIP text messages
49  *
50  * In the SIP channel, there's a list of active SIP dialogs, which includes
51  * all of these when they are active. "sip show channels" in the CLI will
52  * show most of these, excluding subscriptions which are shown by
53  * "sip show subscriptions"
54  *
55  * \par incoming packets
56  * Incoming packets are received in the monitoring thread, then handled by
57  * sipsock_read(). This function parses the packet and matches an existing
58  * dialog or starts a new SIP dialog.
59  * 
60  * sipsock_read sends the packet to handle_request(), that parses a bit more.
61  * if it's a response to an outbound request, it's sent to handle_response().
62  * If it is a request, handle_request sends it to one of a list of functions
63  * depending on the request type - INVITE, OPTIONS, REFER, BYE, CANCEL etc
64  * sipsock_read locks the ast_channel if it exists (an active call) and
65  * unlocks it after we have processed the SIP message.
66  *
67  * A new INVITE is sent to handle_request_invite(), that will end up
68  * starting a new channel in the PBX, the new channel after that executing
69  * in a separate channel thread. This is an incoming "call".
70  * When the call is answered, either by a bridged channel or the PBX itself
71  * the sip_answer() function is called.
72  *
73  * The actual media - Video or Audio - is mostly handled by the RTP subsystem
74  * in rtp.c 
75  * 
76  * \par Outbound calls
77  * Outbound calls are set up by the PBX through the sip_request_call()
78  * function. After that, they are activated by sip_call().
79  * 
80  * \par Hanging up
81  * The PBX issues a hangup on both incoming and outgoing calls through
82  * the sip_hangup() function
83  *
84  */
85
86
87 #include "asterisk.h"
88
89 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
90
91 #include <stdio.h>
92 #include <ctype.h>
93 #include <string.h>
94 #include <unistd.h>
95 #include <sys/socket.h>
96 #include <sys/ioctl.h>
97 #include <net/if.h>
98 #include <errno.h>
99 #include <stdlib.h>
100 #include <fcntl.h>
101 #include <netdb.h>
102 #include <signal.h>
103 #include <sys/signal.h>
104 #include <netinet/in.h>
105 #include <netinet/in_systm.h>
106 #include <arpa/inet.h>
107 #include <netinet/ip.h>
108 #include <regex.h>
109
110 #include "asterisk/lock.h"
111 #include "asterisk/channel.h"
112 #include "asterisk/config.h"
113 #include "asterisk/logger.h"
114 #include "asterisk/module.h"
115 #include "asterisk/pbx.h"
116 #include "asterisk/options.h"
117 #include "asterisk/lock.h"
118 #include "asterisk/sched.h"
119 #include "asterisk/io.h"
120 #include "asterisk/rtp.h"
121 #include "asterisk/acl.h"
122 #include "asterisk/manager.h"
123 #include "asterisk/callerid.h"
124 #include "asterisk/cli.h"
125 #include "asterisk/app.h"
126 #include "asterisk/musiconhold.h"
127 #include "asterisk/dsp.h"
128 #include "asterisk/features.h"
129 #include "asterisk/acl.h"
130 #include "asterisk/srv.h"
131 #include "asterisk/astdb.h"
132 #include "asterisk/causes.h"
133 #include "asterisk/utils.h"
134 #include "asterisk/file.h"
135 #include "asterisk/astobj.h"
136 #include "asterisk/dnsmgr.h"
137 #include "asterisk/devicestate.h"
138 #include "asterisk/linkedlists.h"
139 #include "asterisk/stringfields.h"
140 #include "asterisk/monitor.h"
141 #include "asterisk/localtime.h"
142 #include "asterisk/abstract_jb.h"
143
144 #ifndef FALSE
145 #define FALSE   0
146 #endif
147
148 #ifndef TRUE
149 #define TRUE 1
150 #endif
151
152 #define VIDEO_CODEC_MASK        0x1fc0000 /*!< Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
153 #ifndef IPTOS_MINCOST
154 #define IPTOS_MINCOST           0x02
155 #endif
156
157 /* #define VOCAL_DATA_HACK */
158
159 #define DEFAULT_DEFAULT_EXPIRY  120
160 #define DEFAULT_MIN_EXPIRY      60
161 #define DEFAULT_MAX_EXPIRY      3600
162 #define DEFAULT_REGISTRATION_TIMEOUT    20
163 #define DEFAULT_MAX_FORWARDS    "70"
164
165 /* guard limit must be larger than guard secs */
166 /* guard min must be < 1000, and should be >= 250 */
167 #define EXPIRY_GUARD_SECS       15              /*!< How long before expiry do we reregister */
168 #define EXPIRY_GUARD_LIMIT      30              /*!< Below here, we use EXPIRY_GUARD_PCT instead of 
169                                                   EXPIRY_GUARD_SECS */
170 #define EXPIRY_GUARD_MIN        500             /*!< This is the minimum guard time applied. If 
171                                                   GUARD_PCT turns out to be lower than this, it 
172                                                    will use this time instead.
173                                                    This is in milliseconds. */
174 #define EXPIRY_GUARD_PCT        0.20            /*!< Percentage of expires timeout to use when 
175                                                    below EXPIRY_GUARD_LIMIT */
176 #define DEFAULT_EXPIRY 900                      /*!< Expire slowly */
177
178 static int min_expiry = DEFAULT_MIN_EXPIRY;     /*!< Minimum accepted registration time */
179 static int max_expiry = DEFAULT_MAX_EXPIRY;     /*!< Maximum accepted registration time */
180 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
181 static int expiry = DEFAULT_EXPIRY;
182
183 #ifndef MAX
184 #define MAX(a,b) ((a) > (b) ? (a) : (b))
185 #endif
186
187 #define CALLERID_UNKNOWN        "Unknown"
188
189 #define DEFAULT_MAXMS           2000            /*!< Qualification: Must be faster than 2 seconds by default */
190 #define DEFAULT_FREQ_OK         60 * 1000       /*!< Qualification: How often to check for the host to be up */
191 #define DEFAULT_FREQ_NOTOK      10 * 1000       /*!< Qualification: How often to check, if the host is down... */
192
193 #define DEFAULT_RETRANS         1000            /*!< How frequently to retransmit Default: 2 * 500 ms in RFC 3261 */
194 #define MAX_RETRANS             6               /*!< Try only 6 times for retransmissions, a total of 7 transmissions */
195 #define SIP_TRANS_TIMEOUT       32000           /*!< SIP request timeout (rfc 3261) 64*T1 
196                                                 \todo Use known T1 for timeout (peerpoke)
197                                                 */
198 #define MAX_AUTHTRIES           3               /*!< Try authentication three times, then fail */
199
200 #define SIP_MAX_HEADERS         64                      /*!< Max amount of SIP headers to read */
201 #define SIP_MAX_LINES           64                      /*!< Max amount of lines in SIP attachment (like SDP) */
202 #define SIP_MAX_PACKET          4096    /*!< Also from RFC 3261 (2543), should sub headers tho */
203
204 #define INITIAL_CSEQ            101     /*!< our initial sip sequence number */
205
206 /*! Global jitterbuffer configuration - by default, jb is disabled */
207 static struct ast_jb_conf default_jbconf =
208 {
209         .flags = 0,
210         .max_size = -1,
211         .resync_threshold = -1,
212         .impl = ""
213 };
214 static struct ast_jb_conf global_jbconf;
215
216 static const char tdesc[] = "Session Initiation Protocol (SIP)";
217 static const char config[] = "sip.conf";
218 static const char notify_config[] = "sip_notify.conf";
219 static int usecnt = 0;
220
221
222 #define RTP     1
223 #define NO_RTP  0
224
225 /*! \brief Authorization scheme for call transfers 
226 \note Not a bitfield flag, since there are plans for other modes,
227         like "only allow transfers for authenticated devices" */
228 enum transfermodes {
229         TRANSFER_OPENFORALL,            /*!< Allow all SIP transfers */
230         TRANSFER_CLOSED,                /*!< Allow no SIP transfers */
231 };
232
233
234 enum sip_result {
235         AST_SUCCESS = 0,
236         AST_FAILURE = -1,
237 };
238
239 /* Do _NOT_ make any changes to this enum, or the array following it;
240    if you think you are doing the right thing, you are probably
241    not doing the right thing. If you think there are changes
242    needed, get someone else to review them first _before_
243    submitting a patch. If these two lists do not match properly
244    bad things will happen.
245 */
246
247 enum xmittype {
248         XMIT_CRITICAL = 2,              /*!< Transmit critical SIP message reliably, with re-transmits.
249                                                         If it fails, it's critical and will cause a teardown of the session */
250         XMIT_RELIABLE = 1,              /*!< Transmit SIP message reliably, with re-transmits */
251         XMIT_UNRELIABLE = 0,            /*!< Transmit SIP message without bothering with re-transmits */
252 };
253
254 enum subscriptiontype { 
255         NONE = 0,
256         TIMEOUT,
257         XPIDF_XML,
258         DIALOG_INFO_XML,
259         CPIM_PIDF_XML,
260         PIDF_XML,
261         MWI_NOTIFICATION
262 };
263
264 enum parse_register_result {
265         PARSE_REGISTER_FAILED,
266         PARSE_REGISTER_UPDATE,
267         PARSE_REGISTER_QUERY,
268 };
269
270
271 static const struct cfsubscription_types {
272         enum subscriptiontype type;
273         const char * const event;
274         const char * const mediatype;
275         const char * const text;
276 } subscription_types[] = {
277         { NONE,            "-",        "unknown",                    "unknown" },
278         /* IETF draft: draft-ietf-sipping-dialog-package-05.txt */
279         { DIALOG_INFO_XML, "dialog",   "application/dialog-info+xml", "dialog-info+xml" },
280         { CPIM_PIDF_XML,   "presence", "application/cpim-pidf+xml",   "cpim-pidf+xml" },  /* RFC 3863 */
281         { PIDF_XML,        "presence", "application/pidf+xml",        "pidf+xml" },       /* RFC 3863 */
282         { XPIDF_XML,       "presence", "application/xpidf+xml",       "xpidf+xml" },       /* Pre-RFC 3863 with MS additions */
283         { MWI_NOTIFICATION,     "message-summary", "application/simple-message-summary", "mwi" } /* RFC 3842: Mailbox notification */
284 };
285
286 /*! \brief SIP Request methods known by Asterisk */
287 enum sipmethod {
288         SIP_UNKNOWN,            /* Unknown response */
289         SIP_RESPONSE,           /* Not request, response to outbound request */
290         SIP_REGISTER,
291         SIP_OPTIONS,
292         SIP_NOTIFY,
293         SIP_INVITE,
294         SIP_ACK,
295         SIP_PRACK,              /* Not supported at all */
296         SIP_BYE,
297         SIP_REFER,
298         SIP_SUBSCRIBE,
299         SIP_MESSAGE,
300         SIP_UPDATE,             /* We can send UPDATE; but not accept it */
301         SIP_INFO,
302         SIP_CANCEL,
303         SIP_PUBLISH,            /* Not supported at all */
304 };
305
306 /*! \brief Authentication types - proxy or www authentication 
307         \note Endpoints, like Asterisk, should always use WWW authentication to
308         allow multiple authentications in the same call - to the proxy and
309         to the end point.
310 */
311 enum sip_auth_type {
312         PROXY_AUTH,
313         WWW_AUTH,
314 };
315
316 /*! \brief Authentication result from check_auth* functions */
317 enum check_auth_result {
318         AUTH_SUCCESSFUL = 0,
319         AUTH_CHALLENGE_SENT = 1,
320         AUTH_SECRET_FAILED = -1,
321         AUTH_USERNAME_MISMATCH = -2,
322         AUTH_NOT_FOUND = -3,
323         AUTH_FAKE_AUTH = -4,
324         AUTH_UNKNOWN_DOMAIN = -5,
325 };
326
327 /* States for outbound registrations (with register= lines in sip.conf */
328 enum sipregistrystate {
329         REG_STATE_UNREGISTERED = 0,     /*!< We are not registred */
330         REG_STATE_REGSENT,      /*!< Registration request sent */
331         REG_STATE_AUTHSENT,     /*!< We have tried to authenticate */
332         REG_STATE_REGISTERED,   /*!< Registred and done */
333         REG_STATE_REJECTED,     /*!< Registration rejected */
334         REG_STATE_TIMEOUT,      /*!< Registration timed out */
335         REG_STATE_NOAUTH,       /*!< We have no accepted credentials */
336         REG_STATE_FAILED,       /*!< Registration failed after several tries */
337 };
338
339
340 /*! XXX Note that sip_methods[i].id == i must hold or the code breaks */
341 static const struct  cfsip_methods { 
342         enum sipmethod id;
343         int need_rtp;           /*!< when this is the 'primary' use for a pvt structure, does it need RTP? */
344         char * const text;
345 } sip_methods[] = {
346         { SIP_UNKNOWN,   RTP,    "-UNKNOWN-" },
347         { SIP_RESPONSE,  NO_RTP, "SIP/2.0" },
348         { SIP_REGISTER,  NO_RTP, "REGISTER" },
349         { SIP_OPTIONS,   NO_RTP, "OPTIONS" },
350         { SIP_NOTIFY,    NO_RTP, "NOTIFY" },
351         { SIP_INVITE,    RTP,    "INVITE" },
352         { SIP_ACK,       NO_RTP, "ACK" },
353         { SIP_PRACK,     NO_RTP, "PRACK" },
354         { SIP_BYE,       NO_RTP, "BYE" },
355         { SIP_REFER,     NO_RTP, "REFER" },
356         { SIP_SUBSCRIBE, NO_RTP, "SUBSCRIBE" },
357         { SIP_MESSAGE,   NO_RTP, "MESSAGE" },
358         { SIP_UPDATE,    NO_RTP, "UPDATE" },
359         { SIP_INFO,      NO_RTP, "INFO" },
360         { SIP_CANCEL,    NO_RTP, "CANCEL" },
361         { SIP_PUBLISH,   NO_RTP, "PUBLISH" }
362 };
363
364 /*!  Define SIP option tags, used in Require: and Supported: headers 
365         We need to be aware of these properties in the phones to use 
366         the replace: header. We should not do that without knowing
367         that the other end supports it... 
368         This is nothing we can configure, we learn by the dialog
369         Supported: header on the REGISTER (peer) or the INVITE
370         (other devices)
371         We are not using many of these today, but will in the future.
372         This is documented in RFC 3261
373 */
374 #define SUPPORTED               1
375 #define NOT_SUPPORTED           0
376
377 #define SIP_OPT_REPLACES        (1 << 0)
378 #define SIP_OPT_100REL          (1 << 1)
379 #define SIP_OPT_TIMER           (1 << 2)
380 #define SIP_OPT_EARLY_SESSION   (1 << 3)
381 #define SIP_OPT_JOIN            (1 << 4)
382 #define SIP_OPT_PATH            (1 << 5)
383 #define SIP_OPT_PREF            (1 << 6)
384 #define SIP_OPT_PRECONDITION    (1 << 7)
385 #define SIP_OPT_PRIVACY         (1 << 8)
386 #define SIP_OPT_SDP_ANAT        (1 << 9)
387 #define SIP_OPT_SEC_AGREE       (1 << 10)
388 #define SIP_OPT_EVENTLIST       (1 << 11)
389 #define SIP_OPT_GRUU            (1 << 12)
390 #define SIP_OPT_TARGET_DIALOG   (1 << 13)
391
392 /*! \brief List of well-known SIP options. If we get this in a require,
393    we should check the list and answer accordingly. */
394 static const struct cfsip_options {
395         int id;                 /*!< Bitmap ID */
396         int supported;          /*!< Supported by Asterisk ? */
397         char * const text;      /*!< Text id, as in standard */
398 } sip_options[] = {     /* XXX used in 3 places */
399         /* Replaces: header for transfer */
400         { SIP_OPT_REPLACES,     SUPPORTED,      "replaces" },   
401         /* One version of Polycom firmware has the wrong label */
402         { SIP_OPT_REPLACES,     SUPPORTED,      "replace" },    
403         /* RFC3262: PRACK 100% reliability */
404         { SIP_OPT_100REL,       NOT_SUPPORTED,  "100rel" },     
405         /* SIP Session Timers */
406         { SIP_OPT_TIMER,        NOT_SUPPORTED,  "timer" },
407         /* RFC3959: SIP Early session support */
408         { SIP_OPT_EARLY_SESSION, NOT_SUPPORTED, "early-session" },
409         /* SIP Join header support */
410         { SIP_OPT_JOIN,         NOT_SUPPORTED,  "join" },
411         /* RFC3327: Path support */
412         { SIP_OPT_PATH,         NOT_SUPPORTED,  "path" },
413         /* RFC3840: Callee preferences */
414         { SIP_OPT_PREF,         NOT_SUPPORTED,  "pref" },
415         /* RFC3312: Precondition support */
416         { SIP_OPT_PRECONDITION, NOT_SUPPORTED,  "precondition" },
417         /* RFC3323: Privacy with proxies*/
418         { SIP_OPT_PRIVACY,      NOT_SUPPORTED,  "privacy" },
419         /* RFC4092: Usage of the SDP ANAT Semantics in the SIP */
420         { SIP_OPT_SDP_ANAT,     NOT_SUPPORTED,  "sdp-anat" },
421         /* RFC3329: Security agreement mechanism */
422         { SIP_OPT_SEC_AGREE,    NOT_SUPPORTED,  "sec_agree" },
423         /* SIMPLE events:  draft-ietf-simple-event-list-07.txt */
424         { SIP_OPT_EVENTLIST,    NOT_SUPPORTED,  "eventlist" },
425         /* GRUU: Globally Routable User Agent URI's */
426         { SIP_OPT_GRUU,         NOT_SUPPORTED,  "gruu" },
427         /* Target-dialog: draft-ietf-sip-target-dialog-00.txt */
428         { SIP_OPT_TARGET_DIALOG,NOT_SUPPORTED,  "target-dialog" },
429 };
430
431
432 /*! \brief SIP Methods we support */
433 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY"
434
435 /*! \brief SIP Extensions we support */
436 #define SUPPORTED_EXTENSIONS "replaces" 
437
438
439 /* Default values, set and reset in reload_config before reading configuration */
440 /* These are default values in the source. There are other recommended values in the
441    sip.conf.sample for new installations. These may differ to keep backwards compatibility,
442    yet encouraging new behaviour on new installations 
443  */
444 #define DEFAULT_SIP_PORT        5060    /*!< From RFC 3261 (former 2543) */
445 #define DEFAULT_CONTEXT         "default"
446 #define DEFAULT_MUSICCLASS      "default"
447 #define DEFAULT_VMEXTEN         "asterisk"
448 #define DEFAULT_CALLERID        "asterisk"
449 #define DEFAULT_NOTIFYMIME      "application/simple-message-summary"
450 #define DEFAULT_MWITIME         10
451 #define DEFAULT_ALLOWGUEST      TRUE
452 #define DEFAULT_SRVLOOKUP       FALSE           /*!< Recommended setting is ON */
453 #define DEFAULT_COMPACTHEADERS  FALSE
454 #define DEFAULT_TOS_SIP         0               /*!< Call signalling packets should be marked as DSCP CS3, but the default is 0 to be compatible with previous versions. */
455 #define DEFAULT_TOS_AUDIO       0               /*!< Audio packets should be marked as DSCP EF (Expedited Forwarding), but the default is 0 to be compatible with previous versions. */
456 #define DEFAULT_TOS_VIDEO       0               /*!< Video packets should be marked as DSCP AF41, but the default is 0 to be compatible with previous versions. */
457 #define DEFAULT_ALLOW_EXT_DOM   TRUE
458 #define DEFAULT_REALM           "asterisk"
459 #define DEFAULT_NOTIFYRINGING   TRUE
460 #define DEFAULT_PEDANTIC        FALSE
461 #define DEFAULT_AUTOCREATEPEER  FALSE
462 #define DEFAULT_QUALIFY         FALSE
463 #define DEFAULT_T1MIN           100             /*!< 100 MS for minimal roundtrip time */
464 #define DEFAULT_MAX_CALL_BITRATE (384)          /*!< Max bitrate for video */
465 #ifndef DEFAULT_USERAGENT
466 #define DEFAULT_USERAGENT "Asterisk PBX"        /*!< Default Useragent: header unless re-defined in sip.conf */
467 #endif
468
469
470 /* Default setttings are used as a channel setting and as a default when
471    configuring devices */
472 static char default_context[AST_MAX_CONTEXT];
473 static char default_subscribecontext[AST_MAX_CONTEXT];
474 static char default_language[MAX_LANGUAGE];
475 static char default_callerid[AST_MAX_EXTENSION];
476 static char default_fromdomain[AST_MAX_EXTENSION];
477 static char default_notifymime[AST_MAX_EXTENSION];
478 static int default_qualify;             /*!< Default Qualify= setting */
479 static char default_vmexten[AST_MAX_EXTENSION];
480 static char default_musicclass[MAX_MUSICCLASS];         /*!< Global music on hold class */
481 static int default_maxcallbitrate;      /*!< Maximum bitrate for call */
482 static struct ast_codec_pref default_prefs;             /*!< Default codec prefs */
483
484 /* Global settings only apply to the channel */
485 static int global_rtautoclear;
486 static int global_notifyringing;        /*!< Send notifications on ringing */
487 static int global_alwaysauthreject;     /*!< Send 401 Unauthorized for all failing requests */
488 static int srvlookup;                   /*!< SRV Lookup on or off. Default is off, RFC behavior is on */
489 static int pedanticsipchecking;         /*!< Extra checking ?  Default off */
490 static int autocreatepeer;              /*!< Auto creation of peers at registration? Default off. */
491 static int global_relaxdtmf;                    /*!< Relax DTMF */
492 static int global_rtptimeout;           /*!< Time out call if no RTP */
493 static int global_rtpholdtimeout;
494 static int global_rtpkeepalive;         /*!< Send RTP keepalives */
495 static int global_reg_timeout;  
496 static int global_regattempts_max;      /*!< Registration attempts before giving up */
497 static int global_allowguest;           /*!< allow unauthenticated users/peers to connect? */
498 static int global_allowsubscribe;       /*!< Flag for disabling ALL subscriptions, this is FALSE only if all peers are FALSE 
499                                             the global setting is in globals_flags[1] */
500 static int global_mwitime;              /*!< Time between MWI checks for peers */
501 static int global_tos_sip;              /*!< IP type of service for SIP packets */
502 static int global_tos_audio;            /*!< IP type of service for audio RTP packets */
503 static int global_tos_video;            /*!< IP type of service for video RTP packets */
504 static int compactheaders;              /*!< send compact sip headers */
505 static int recordhistory;               /*!< Record SIP history. Off by default */
506 static int dumphistory;                 /*!< Dump history to verbose before destroying SIP dialog */
507 static char global_realm[MAXHOSTNAMELEN];               /*!< Default realm */
508 static char global_regcontext[AST_MAX_CONTEXT];         /*!< Context for auto-extensions */
509 static char global_useragent[AST_MAX_EXTENSION];        /*!< Useragent for the SIP channel */
510 static int allow_external_domains;      /*!< Accept calls to external SIP domains? */
511 static int global_callevents;           /*!< Whether we send manager events or not */
512 static int global_t1min;                /*!< T1 roundtrip time minimum */
513 static enum transfermodes global_allowtransfer; /*!< SIP Refer restriction scheme */
514
515 /*! \brief Codecs that we support by default: */
516 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
517 static int noncodeccapability = AST_RTP_DTMF;
518
519 /* Object counters */
520 static int suserobjs = 0;               /*!< Static users */
521 static int ruserobjs = 0;               /*!< Realtime users */
522 static int speerobjs = 0;               /*!< Statis peers */
523 static int rpeerobjs = 0;               /*!< Realtime peers */
524 static int apeerobjs = 0;               /*!< Autocreated peer objects */
525 static int regobjs = 0;                 /*!< Registry objects */
526
527 static struct ast_flags global_flags[2] = {{0}};        /*!< global SIP_ flags */
528
529 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
530
531 /*! \brief Protect the SIP dialog list (of sip_pvt's) */
532 AST_MUTEX_DEFINE_STATIC(iflock);
533
534 /*! \brief Protect the monitoring thread, so only one process can kill or start it, and not
535    when it's doing something critical. */
536 AST_MUTEX_DEFINE_STATIC(netlock);
537
538 AST_MUTEX_DEFINE_STATIC(monlock);
539
540 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
541
542 /*! \brief This is the thread for the monitor which checks for input on the channels
543    which are not currently in use.  */
544 static pthread_t monitor_thread = AST_PTHREADT_NULL;
545
546 static int sip_reloading = FALSE;                       /*!< Flag for avoiding multiple reloads at the same time */
547 static enum channelreloadreason sip_reloadreason;       /*!< Reason for last reload/load of configuration */
548
549 static struct sched_context *sched;     /*!< The scheduling context */
550 static struct io_context *io;           /*!< The IO context */
551
552 #define DEC_CALL_LIMIT  0
553 #define INC_CALL_LIMIT  1
554 #define DEC_CALL_RINGING 2
555 #define INC_CALL_RINGING 3
556
557 /*! \brief sip_request: The data grabbed from the UDP socket */
558 struct sip_request {
559         char *rlPart1;          /*!< SIP Method Name or "SIP/2.0" protocol version */
560         char *rlPart2;          /*!< The Request URI or Response Status */
561         int len;                /*!< Length */
562         int headers;            /*!< # of SIP Headers */
563         int method;             /*!< Method of this request */
564         int lines;              /*!< Body Content */
565         unsigned int flags;     /*!< SIP_PKT Flags for this packet */
566         char *header[SIP_MAX_HEADERS];
567         char *line[SIP_MAX_LINES];
568         char data[SIP_MAX_PACKET];
569         unsigned int sdp_start; /*!< the line number where the SDP begins */
570         unsigned int sdp_end;   /*!< the line number where the SDP ends */
571 };
572
573 /*
574  * A sip packet is stored into the data[] buffer, with the header followed
575  * by an empty line and the body of the message.
576  * On outgoing packets, data is accumulated in data[] with len reflecting
577  * the next available byte, headers and lines count the number of lines
578  * in both parts. There are no '\0' in data[0..len-1].
579  *
580  * On received packet, the input read from the socket is copied into data[],
581  * len is set and the string is NUL-terminated. Then a parser fills up
582  * the other fields -header[] and line[] to point to the lines of the
583  * message, rlPart1 and rlPart2 parse the first lnie as below:
584  *
585  * Requests have in the first line      METHOD URI SIP/2.0
586  *      rlPart1 = method; rlPart2 = uri;
587  * Responses have in the first line     SIP/2.0 code description
588  *      rlPart1 = SIP/2.0; rlPart2 = code + description;
589  *
590  */
591
592 /*! \brief structure used in transfers */
593 struct sip_dual {
594         struct ast_channel *chan1;      /*!< First channel involved */
595         struct ast_channel *chan2;      /*!< Second channel involved */
596         struct sip_request req;         /*!< Request that caused the transfer (REFER) */
597         int seqno;                      /*!< Sequence number */
598 };
599
600 struct sip_pkt;
601
602 /*! \brief Parameters to the transmit_invite function */
603 struct sip_invite_param {
604         const char *distinctive_ring;   /*!< Distinctive ring header */
605         int addsipheaders;              /*!< Add extra SIP headers */
606         const char *uri_options;        /*!< URI options to add to the URI */
607         const char *vxml_url;           /*!< VXML url for Cisco phones */
608         char *auth;                     /*!< Authentication */
609         char *authheader;               /*!< Auth header */
610         enum sip_auth_type auth_type;   /*!< Authentication type */
611         const char *replaces;           /*!< Replaces header for call transfers */
612         int transfer;                   /*!< Flag - is this Invite part of a SIP transfer? (invite/replaces) */
613 };
614
615 /*! \brief Structure to save routing information for a SIP session */
616 struct sip_route {
617         struct sip_route *next;
618         char hop[0];
619 };
620
621 /*! \brief Modes for SIP domain handling in the PBX */
622 enum domain_mode {
623         SIP_DOMAIN_AUTO,                /*!< This domain is auto-configured */
624         SIP_DOMAIN_CONFIG,              /*!< This domain is from configuration */
625 };
626
627 struct domain {
628         char domain[MAXHOSTNAMELEN];            /*!< SIP domain we are responsible for */
629         char context[AST_MAX_EXTENSION];        /*!< Incoming context for this domain */
630         enum domain_mode mode;                  /*!< How did we find this domain? */
631         AST_LIST_ENTRY(domain) list;            /*!< List mechanics */
632 };
633
634 static AST_LIST_HEAD_STATIC(domain_list, domain);       /*!< The SIP domain list */
635
636
637 /*! \brief sip_history: Structure for saving transactions within a SIP dialog */
638 struct sip_history {
639         AST_LIST_ENTRY(sip_history) list;
640         char event[0];  /* actually more, depending on needs */
641 };
642
643 AST_LIST_HEAD_NOLOCK(sip_history_head, sip_history); /*!< history list, entry in sip_pvt */
644
645 /*! \brief sip_auth: Creadentials for authentication to other SIP services */
646 struct sip_auth {
647         char realm[AST_MAX_EXTENSION];  /*!< Realm in which these credentials are valid */
648         char username[256];             /*!< Username */
649         char secret[256];               /*!< Secret */
650         char md5secret[256];            /*!< MD5Secret */
651         struct sip_auth *next;          /*!< Next auth structure in list */
652 };
653
654 /*--- Various flags for the flags field in the pvt structure */
655 #define SIP_ALREADYGONE         (1 << 0)        /*!< Whether or not we've already been destroyed by our peer */
656 #define SIP_NEEDDESTROY         (1 << 1)        /*!< if we need to be destroyed by the monitor thread */
657 #define SIP_NOVIDEO             (1 << 2)        /*!< Didn't get video in invite, don't offer */
658 #define SIP_RINGING             (1 << 3)        /*!< Have sent 180 ringing */
659 #define SIP_PROGRESS_SENT       (1 << 4)        /*!< Have sent 183 message progress */
660 #define SIP_NEEDREINVITE        (1 << 5)        /*!< Do we need to send another reinvite? */
661 #define SIP_PENDINGBYE          (1 << 6)        /*!< Need to send bye after we ack? */
662 #define SIP_GOTREFER            (1 << 7)        /*!< Got a refer? */
663 #define SIP_PROMISCREDIR        (1 << 8)        /*!< Promiscuous redirection */
664 #define SIP_TRUSTRPID           (1 << 9)        /*!< Trust RPID headers? */
665 #define SIP_USEREQPHONE         (1 << 10)       /*!< Add user=phone to numeric URI. Default off */
666 #define SIP_REALTIME            (1 << 11)       /*!< Flag for realtime users */
667 #define SIP_USECLIENTCODE       (1 << 12)       /*!< Trust X-ClientCode info message */
668 #define SIP_OUTGOING            (1 << 13)       /*!< Is this an outgoing call? */
669 #define SIP_CAN_BYE             (1 << 14)       /*!< Can we send BYE on this dialog? */
670 #define SIP_DEFER_BYE_ON_TRANSFER       (1 << 15)       /*!< Do not hangup at first ast_hangup */
671 #define SIP_DTMF                (3 << 16)       /*!< DTMF Support: four settings, uses two bits */
672 #define SIP_DTMF_RFC2833        (0 << 16)       /*!< DTMF Support: RTP DTMF - "rfc2833" */
673 #define SIP_DTMF_INBAND         (1 << 16)       /*!< DTMF Support: Inband audio, only for ULAW/ALAW - "inband" */
674 #define SIP_DTMF_INFO           (2 << 16)       /*!< DTMF Support: SIP Info messages - "info" */
675 #define SIP_DTMF_AUTO           (3 << 16)       /*!< DTMF Support: AUTO switch between rfc2833 and in-band DTMF */
676 /* NAT settings */
677 #define SIP_NAT                 (3 << 18)       /*!< four settings, uses two bits */
678 #define SIP_NAT_NEVER           (0 << 18)       /*!< No nat support */
679 #define SIP_NAT_RFC3581         (1 << 18)       /*!< NAT RFC3581 */
680 #define SIP_NAT_ROUTE           (2 << 18)       /*!< NAT Only ROUTE */
681 #define SIP_NAT_ALWAYS          (3 << 18)       /*!< NAT Both ROUTE and RFC3581 */
682 /* re-INVITE related settings */
683 #define SIP_REINVITE            (7 << 20)       /*!< three bits used */
684 #define SIP_CAN_REINVITE        (1 << 20)       /*!< allow peers to be reinvited to send media directly p2p */
685 #define SIP_CAN_REINVITE_NAT    (2 << 20)       /*!< allow media reinvite when new peer is behind NAT */
686 #define SIP_REINVITE_UPDATE     (4 << 20)       /*!< use UPDATE (RFC3311) when reinviting this peer */
687 /* "insecure" settings */
688 #define SIP_INSECURE_PORT       (1 << 23)       /*!< don't require matching port for incoming requests */
689 #define SIP_INSECURE_INVITE     (1 << 24)       /*!< don't require authentication for incoming INVITEs */
690 /* Sending PROGRESS in-band settings */
691 #define SIP_PROG_INBAND         (3 << 25)       /*!< three settings, uses two bits */
692 #define SIP_PROG_INBAND_NEVER   (0 << 25)
693 #define SIP_PROG_INBAND_NO      (1 << 25)
694 #define SIP_PROG_INBAND_YES     (2 << 25)
695 #define SIP_CALL_ONHOLD         (1 << 27)       /*!< Call states */
696 #define SIP_CALL_LIMIT          (1 << 28)       /*!< Call limit enforced for this call */
697 #define SIP_SENDRPID            (1 << 29)       /*!< Remote Party-ID Support */
698 #define SIP_INC_COUNT           (1 << 30)       /*!< Did this connection increment the counter of in-use calls? */
699
700 #define SIP_FLAGS_TO_COPY \
701         (SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_SENDRPID | SIP_DTMF | SIP_REINVITE | \
702          SIP_PROG_INBAND | SIP_USECLIENTCODE | SIP_NAT | \
703          SIP_USEREQPHONE | SIP_INSECURE_PORT | SIP_INSECURE_INVITE)
704
705 /* a new page of flags for peers */
706 #define SIP_PAGE2_RTCACHEFRIENDS        (1 << 0)
707 #define SIP_PAGE2_RTUPDATE              (1 << 1)
708 #define SIP_PAGE2_RTAUTOCLEAR           (1 << 2)
709 #define SIP_PAGE2_IGNOREREGEXPIRE       (1 << 3)
710 #define SIP_PAGE2_RT_FROMCONTACT        (1 << 4)
711 #define SIP_PAGE2_DEBUG                 (3 << 5)
712 #define SIP_PAGE2_DEBUG_CONFIG          (1 << 5)
713 #define SIP_PAGE2_DEBUG_CONSOLE         (1 << 6)
714 #define SIP_PAGE2_DYNAMIC               (1 << 7)        /*!< Dynamic Peers register with Asterisk */
715 #define SIP_PAGE2_SELFDESTRUCT          (1 << 8)        /*!< Automatic peers need to destruct themselves */
716 #define SIP_PAGE2_VIDEOSUPPORT          (1 << 9)
717 #define SIP_PAGE2_ALLOWSUBSCRIBE        (1 << 10)       /*!< Allow subscriptions from this peer? */
718 #define SIP_PAGE2_ALLOWOVERLAP          (1 << 11)       /*!< Allow overlap dialing ? */
719 #define SIP_PAGE2_SUBSCRIBEMWIONLY      (1 << 12)       /*!< Only issue MWI notification if subscribed to */
720 #define SIP_PAGE2_INC_RINGING           (1 << 13)       /*!< Did this connection increment the counter of in-use calls? */
721
722 #define SIP_PAGE2_FLAGS_TO_COPY \
723         (SIP_PAGE2_ALLOWSUBSCRIBE | SIP_PAGE2_ALLOWOVERLAP | SIP_PAGE2_VIDEOSUPPORT)
724
725 /* SIP packet flags */
726 #define SIP_PKT_DEBUG           (1 << 0)        /*!< Debug this packet */
727 #define SIP_PKT_WITH_TOTAG      (1 << 1)        /*!< This packet has a to-tag */
728 #define SIP_PKT_IGNORE          (1 << 2)        /*!< This is a re-transmit, ignore it */
729 #define SIP_PKT_IGNORE_RESP     (1 << 3)        /*!< Resp ignore - ??? */
730 #define SIP_PKT_IGNORE_REQ      (1 << 4)        /*!< Req ignore - ??? */
731
732 #define sipdebug                ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG)
733 #define sipdebug_config         ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG)
734 #define sipdebug_console        ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE)
735
736 /*! \brief Parameters to know status of transfer */
737 enum referstatus {
738         REFER_IDLE,             /*!< No REFER is in progress */
739         REFER_SENT,             /*!< Sent REFER to transferee */
740         REFER_RECEIVED,         /*!< Received REFER from transferer */
741         REFER_CONFIRMED,        /*!< Refer confirmed with a 100 TRYING */
742         REFER_ACCEPTED,         /*!< Accepted by transferee */
743         REFER_RINGING,          /*!< Target Ringing */
744         REFER_200OK,            /*!< Answered by transfer target */
745         REFER_FAILED,           /*!< REFER declined - go on */
746         REFER_NOAUTH            /*!< We had no auth for REFER */
747 };
748
749 static const struct c_referstatusstring {
750         enum referstatus status;
751         char *text;
752 } referstatusstrings[] = {
753         { REFER_IDLE,           "<none>" },
754         { REFER_SENT,           "Request sent" },
755         { REFER_RECEIVED,       "Request received" },
756         { REFER_ACCEPTED,       "Accepted" },
757         { REFER_RINGING,        "Target ringing" },
758         { REFER_200OK,          "Done" },
759         { REFER_FAILED,         "Failed" },
760         { REFER_NOAUTH,         "Failed - auth failure" }
761 } ;
762
763 /*! \brief Structure to handle SIP transfers. Dynamically allocated when needed  */
764 /* OEJ: Should be moved to string fields */
765 struct sip_refer {
766         char refer_to[AST_MAX_EXTENSION];               /*!< Place to store REFER-TO extension */
767         char refer_to_domain[AST_MAX_EXTENSION];        /*!< Place to store REFER-TO domain */
768         char refer_to_urioption[AST_MAX_EXTENSION];     /*!< Place to store REFER-TO uri options */
769         char refer_to_context[AST_MAX_EXTENSION];       /*!< Place to store REFER-TO context */
770         char referred_by[AST_MAX_EXTENSION];            /*!< Place to store REFERRED-BY extension */
771         char referred_by_name[AST_MAX_EXTENSION];       /*!< Place to store REFERRED-BY extension */
772         char refer_contact[AST_MAX_EXTENSION];          /*!< Place to store Contact info from a REFER extension */
773         char replaces_callid[BUFSIZ];                   /*!< Replace info */
774         char replaces_callid_totag[BUFSIZ/2];           /*!< Replace info */
775         char replaces_callid_fromtag[BUFSIZ/2];         /*!< Replace info */
776         struct sip_pvt *refer_call;                     /*!< Call we are referring */
777         int attendedtransfer;                           /*!< Attended or blind transfer? */
778         int localtransfer;                              /*!< Transfer to local domain? */
779         enum referstatus status;                        /*!< REFER status */
780 };
781
782 /*! \brief sip_pvt: PVT structures are used for each SIP dialog, ie. a call, a registration, a subscribe  */
783 static struct sip_pvt {
784         ast_mutex_t lock;                       /*!< Dialog private lock */
785         int method;                             /*!< SIP method that opened this dialog */
786         AST_DECLARE_STRING_FIELDS(
787                 AST_STRING_FIELD(callid);       /*!< Global CallID */
788                 AST_STRING_FIELD(randdata);     /*!< Random data */
789                 AST_STRING_FIELD(accountcode);  /*!< Account code */
790                 AST_STRING_FIELD(realm);        /*!< Authorization realm */
791                 AST_STRING_FIELD(nonce);        /*!< Authorization nonce */
792                 AST_STRING_FIELD(opaque);       /*!< Opaque nonsense */
793                 AST_STRING_FIELD(qop);          /*!< Quality of Protection, since SIP wasn't complicated enough yet. */
794                 AST_STRING_FIELD(domain);       /*!< Authorization domain */
795                 AST_STRING_FIELD(from);         /*!< The From: header */
796                 AST_STRING_FIELD(useragent);    /*!< User agent in SIP request */
797                 AST_STRING_FIELD(exten);        /*!< Extension where to start */
798                 AST_STRING_FIELD(context);      /*!< Context for this call */
799                 AST_STRING_FIELD(subscribecontext); /*!< Subscribecontext */
800                 AST_STRING_FIELD(subscribeuri); /*!< Subscribecontext */
801                 AST_STRING_FIELD(fromdomain);   /*!< Domain to show in the from field */
802                 AST_STRING_FIELD(fromuser);     /*!< User to show in the user field */
803                 AST_STRING_FIELD(fromname);     /*!< Name to show in the user field */
804                 AST_STRING_FIELD(tohost);       /*!< Host we should put in the "to" field */
805                 AST_STRING_FIELD(language);     /*!< Default language for this call */
806                 AST_STRING_FIELD(musicclass);   /*!< Music on Hold class */
807                 AST_STRING_FIELD(rdnis);        /*!< Referring DNIS */
808                 AST_STRING_FIELD(theirtag);     /*!< Their tag */
809                 AST_STRING_FIELD(username);     /*!< [user] name */
810                 AST_STRING_FIELD(peername);     /*!< [peer] name, not set if [user] */
811                 AST_STRING_FIELD(authname);     /*!< Who we use for authentication */
812                 AST_STRING_FIELD(uri);          /*!< Original requested URI */
813                 AST_STRING_FIELD(okcontacturi); /*!< URI from the 200 OK on INVITE */
814                 AST_STRING_FIELD(peersecret);   /*!< Password */
815                 AST_STRING_FIELD(peermd5secret);
816                 AST_STRING_FIELD(cid_num);      /*!< Caller*ID */
817                 AST_STRING_FIELD(cid_name);     /*!< Caller*ID */
818                 AST_STRING_FIELD(via);          /*!< Via: header */
819                 AST_STRING_FIELD(fullcontact);  /*!< The Contact: that the UA registers with us */
820                 AST_STRING_FIELD(our_contact);  /*!< Our contact header */
821                 AST_STRING_FIELD(rpid);         /*!< Our RPID header */
822                 AST_STRING_FIELD(rpid_from);    /*!< Our RPID From header */
823         );
824         struct ast_codec_pref prefs;            /*!< codec prefs */
825         unsigned int ocseq;                     /*!< Current outgoing seqno */
826         unsigned int icseq;                     /*!< Current incoming seqno */
827         ast_group_t callgroup;                  /*!< Call group */
828         ast_group_t pickupgroup;                /*!< Pickup group */
829         int lastinvite;                         /*!< Last Cseq of invite */
830         struct ast_flags flags[2];              /*!< SIP_ flags */
831         int timer_t1;                           /*!< SIP timer T1, ms rtt */
832         unsigned int sipoptions;                /*!< Supported SIP sipoptions on the other end */
833         int capability;                         /*!< Special capability (codec) */
834         int jointcapability;                    /*!< Supported capability at both ends (codecs ) */
835         int peercapability;                     /*!< Supported peer capability */
836         int prefcodec;                          /*!< Preferred codec (outbound only) */
837         int noncodeccapability;                 /*!< DTMF RFC2833 telephony-event */
838         int redircodecs;                        /*!< Redirect codecs */
839         int maxcallbitrate;                     /*!< Maximum Call Bitrate for Video Calls */    
840         int callingpres;                        /*!< Calling presentation */
841         int authtries;                          /*!< Times we've tried to authenticate */
842         int expiry;                             /*!< How long we take to expire */
843         long branch;                            /*!< One random number */
844         char tag[11];                           /*!< Another random number */
845         int sessionid;                          /*!< SDP Session ID */
846         int sessionversion;                     /*!< SDP Session Version */
847         struct sockaddr_in sa;                  /*!< Our peer */
848         struct sockaddr_in redirip;             /*!< Where our RTP should be going if not to us */
849         struct sockaddr_in vredirip;            /*!< Where our Video RTP should be going if not to us */
850         struct sockaddr_in recv;                /*!< Received as */
851         struct in_addr ourip;                   /*!< Our IP */
852         struct ast_channel *owner;              /*!< Who owns us */
853         struct sip_route *route;                /*!< Head of linked list of routing steps (fm Record-Route) */
854         int route_persistant;                   /*!< Is this the "real" route? */
855         struct sip_auth *peerauth;              /*!< Realm authentication */
856         int noncecount;                         /*!< Nonce-count */
857         char lastmsg[256];                      /*!< Last Message sent/received */
858         int amaflags;                           /*!< AMA Flags */
859         int pendinginvite;                      /*!< Any pending invite */
860         struct sip_request initreq;             /*!< Initial request that opened the SIP dialog */
861         
862         int maxtime;                            /*!< Max time for first response */
863         int initid;                             /*!< Auto-congest ID if appropriate */
864         int autokillid;                         /*!< Auto-kill ID */
865         time_t lastrtprx;                       /*!< Last RTP received */
866         time_t lastrtptx;                       /*!< Last RTP sent */
867         int rtptimeout;                         /*!< RTP timeout time */
868         int rtpholdtimeout;                     /*!< RTP timeout when on hold */
869         int rtpkeepalive;                       /*!< Send RTP packets for keepalive */
870         enum transfermodes allowtransfer;       /*! SIP Refer restriction scheme */
871         enum subscriptiontype subscribed;       /*!< SUBSCRIBE: Is this dialog a subscription?  */
872         int stateid;                            /*!< SUBSCRIBE: ID for devicestate subscriptions */
873         int laststate;                          /*!< SUBSCRIBE: Last known extension state */
874         int dialogver;                          /*!< SUBSCRIBE: Version for subscription dialog-info */
875         
876         struct sip_refer *refer;                /*!< REFER: SIP transfer data structure */
877         struct ast_dsp *vad;                    /*!< Voice Activation Detection dsp */
878         
879         struct sip_peer *relatedpeer;           /*!< If this dialog is related to a peer, which one 
880                                                         Used in peerpoke, mwi subscriptions */
881         struct sip_registry *registry;          /*!< If this is a REGISTER dialog, to which registry */
882         struct ast_rtp *rtp;                    /*!< RTP Session */
883         struct ast_rtp *vrtp;                   /*!< Video RTP session */
884         struct sip_pkt *packets;                /*!< Packets scheduled for re-transmission */
885         struct sip_history_head *history;       /*!< History of this SIP dialog */
886         struct ast_variable *chanvars;          /*!< Channel variables to set for inbound call */
887         struct sip_pvt *next;                   /*!< Next dialog in chain */
888         struct sip_invite_param *options;       /*!< Options for INVITE */
889 } *iflist = NULL;
890
891 #define FLAG_RESPONSE (1 << 0)
892 #define FLAG_FATAL (1 << 1)
893
894 /*! \brief sip packet - raw format for outbound packets that are sent or scheduled for transmission */
895 struct sip_pkt {
896         struct sip_pkt *next;                   /*!< Next packet in linked list */
897         int retrans;                            /*!< Retransmission number */
898         int method;                             /*!< SIP method for this packet */
899         int seqno;                              /*!< Sequence number */
900         unsigned int flags;                     /*!< non-zero if this is a response packet (e.g. 200 OK) */
901         struct sip_pvt *owner;                  /*!< Owner AST call */
902         int retransid;                          /*!< Retransmission ID */
903         int timer_a;                            /*!< SIP timer A, retransmission timer */
904         int timer_t1;                           /*!< SIP Timer T1, estimated RTT or 500 ms */
905         int packetlen;                          /*!< Length of packet */
906         char data[0];
907 };      
908
909 /*! \brief Structure for SIP user data. User's place calls to us */
910 struct sip_user {
911         /* Users who can access various contexts */
912         ASTOBJ_COMPONENTS(struct sip_user);
913         char secret[80];                /*!< Password */
914         char md5secret[80];             /*!< Password in md5 */
915         char context[AST_MAX_CONTEXT];  /*!< Default context for incoming calls */
916         char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
917         char cid_num[80];               /*!< Caller ID num */
918         char cid_name[80];              /*!< Caller ID name */
919         char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
920         char language[MAX_LANGUAGE];    /*!< Default language for this user */
921         char musicclass[MAX_MUSICCLASS];/*!< Music on Hold class */
922         char useragent[256];            /*!< User agent in SIP request */
923         struct ast_codec_pref prefs;    /*!< codec prefs */
924         ast_group_t callgroup;          /*!< Call group */
925         ast_group_t pickupgroup;        /*!< Pickup Group */
926         unsigned int sipoptions;        /*!< Supported SIP options */
927         struct ast_flags flags[2];      /*!< SIP_ flags */
928         int amaflags;                   /*!< AMA flags for billing */
929         int callingpres;                /*!< Calling id presentation */
930         int capability;                 /*!< Codec capability */
931         int inUse;                      /*!< Number of calls in use */
932         int call_limit;                 /*!< Limit of concurrent calls */
933         enum transfermodes allowtransfer;       /*! SIP Refer restriction scheme */
934         struct ast_ha *ha;              /*!< ACL setting */
935         struct ast_variable *chanvars;  /*!< Variables to set for channel created by user */
936         int maxcallbitrate;             /*!< Maximum Bitrate for a video call */
937 };
938
939 /*! \brief Structure for SIP peer data, we place calls to peers if registered  or fixed IP address (host) */
940 /* XXX field 'name' must be first otherwise sip_addrcmp() will fail */
941 struct sip_peer {
942         ASTOBJ_COMPONENTS(struct sip_peer);     /*!< name, refcount, objflags,  object pointers */
943                                         /*!< peer->name is the unique name of this object */
944         char secret[80];                /*!< Password */
945         char md5secret[80];             /*!< Password in MD5 */
946         struct sip_auth *auth;          /*!< Realm authentication list */
947         char context[AST_MAX_CONTEXT];  /*!< Default context for incoming calls */
948         char subscribecontext[AST_MAX_CONTEXT]; /*!< Default context for subscriptions */
949         char username[80];              /*!< Temporary username until registration */ 
950         char accountcode[AST_MAX_ACCOUNT_CODE]; /*!< Account code */
951         int amaflags;                   /*!< AMA Flags (for billing) */
952         char tohost[MAXHOSTNAMELEN];    /*!< If not dynamic, IP address */
953         char regexten[AST_MAX_EXTENSION]; /*!< Extension to register (if regcontext is used) */
954         char fromuser[80];              /*!< From: user when calling this peer */
955         char fromdomain[MAXHOSTNAMELEN];        /*!< From: domain when calling this peer */
956         char fullcontact[256];          /*!< Contact registered with us (not in sip.conf) */
957         char cid_num[80];               /*!< Caller ID num */
958         char cid_name[80];              /*!< Caller ID name */
959         int callingpres;                /*!< Calling id presentation */
960         int inUse;                      /*!< Number of calls in use */
961         int inRinging;                  /*!< Number of calls ringing */
962         int call_limit;                 /*!< Limit of concurrent calls */
963         enum transfermodes allowtransfer;       /*! SIP Refer restriction scheme */
964         char vmexten[AST_MAX_EXTENSION]; /*!< Dialplan extension for MWI notify message*/
965         char mailbox[AST_MAX_EXTENSION]; /*!< Mailbox setting for MWI checks */
966         char language[MAX_LANGUAGE];    /*!<  Default language for prompts */
967         char musicclass[MAX_MUSICCLASS];/*!<  Music on Hold class */
968         char useragent[256];            /*!<  User agent in SIP request (saved from registration) */
969         struct ast_codec_pref prefs;    /*!<  codec prefs */
970         int lastmsgssent;
971         time_t  lastmsgcheck;           /*!<  Last time we checked for MWI */
972         unsigned int sipoptions;        /*!<  Supported SIP options */
973         struct ast_flags flags[2];      /*!<  SIP_ flags */
974         int expire;                     /*!<  When to expire this peer registration */
975         int capability;                 /*!<  Codec capability */
976         int rtptimeout;                 /*!<  RTP timeout */
977         int rtpholdtimeout;             /*!<  RTP Hold Timeout */
978         int rtpkeepalive;               /*!<  Send RTP packets for keepalive */
979         ast_group_t callgroup;          /*!<  Call group */
980         ast_group_t pickupgroup;        /*!<  Pickup group */
981         struct ast_dnsmgr_entry *dnsmgr;/*!<  DNS refresh manager for peer */
982         struct sockaddr_in addr;        /*!<  IP address of peer */
983         int maxcallbitrate;             /*!< Maximum Bitrate for a video call */
984         
985         /* Qualification */
986         struct sip_pvt *call;           /*!<  Call pointer */
987         int pokeexpire;                 /*!<  When to expire poke (qualify= checking) */
988         int lastms;                     /*!<  How long last response took (in ms), or -1 for no response */
989         int maxms;                      /*!<  Max ms we will accept for the host to be up, 0 to not monitor */
990         struct timeval ps;              /*!<  Ping send time */
991         
992         struct sockaddr_in defaddr;     /*!<  Default IP address, used until registration */
993         struct ast_ha *ha;              /*!<  Access control list */
994         struct ast_variable *chanvars;  /*!<  Variables to set for channel created by user */
995         struct sip_pvt *mwipvt;         /*!<  Subscription for MWI */
996         int lastmsg;
997 };
998
999
1000
1001 /*! \brief Registrations with other SIP proxies */
1002 struct sip_registry {
1003         ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
1004         AST_DECLARE_STRING_FIELDS(
1005                 AST_STRING_FIELD(callid);       /*!< Global Call-ID */
1006                 AST_STRING_FIELD(realm);        /*!< Authorization realm */
1007                 AST_STRING_FIELD(nonce);        /*!< Authorization nonce */
1008                 AST_STRING_FIELD(opaque);       /*!< Opaque nonsense */
1009                 AST_STRING_FIELD(qop);          /*!< Quality of Protection, since SIP wasn't complicated enough yet. */
1010                 AST_STRING_FIELD(domain);       /*!< Authorization domain */
1011                 AST_STRING_FIELD(username);     /*!< Who we are registering as */
1012                 AST_STRING_FIELD(authuser);     /*!< Who we *authenticate* as */
1013                 AST_STRING_FIELD(hostname);     /*!< Domain or host we register to */
1014                 AST_STRING_FIELD(secret);       /*!< Password in clear text */  
1015                 AST_STRING_FIELD(md5secret);    /*!< Password in md5 */
1016                 AST_STRING_FIELD(contact);      /*!< Contact extension */
1017                 AST_STRING_FIELD(random);
1018         );
1019         int portno;                     /*!<  Optional port override */
1020         int expire;                     /*!< Sched ID of expiration */
1021         int regattempts;                /*!< Number of attempts (since the last success) */
1022         int timeout;                    /*!< sched id of sip_reg_timeout */
1023         int refresh;                    /*!< How often to refresh */
1024         struct sip_pvt *call;           /*!< create a sip_pvt structure for each outbound "registration dialog" in progress */
1025         enum sipregistrystate regstate; /*!< Registration state (see above) */
1026         time_t regtime;         /*!< Last succesful registration time */
1027         int callid_valid;               /*!< 0 means we haven't chosen callid for this registry yet. */
1028         unsigned int ocseq;             /*!< Sequence number we got to for REGISTERs for this registry */
1029         struct sockaddr_in us;          /*!< Who the server thinks we are */
1030         int noncecount;                 /*!< Nonce-count */
1031         char lastmsg[256];              /*!< Last Message sent/received */
1032 };
1033
1034 /* --- Linked lists of various objects --------*/
1035
1036 /*! \brief  The user list: Users and friends */
1037 static struct ast_user_list {
1038         ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
1039 } userl;
1040
1041 /*! \brief  The peer list: Peers and Friends */
1042 static struct ast_peer_list {
1043         ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
1044 } peerl;
1045
1046 /*! \brief  The register list: Other SIP proxys we register with and place calls to */
1047 static struct ast_register_list {
1048         ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
1049         int recheck;
1050 } regl;
1051
1052 /*! \todo Move the sip_auth list to AST_LIST */
1053 static struct sip_auth *authl = NULL;           /*!< Authentication list for realm authentication */
1054
1055
1056 /* --- Sockets and networking --------------*/
1057 static int sipsock  = -1;                       /*!< Main socket for SIP network communication */
1058 static struct sockaddr_in bindaddr = { 0, };    /*!< The address we bind to */
1059 static struct sockaddr_in externip;             /*!< External IP address if we are behind NAT */
1060 static char externhost[MAXHOSTNAMELEN];         /*!< External host name (possibly with dynamic DNS and DHCP */
1061 static time_t externexpire = 0;                 /*!< Expiration counter for re-resolving external host name in dynamic DNS */
1062 static int externrefresh = 10;
1063 static struct ast_ha *localaddr;                /*!< List of local networks, on the same side of NAT as this Asterisk */
1064 static struct in_addr __ourip;
1065 static struct sockaddr_in outboundproxyip;
1066 static int ourport;
1067 static struct sockaddr_in debugaddr;
1068
1069 static struct ast_config *notify_types;         /*!< The list of manual NOTIFY types we know how to send */
1070
1071 /*---------------------------- Forward declarations of functions in chan_sip.c */
1072 /*! \note This is added to help splitting up chan_sip.c into several files
1073         in coming releases */
1074
1075 /*--- PBX interface functions */
1076 static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause);
1077 static int sip_devicestate(void *data);
1078 static int sip_sendtext(struct ast_channel *ast, const char *text);
1079 static int sip_call(struct ast_channel *ast, char *dest, int timeout);
1080 static int sip_hangup(struct ast_channel *ast);
1081 static int sip_answer(struct ast_channel *ast);
1082 static struct ast_frame *sip_read(struct ast_channel *ast);
1083 static int sip_write(struct ast_channel *ast, struct ast_frame *frame);
1084 static int sip_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
1085 static int sip_transfer(struct ast_channel *ast, const char *dest);
1086 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
1087 static int sip_senddigit(struct ast_channel *ast, char digit);
1088
1089 /*--- Transmitting responses and requests */
1090 static int sipsock_read(int *id, int fd, short events, void *ignore);
1091 static int __sip_xmit(struct sip_pvt *p, char *data, int len);
1092 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod);
1093 static int __transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
1094 static int retrans_pkt(void *data);
1095 static int transmit_sip_request(struct sip_pvt *p, struct sip_request *req);
1096 static int transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req);
1097 static int transmit_response_reliable(struct sip_pvt *p, const char *msg, const struct sip_request *req);
1098 static int transmit_response_with_date(struct sip_pvt *p, const char *msg, const struct sip_request *req);
1099 static int transmit_response_with_sdp(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
1100 static int transmit_response_with_unsupported(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *unsupported);
1101 static int transmit_response_with_auth(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *rand, enum xmittype reliable, const char *header, int stale);
1102 static int transmit_response_with_allow(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
1103 static void transmit_fake_auth_response(struct sip_pvt *p, struct sip_request *req, int reliable);
1104 static int transmit_request(struct sip_pvt *p, int sipmethod, int inc, enum xmittype reliable, int newbranch);
1105 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch);
1106 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sdp, int init);
1107 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
1108 static int transmit_info_with_digit(struct sip_pvt *p, const char digit);
1109 static int transmit_info_with_vidupdate(struct sip_pvt *p);
1110 static int transmit_message_with_text(struct sip_pvt *p, const char *text);
1111 static int transmit_refer(struct sip_pvt *p, const char *dest);
1112 static int transmit_notify_with_mwi(struct sip_pvt *p, int newmsgs, int oldmsgs, char *vmexten);
1113 static int transmit_notify_with_sipfrag(struct sip_pvt *p, int cseq, char *message, int terminate);
1114 static int transmit_state_notify(struct sip_pvt *p, int state, int full);
1115 static int transmit_register(struct sip_registry *r, int sipmethod, const char *auth, const char *authheader);
1116 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno);
1117 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno);
1118 static void copy_request(struct sip_request *dst, const struct sip_request *src);
1119 static void receive_message(struct sip_pvt *p, struct sip_request *req);
1120 static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req);
1121 static int sip_send_mwi_to_peer(struct sip_peer *peer);
1122 static int does_peer_need_mwi(struct sip_peer *peer);
1123
1124 /*--- Dialog management */
1125 static struct sip_pvt *sip_alloc(ast_string_field callid, struct sockaddr_in *sin,
1126                                  int useglobal_nat, const int intended_method);
1127 static int __sip_autodestruct(void *data);
1128 static void sip_scheddestroy(struct sip_pvt *p, int ms);
1129 static void sip_cancel_destroy(struct sip_pvt *p);
1130 static void sip_destroy(struct sip_pvt *p);
1131 static void __sip_destroy(struct sip_pvt *p, int lockowner);
1132 static void __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod, int reset);
1133 static void __sip_pretend_ack(struct sip_pvt *p);
1134 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod);
1135 static int auto_congest(void *nothing);
1136 static int update_call_counter(struct sip_pvt *fup, int event);
1137 static int hangup_sip2cause(int cause);
1138 static const char *hangup_cause2sip(int cause);
1139 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method);
1140 static void free_old_route(struct sip_route *route);
1141 static void list_route(struct sip_route *route);
1142 static void build_route(struct sip_pvt *p, struct sip_request *req, int backwards);
1143 static enum check_auth_result register_verify(struct sip_pvt *p, struct sockaddr_in *sin,
1144                                               struct sip_request *req, char *uri);
1145 static struct sip_pvt *get_sip_pvt_byid_locked(const char *callid, const char *totag, const char *fromtag);
1146 static void check_pendings(struct sip_pvt *p);
1147 static void *sip_park_thread(void *stuff);
1148 static int sip_park(struct ast_channel *chan1, struct ast_channel *chan2, struct sip_request *req, int seqno);
1149 static int sip_sipredirect(struct sip_pvt *p, const char *dest);
1150
1151 /*--- Codec handling / SDP */
1152 static void try_suggested_sip_codec(struct sip_pvt *p);
1153 static const char* get_sdp_iterate(int* start, struct sip_request *req, const char *name);
1154 static const char *get_sdp(struct sip_request *req, const char *name);
1155 static int find_sdp(struct sip_request *req);
1156 static int process_sdp(struct sip_pvt *p, struct sip_request *req);
1157 static void add_codec_to_sdp(const struct sip_pvt *p, int codec, int sample_rate,
1158                              char **m_buf, size_t *m_size, char **a_buf, size_t *a_size,
1159                              int debug);
1160 static void add_noncodec_to_sdp(const struct sip_pvt *p, int format, int sample_rate,
1161                                 char **m_buf, size_t *m_size, char **a_buf, size_t *a_size,
1162                                 int debug);
1163 static int add_sdp(struct sip_request *resp, struct sip_pvt *p);
1164
1165 /*--- Authentication stuff */
1166 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, int sipmethod, int init);
1167 static int reply_digest(struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len);
1168 static int build_reply_digest(struct sip_pvt *p, int method, char *digest, int digest_len);
1169 static int clear_realm_authentication(struct sip_auth *authlist);       /* Clear realm authentication list (at reload) */
1170 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno);   /* Add realm authentication in list */
1171 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, const char *realm);        /* Find authentication for a specific realm */
1172 static enum check_auth_result check_auth(struct sip_pvt *p, struct sip_request *req, const char *username,
1173                                          const char *secret, const char *md5secret, int sipmethod,
1174                                          char *uri, enum xmittype reliable, int ignore);
1175 static enum check_auth_result check_user_full(struct sip_pvt *p, struct sip_request *req,
1176                                               int sipmethod, char *uri, enum xmittype reliable,
1177                                               struct sockaddr_in *sin, struct sip_peer **authpeer);
1178 static int check_user(struct sip_pvt *p, struct sip_request *req, int sipmethod, char *uri, enum xmittype reliable, struct sockaddr_in *sin);
1179 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, int sipmethod, int init);
1180 static int build_reply_digest(struct sip_pvt *p, int method, char* digest, int digest_len);
1181
1182 /*--- Domain handling */
1183 static int check_sip_domain(const char *domain, char *context, size_t len); /* Check if domain is one of our local domains */
1184 static int add_sip_domain(const char *domain, const enum domain_mode mode, const char *context);
1185 static void clear_sip_domains(void);
1186
1187 /*--- SIP realm authentication */
1188 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno);
1189 static int clear_realm_authentication(struct sip_auth *authlist);
1190 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, const char *realm);
1191
1192 /*--- Misc functions */
1193 static int sip_do_reload(enum channelreloadreason reason);
1194 static int reload_config(enum channelreloadreason reason);
1195 static int expire_register(void *data);
1196 static int sip_sipredirect(struct sip_pvt *p, const char *dest);
1197 static void *do_monitor(void *data);
1198 static int restart_monitor(void);
1199 static int sip_send_mwi_to_peer(struct sip_peer *peer);
1200 static void sip_destroy(struct sip_pvt *p);
1201 static int sip_addrcmp(char *name, struct sockaddr_in *sin);    /* Support for peer matching */
1202 static int sip_refer_allocate(struct sip_pvt *p);
1203 static void ast_quiet_chan(struct ast_channel *chan);
1204 static int attempt_transfer(struct sip_dual *transferer, struct sip_dual *target);
1205
1206 /*--- Device monitoring and Device/extension state handling */
1207 static int cb_extensionstate(char *context, char* exten, int state, void *data);
1208 static int sip_devicestate(void *data);
1209 static int sip_poke_noanswer(void *data);
1210 static int sip_poke_peer(struct sip_peer *peer);
1211 static void sip_poke_all_peers(void);
1212
1213
1214 /*--- Applications, functions, CLI and manager command helpers */
1215 static const char *sip_nat_mode(const struct sip_pvt *p);
1216 static int sip_show_inuse(int fd, int argc, char *argv[]);
1217 static char *transfermode2str(enum transfermodes mode);
1218 static char *nat2str(int nat);
1219 static int peer_status(struct sip_peer *peer, char *status, int statuslen);
1220 static int sip_show_users(int fd, int argc, char *argv[]);
1221 static int _sip_show_peers(int fd, int *total, struct mansession *s, struct message *m, int argc, char *argv[]);
1222 static int manager_sip_show_peers( struct mansession *s, struct message *m );
1223 static int sip_show_peers(int fd, int argc, char *argv[]);
1224 static int sip_show_objects(int fd, int argc, char *argv[]);
1225 static void  print_group(int fd, unsigned int group, int crlf);
1226 static const char *dtmfmode2str(int mode);
1227 static const char *insecure2str(int port, int invite);
1228 static void cleanup_stale_contexts(char *new, char *old);
1229 static void print_codec_to_cli(int fd, struct ast_codec_pref *pref);
1230 static const char *domain_mode_to_text(const enum domain_mode mode);
1231 static int sip_show_domains(int fd, int argc, char *argv[]);
1232 static int _sip_show_peer(int type, int fd, struct mansession *s, struct message *m, int argc, char *argv[]);
1233 static int manager_sip_show_peer( struct mansession *s, struct message *m);
1234 static int sip_show_peer(int fd, int argc, char *argv[]);
1235 static int _sip_show_peer(int type, int fd, struct mansession *s, struct message *m, int argc, char *argv[]);
1236 static int sip_show_user(int fd, int argc, char *argv[]);
1237 static int sip_show_registry(int fd, int argc, char *argv[]);
1238 static int sip_show_settings(int fd, int argc, char *argv[]);
1239 static const char *subscription_type2str(enum subscriptiontype subtype);
1240 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
1241 static int __sip_show_channels(int fd, int argc, char *argv[], int subscriptions);
1242 static int sip_show_channels(int fd, int argc, char *argv[]);
1243 static int sip_show_subscriptions(int fd, int argc, char *argv[]);
1244 static int __sip_show_channels(int fd, int argc, char *argv[], int subscriptions);
1245 static char *complete_sipch(const char *line, const char *word, int pos, int state);
1246 static char *complete_sip_peer(const char *word, int state, int flags2);
1247 static char *complete_sip_show_peer(const char *line, const char *word, int pos, int state);
1248 static char *complete_sip_debug_peer(const char *line, const char *word, int pos, int state);
1249 static char *complete_sip_user(const char *word, int state, int flags2);
1250 static char *complete_sip_show_user(const char *line, const char *word, int pos, int state);
1251 static char *complete_sipnotify(const char *line, const char *word, int pos, int state);
1252 static char *complete_sip_prune_realtime_peer(const char *line, const char *word, int pos, int state);
1253 static char *complete_sip_prune_realtime_user(const char *line, const char *word, int pos, int state);
1254 static int sip_show_channel(int fd, int argc, char *argv[]);
1255 static int sip_show_history(int fd, int argc, char *argv[]);
1256 static int sip_do_debug_ip(int fd, int argc, char *argv[]);
1257 static int sip_do_debug_peer(int fd, int argc, char *argv[]);
1258 static int sip_do_debug(int fd, int argc, char *argv[]);
1259 static int sip_no_debug(int fd, int argc, char *argv[]);
1260 static int sip_notify(int fd, int argc, char *argv[]);
1261 static int sip_do_history(int fd, int argc, char *argv[]);
1262 static int sip_no_history(int fd, int argc, char *argv[]);
1263 static int func_header_read(struct ast_channel *chan, char *function, char *data, char *buf, size_t len);
1264 static int func_check_sipdomain(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len);
1265 static int function_sippeer(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len);
1266 static int function_sipchaninfo_read(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len);
1267 static int sip_dtmfmode(struct ast_channel *chan, void *data);
1268 static int sip_addheader(struct ast_channel *chan, void *data);
1269 static int sip_do_reload(enum channelreloadreason reason);
1270 static int sip_reload(int fd, int argc, char *argv[]);
1271
1272 /*--- Debugging 
1273         Functions for enabling debug per IP or fully, or enabling history logging for
1274         a SIP dialog
1275 */
1276 static void sip_dump_history(struct sip_pvt *dialog);   /* Dump history to LOG_DEBUG at end of dialog, before destroying data */
1277 static inline int sip_debug_test_addr(const struct sockaddr_in *addr);
1278 static inline int sip_debug_test_pvt(struct sip_pvt *p);
1279 static void append_history_full(struct sip_pvt *p, const char *fmt, ...);
1280 static void sip_dump_history(struct sip_pvt *dialog);
1281
1282 /*--- Device object handling */
1283 static struct sip_peer *temp_peer(const char *name);
1284 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int realtime);
1285 static struct sip_user *build_user(const char *name, struct ast_variable *v, int realtime);
1286 static int update_call_counter(struct sip_pvt *fup, int event);
1287 static void sip_destroy_peer(struct sip_peer *peer);
1288 static void sip_destroy_user(struct sip_user *user);
1289 static int sip_poke_peer(struct sip_peer *peer);
1290 static void set_peer_defaults(struct sip_peer *peer);
1291 static struct sip_peer *temp_peer(const char *name);
1292 static void register_peer_exten(struct sip_peer *peer, int onoff);
1293 static void sip_destroy_peer(struct sip_peer *peer);
1294 static void sip_destroy_user(struct sip_user *user);
1295 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime);
1296 static struct sip_user *find_user(const char *name, int realtime);
1297 static int sip_poke_peer_s(void *data);
1298 static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, struct sip_peer *p, struct sip_request *req);
1299 static int expire_register(void *data);
1300 static void reg_source_db(struct sip_peer *peer);
1301 static void destroy_association(struct sip_peer *peer);
1302 static int handle_common_options(struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v);
1303
1304 /* Realtime device support */
1305 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expirey);
1306 static struct sip_user *realtime_user(const char *username);
1307 static void update_peer(struct sip_peer *p, int expiry);
1308 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin);
1309 static int sip_prune_realtime(int fd, int argc, char *argv[]);
1310
1311 /*--- Internal UA client handling (outbound registrations) */
1312 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us);
1313 static void sip_registry_destroy(struct sip_registry *reg);
1314 static int sip_register(char *value, int lineno);
1315 static char *regstate2str(enum sipregistrystate regstate);
1316 static int sip_reregister(void *data);
1317 static int __sip_do_register(struct sip_registry *r);
1318 static int sip_reg_timeout(void *data);
1319 static int do_register_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader);
1320 static int reply_digest(struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod,  char *digest, int digest_len);
1321 static void sip_send_all_registers(void);
1322
1323 /*--- Parsing SIP requests and responses */
1324 static void append_date(struct sip_request *req);       /* Append date to SIP packet */
1325 static int determine_firstline_parts(struct sip_request *req);
1326 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
1327 static const char *gettag(const struct sip_request *req, const char *header, char *tagbuf, int tagbufsize);
1328 static int find_sip_method(const char *msg);
1329 static unsigned int parse_sip_options(struct sip_pvt *pvt, const char *supported);
1330 static void parse_request(struct sip_request *req);
1331 static const char *get_header(const struct sip_request *req, const char *name);
1332 static char *referstatus2str(enum referstatus rstatus);
1333 static int method_match(enum sipmethod id, const char *name);
1334 static void parse_copy(struct sip_request *dst, const struct sip_request *src);
1335 static char *get_in_brackets(char *tmp);
1336 static const char *find_alias(const char *name, const char *_default);
1337 static const char *__get_header(const struct sip_request *req, const char *name, int *start);
1338 static const char *get_header(const struct sip_request *req, const char *name);
1339 static int lws2sws(char *msgbuf, int len);
1340 static void extract_uri(struct sip_pvt *p, struct sip_request *req);
1341 static int get_refer_info(struct sip_pvt *transferer, struct sip_request *outgoing_req);
1342 static int get_also_info(struct sip_pvt *p, struct sip_request *oreq);
1343 static int parse_ok_contact(struct sip_pvt *pvt, struct sip_request *req);
1344 static int set_address_from_contact(struct sip_pvt *pvt);
1345 static void check_via(struct sip_pvt *p, struct sip_request *req);
1346 static char *get_calleridname(const char *input, char *output, size_t outputsize);
1347 static int get_rpid_num(const char *input, char *output, int maxlen);
1348 static int get_rdnis(struct sip_pvt *p, struct sip_request *oreq);
1349 static int get_destination(struct sip_pvt *p, struct sip_request *oreq);
1350 static int get_msg_text(char *buf, int len, struct sip_request *req);
1351 static const char *gettag(const struct sip_request *req, const char *header, char *tagbuf, int tagbufsize);
1352 static void free_old_route(struct sip_route *route);
1353
1354 /*--- Constructing requests and responses */
1355 static void initialize_initreq(struct sip_pvt *p, struct sip_request *req);
1356 static int init_req(struct sip_request *req, int sipmethod, const char *recip);
1357 static int reqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, int seqno, int newbranch);
1358 static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod);
1359 static int init_resp(struct sip_request *resp, const char *msg);
1360 static int respprep(struct sip_request *resp, struct sip_pvt *p, const char *msg, const struct sip_request *req);
1361 static const struct sockaddr_in *sip_real_dst(const struct sip_pvt *p);
1362 static void build_via(struct sip_pvt *p);
1363 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer);
1364 static int create_addr(struct sip_pvt *dialog, const char *opeer);
1365 static char *generate_random_string(char *buf, size_t size);
1366 static void build_callid_pvt(struct sip_pvt *pvt);
1367 static void build_callid_registry(struct sip_registry *reg, struct in_addr ourip, const char *fromdomain);
1368 static void make_our_tag(char *tagbuf, size_t len);
1369 static int add_header(struct sip_request *req, const char *var, const char *value);
1370 static int add_header_contentLength(struct sip_request *req, int len);
1371 static int add_line(struct sip_request *req, const char *line);
1372 static int add_text(struct sip_request *req, const char *text);
1373 static int add_digit(struct sip_request *req, char digit);
1374 static int add_vidupdate(struct sip_request *req);
1375 static void add_route(struct sip_request *req, struct sip_route *route);
1376 static int copy_header(struct sip_request *req, const struct sip_request *orig, const char *field);
1377 static int copy_all_header(struct sip_request *req, const struct sip_request *orig, const char *field);
1378 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, const struct sip_request *orig, const char *field);
1379 static void set_destination(struct sip_pvt *p, char *uri);
1380 static void append_date(struct sip_request *req);
1381 static void build_contact(struct sip_pvt *p);
1382 static void build_rpid(struct sip_pvt *p);
1383
1384 /*------Request handling functions */
1385 static int handle_request(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int *recount, int *nounlock);
1386 static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct sockaddr_in *sin, int *recount, char *e);
1387 static int handle_request_refer(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, int *nounlock);
1388 static int handle_request_bye(struct sip_pvt *p, struct sip_request *req);
1389 static int handle_request_register(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, char *e);
1390 static int handle_request_cancel(struct sip_pvt *p, struct sip_request *req);
1391 static int handle_request_message(struct sip_pvt *p, struct sip_request *req);
1392 static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e);
1393 static void handle_request_info(struct sip_pvt *p, struct sip_request *req);
1394 static int handle_request_options(struct sip_pvt *p, struct sip_request *req);
1395 static int handle_invite_replaces(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, struct sockaddr_in *sin);
1396 static int handle_request_notify(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e);
1397 static int handle_invite_replaces(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, struct sockaddr_in *sin);
1398 static int local_attended_transfer(struct sip_pvt *transferer, struct sip_dual *current, struct sip_request *req, int seqno);
1399
1400 /*------Response handling functions */
1401 static void handle_response_invite(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno);
1402 static void handle_response_refer(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno);
1403 static int handle_response_peerpoke(struct sip_pvt *p, int resp, struct sip_request *req);
1404 static int handle_response_register(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno);
1405 static void handle_response(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno);
1406
1407 /*----- RTP interface functions */
1408 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active);
1409 static struct ast_rtp *sip_get_rtp_peer(struct ast_channel *chan);
1410 static struct ast_rtp *sip_get_vrtp_peer(struct ast_channel *chan);
1411 static int sip_get_codec(struct ast_channel *chan);
1412 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p);
1413
1414
1415 /*! \brief Definition of this channel for PBX channel registration */
1416 static const struct ast_channel_tech sip_tech = {
1417         .type = "SIP",
1418         .description = "Session Initiation Protocol (SIP)",
1419         .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
1420         .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER,
1421         .requester = sip_request_call,
1422         .devicestate = sip_devicestate,
1423         .call = sip_call,
1424         .hangup = sip_hangup,
1425         .answer = sip_answer,
1426         .read = sip_read,
1427         .write = sip_write,
1428         .write_video = sip_write,
1429         .indicate = sip_indicate,
1430         .transfer = sip_transfer,
1431         .fixup = sip_fixup,
1432         .send_digit = sip_senddigit,
1433         .bridge = ast_rtp_bridge,
1434         .send_text = sip_sendtext,
1435 };
1436
1437 /**--- some list management macros. **/
1438  
1439 #define UNLINK(element, head, prev) do {        \
1440         if (prev)                               \
1441                 (prev)->next = (element)->next; \
1442         else                                    \
1443                 (head) = (element)->next;       \
1444         } while (0)
1445
1446 /*! \brief Interface structure with callbacks used to connect to RTP module */
1447 static struct ast_rtp_protocol sip_rtp = {
1448         type: "SIP",
1449         get_rtp_info: sip_get_rtp_peer,
1450         get_vrtp_info: sip_get_vrtp_peer,
1451         set_rtp_peer: sip_set_rtp_peer,
1452         get_codec: sip_get_codec,
1453 };
1454
1455 /*! \brief Convert transfer status to string */
1456 static char *referstatus2str(enum referstatus rstatus)
1457 {
1458         int i = (sizeof(referstatusstrings) / sizeof(referstatusstrings[0]));
1459         int x;
1460
1461         for (x = 0; x < i; x++) {
1462                 if (referstatusstrings[x].status ==  rstatus)
1463                         return (char *) referstatusstrings[x].text;
1464         }
1465         return "";
1466 }
1467
1468 /*! \brief Initialize the initital request packet in the pvt structure.
1469         This packet is used for creating replies and future requests in
1470         a dialog */
1471 static void initialize_initreq(struct sip_pvt *p, struct sip_request *req)
1472 {
1473         if (p->initreq.headers) {
1474                 ast_log(LOG_DEBUG, "Initializing already initialized SIP dialog %s (presumably reinvite)\n", p->callid);
1475         }
1476         /* Use this as the basis */
1477         copy_request(&p->initreq, req);
1478         parse_request(&p->initreq);
1479         if (ast_test_flag(req, SIP_PKT_DEBUG))
1480                 ast_verbose("%d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
1481 }
1482
1483
1484 /*! \brief returns true if 'name' (with optional trailing whitespace)
1485  * matches the sip method 'id'.
1486  * Strictly speaking, SIP methods are case SENSITIVE, but we do
1487  * a case-insensitive comparison to be more tolerant.
1488  * following Jon Postel's rule: Be gentle in what you accept, strict with what you send
1489  */
1490 static int method_match(enum sipmethod id, const char *name)
1491 {
1492         int len = strlen(sip_methods[id].text);
1493         int l_name = name ? strlen(name) : 0;
1494         /* true if the string is long enough, and ends with whitespace, and matches */
1495         return (l_name >= len && name[len] < 33 &&
1496                 !strncasecmp(sip_methods[id].text, name, len));
1497 }
1498
1499 /*! \brief  find_sip_method: Find SIP method from header */
1500 static int find_sip_method(const char *msg)
1501 {
1502         int i, res = 0;
1503         
1504         if (ast_strlen_zero(msg))
1505                 return 0;
1506         for (i = 1; i < (sizeof(sip_methods) / sizeof(sip_methods[0])) && !res; i++) {
1507                 if (method_match(i, msg))
1508                         res = sip_methods[i].id;
1509         }
1510         return res;
1511 }
1512
1513 /*! \brief Parse supported header in incoming packet */
1514 static unsigned int parse_sip_options(struct sip_pvt *pvt, const char *supported)
1515 {
1516         char *next, *sep;
1517         char *temp = ast_strdupa(supported);
1518         unsigned int profile = 0;
1519         int i, found;
1520
1521         if (ast_strlen_zero(supported) )
1522                 return 0;
1523
1524         if (option_debug > 2 && sipdebug)
1525                 ast_log(LOG_DEBUG, "Begin: parsing SIP \"Supported: %s\"\n", supported);
1526
1527         for (next = temp; next; next = sep) {
1528                 found = FALSE;
1529                 if ( (sep = strchr(next, ',')) != NULL)
1530                         *sep++ = '\0';
1531                 next = ast_skip_blanks(next);
1532                 if (option_debug > 2 && sipdebug)
1533                         ast_log(LOG_DEBUG, "Found SIP option: -%s-\n", next);
1534                 for (i=0; i < (sizeof(sip_options) / sizeof(sip_options[0])); i++) {
1535                         if (!strcasecmp(next, sip_options[i].text)) {
1536                                 profile |= sip_options[i].id;
1537                                 found = TRUE;
1538                                 if (option_debug > 2 && sipdebug)
1539                                         ast_log(LOG_DEBUG, "Matched SIP option: %s\n", next);
1540                                 break;
1541                         }
1542                 }
1543                 if (!found && option_debug > 2 && sipdebug)
1544                         ast_log(LOG_DEBUG, "Found no match for SIP option: %s (Please file bug report!)\n", next);
1545         }
1546
1547         if (pvt)
1548                 pvt->sipoptions = profile;
1549         return profile;
1550 }
1551
1552 /*! \brief See if we pass debug IP filter */
1553 static inline int sip_debug_test_addr(const struct sockaddr_in *addr) 
1554 {
1555         if (!sipdebug)
1556                 return 0;
1557         if (debugaddr.sin_addr.s_addr) {
1558                 if (((ntohs(debugaddr.sin_port) != 0)
1559                         && (debugaddr.sin_port != addr->sin_port))
1560                         || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
1561                         return 0;
1562         }
1563         return 1;
1564 }
1565
1566 /*! \brief The real destination address for a write */
1567 static const struct sockaddr_in *sip_real_dst(const struct sip_pvt *p)
1568 {
1569         return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? &p->recv : &p->sa;
1570 }
1571
1572 /*! \brief Display SIP nat mode */
1573 static const char *sip_nat_mode(const struct sip_pvt *p)
1574 {
1575         return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? "NAT" : "no NAT";
1576 }
1577
1578 /*! \brief Test PVT for debugging output */
1579 static inline int sip_debug_test_pvt(struct sip_pvt *p) 
1580 {
1581         if (!sipdebug)
1582                 return 0;
1583         return sip_debug_test_addr(sip_real_dst(p));
1584 }
1585
1586 /*! \brief Transmit SIP message */
1587 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
1588 {
1589         int res;
1590         char iabuf[INET_ADDRSTRLEN];
1591         const struct sockaddr_in *dst = sip_real_dst(p);
1592         res=sendto(sipsock, data, len, 0, (const struct sockaddr *)dst, sizeof(struct sockaddr_in));
1593
1594         if (res != len)
1595                 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), dst->sin_addr), ntohs(dst->sin_port), res, strerror(errno));
1596         return res;
1597 }
1598
1599
1600 /*! \brief Build a Via header for a request */
1601 static void build_via(struct sip_pvt *p)
1602 {
1603         char iabuf[INET_ADDRSTRLEN];
1604         /* Work around buggy UNIDEN UIP200 firmware */
1605         const char *rport = ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_RFC3581 ? ";rport" : "";
1606
1607         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
1608         ast_string_field_build(p, via, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x%s",
1609                          ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch, rport);
1610 }
1611
1612 /*! \brief NAT fix - decide which IP address to use for ASterisk server?
1613  *
1614  * Using the localaddr structure built up with localnet statements in sip.conf
1615  * apply it to their address to see if we need to substitute our
1616  * externip or can get away with our internal bindaddr
1617  */
1618 static enum sip_result ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
1619 {
1620         struct sockaddr_in theirs, ours;
1621
1622         /* Get our local information */
1623         ast_ouraddrfor(them, us);
1624         theirs.sin_addr = *them;
1625         ours.sin_addr = *us;
1626
1627         if (localaddr && externip.sin_addr.s_addr &&
1628             ast_apply_ha(localaddr, &theirs) &&
1629             !ast_apply_ha(localaddr, &ours)) {
1630                 if (externexpire && time(NULL) >= externexpire) {
1631                         struct ast_hostent ahp;
1632                         struct hostent *hp;
1633
1634                         externexpire = time(NULL) + externrefresh;
1635                         if ((hp = ast_gethostbyname(externhost, &ahp))) {
1636                                 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
1637                         } else
1638                                 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
1639                 }
1640                 *us = externip.sin_addr;
1641                 if (option_debug) {
1642                         char iabuf[INET_ADDRSTRLEN];
1643                         ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
1644                         ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
1645                 }
1646         } else if (bindaddr.sin_addr.s_addr)
1647                 *us = bindaddr.sin_addr;
1648         return AST_SUCCESS;
1649 }
1650
1651 /*! \brief Append to SIP dialog history 
1652         \return Always returns 0 */
1653 #define append_history(p, event, fmt , args... )        append_history_full(p, "%-15s " fmt, event, ## args)
1654
1655 static void append_history_full(struct sip_pvt *p, const char *fmt, ...)
1656         __attribute__ ((format (printf, 2, 3)));
1657
1658 /*! \brief Append to SIP dialog history with arg list  */
1659 static void append_history_va(struct sip_pvt *p, const char *fmt, va_list ap)
1660 {
1661         char buf[80], *c = buf; /* max history length */
1662         struct sip_history *hist;
1663         int l;
1664
1665         vsnprintf(buf, sizeof(buf), fmt, ap);
1666         strsep(&c, "\r\n"); /* Trim up everything after \r or \n */
1667         l = strlen(buf) + 1;
1668         if (!(hist = ast_calloc(1, sizeof(*hist) + l)))
1669                 return;
1670         if (!p->history && !(p->history = ast_calloc(1, sizeof(*p->history)))) {
1671                 free(hist);
1672                 return;
1673         }
1674         memcpy(hist->event, buf, l);
1675         AST_LIST_INSERT_TAIL(p->history, hist, list);
1676 }
1677
1678 /*! \brief Append to SIP dialog history with arg list  */
1679 static void append_history_full(struct sip_pvt *p, const char *fmt, ...)
1680 {
1681         va_list ap;
1682
1683         if (!recordhistory || !p)
1684                 return;
1685         va_start(ap, fmt);
1686         append_history_va(p, fmt, ap);
1687         va_end(ap);
1688
1689         return;
1690 }
1691
1692 /*! \brief Retransmit SIP message if no answer (Called from scheduler) */
1693 static int retrans_pkt(void *data)
1694 {
1695         struct sip_pkt *pkt = data, *prev, *cur = NULL;
1696         char iabuf[INET_ADDRSTRLEN];
1697         int reschedule = DEFAULT_RETRANS;
1698
1699         /* Lock channel PVT */
1700         ast_mutex_lock(&pkt->owner->lock);
1701
1702         if (pkt->retrans < MAX_RETRANS) {
1703                 pkt->retrans++;
1704                 if (!pkt->timer_t1) {   /* Re-schedule using timer_a and timer_t1 */
1705                         if (sipdebug && option_debug > 3)
1706                                 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);
1707                 } else {
1708                         int siptimer_a;
1709
1710                         if (sipdebug && option_debug > 3)
1711                                 ast_log(LOG_DEBUG, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n", pkt->retransid, pkt->retrans, sip_methods[pkt->method].text, pkt->method);
1712                         if (!pkt->timer_a)
1713                                 pkt->timer_a = 2 ;
1714                         else
1715                                 pkt->timer_a = 2 * pkt->timer_a;
1716  
1717                         /* For non-invites, a maximum of 4 secs */
1718                         siptimer_a = pkt->timer_t1 * pkt->timer_a;      /* Double each time */
1719                         if (pkt->method != SIP_INVITE && siptimer_a > 4000)
1720                                 siptimer_a = 4000;
1721                 
1722                         /* Reschedule re-transmit */
1723                         reschedule = siptimer_a;
1724                         if (option_debug > 3)
1725                                 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);
1726                 } 
1727
1728                 if (sip_debug_test_pvt(pkt->owner)) {
1729                         const struct sockaddr_in *dst = sip_real_dst(pkt->owner);
1730                         ast_verbose("Retransmitting #%d (%s) to %s:%d:\n%s\n---\n",
1731                                 pkt->retrans, sip_nat_mode(pkt->owner),
1732                                 ast_inet_ntoa(iabuf, sizeof(iabuf), dst->sin_addr),
1733                                 ntohs(dst->sin_port), pkt->data);
1734                 }
1735
1736                 append_history(pkt->owner, "ReTx", "%d %s", reschedule, pkt->data);
1737                 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
1738                 ast_mutex_unlock(&pkt->owner->lock);
1739                 return  reschedule;
1740         } 
1741         /* Too many retries */
1742         if (pkt->owner && pkt->method != SIP_OPTIONS) {
1743                 if (ast_test_flag(pkt, FLAG_FATAL) || sipdebug) /* Tell us if it's critical or if we're debugging */
1744                         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");
1745         } else {
1746                 if ((pkt->method == SIP_OPTIONS) && sipdebug)
1747                         ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s) \n", pkt->owner->callid);
1748         }
1749         append_history(pkt->owner, "MaxRetries", "%s", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
1750                 
1751         pkt->retransid = -1;
1752
1753         if (ast_test_flag(pkt, FLAG_FATAL)) {
1754                 while(pkt->owner->owner && ast_channel_trylock(pkt->owner->owner)) {
1755                         ast_mutex_unlock(&pkt->owner->lock);    /* SIP_PVT, not channel */
1756                         usleep(1);
1757                         ast_mutex_lock(&pkt->owner->lock);
1758                 }
1759                 if (pkt->owner->owner) {
1760                         ast_set_flag(&pkt->owner->flags[0], SIP_ALREADYGONE);
1761                         ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet.\n", pkt->owner->callid);
1762                         ast_queue_hangup(pkt->owner->owner);
1763                         ast_channel_unlock(pkt->owner->owner);
1764                 } else {
1765                         /* If no channel owner, destroy now */
1766                         ast_set_flag(&pkt->owner->flags[0], SIP_NEEDDESTROY);   
1767                 }
1768         }
1769         /* In any case, go ahead and remove the packet */
1770         for (prev = NULL, cur = pkt->owner->packets; cur; prev = cur, cur = cur->next) {
1771                 if (cur == pkt)
1772                         break;
1773         }
1774         if (cur) {
1775                 if (prev)
1776                         prev->next = cur->next;
1777                 else
1778                         pkt->owner->packets = cur->next;
1779                 ast_mutex_unlock(&pkt->owner->lock);
1780                 free(cur);
1781                 pkt = NULL;
1782         } else
1783                 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
1784         if (pkt)
1785                 ast_mutex_unlock(&pkt->owner->lock);
1786         return 0;
1787 }
1788
1789 /*! \brief Transmit packet with retransmits 
1790         \return 0 on success, -1 on failure to allocate packet 
1791 */
1792 static enum sip_result __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod)
1793 {
1794         struct sip_pkt *pkt;
1795         int siptimer_a = DEFAULT_RETRANS;
1796
1797         if (!(pkt = ast_calloc(1, sizeof(*pkt) + len + 1)))
1798                 return AST_FAILURE;
1799         memcpy(pkt->data, data, len);
1800         pkt->method = sipmethod;
1801         pkt->packetlen = len;
1802         pkt->next = p->packets;
1803         pkt->owner = p;
1804         pkt->seqno = seqno;
1805         pkt->flags = resp;
1806         pkt->data[len] = '\0';
1807         pkt->timer_t1 = p->timer_t1;    /* Set SIP timer T1 */
1808         if (fatal)
1809                 ast_set_flag(pkt, FLAG_FATAL);
1810         if (pkt->timer_t1)
1811                 siptimer_a = pkt->timer_t1 * 2;
1812
1813         /* Schedule retransmission */
1814         pkt->retransid = ast_sched_add_variable(sched, siptimer_a, retrans_pkt, pkt, 1);
1815         if (option_debug > 3 && sipdebug)
1816                 ast_log(LOG_DEBUG, "*** SIP TIMER: Initalizing retransmit timer on packet: Id  #%d\n", pkt->retransid);
1817         pkt->next = p->packets;
1818         p->packets = pkt;
1819
1820         __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);      /* Send packet */
1821         if (sipmethod == SIP_INVITE) {
1822                 /* Note this is a pending invite */
1823                 p->pendinginvite = seqno;
1824         }
1825         return AST_SUCCESS;
1826 }
1827
1828 /*! \brief Kill a SIP dialog (called by scheduler) */
1829 static int __sip_autodestruct(void *data)
1830 {
1831         struct sip_pvt *p = data;
1832
1833         /* If this is a subscription, tell the phone that we got a timeout */
1834         if (p->subscribed) {
1835                 p->subscribed = TIMEOUT;
1836                 transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1); /* Send last notification */
1837                 p->subscribed = NONE;
1838                 append_history(p, "Subscribestatus", "timeout");
1839                 if (option_debug > 2)
1840                         ast_log(LOG_DEBUG, "Re-scheduled destruction of SIP subsription %s\n", p->callid ? p->callid : "<unknown>");
1841                 return 10000;   /* Reschedule this destruction so that we know that it's gone */
1842         }
1843
1844         /* Reset schedule ID */
1845         p->autokillid = -1;
1846
1847         if (option_debug)
1848                 ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
1849         append_history(p, "AutoDestroy", "%s", p->callid);
1850         if (p->owner) {
1851                 ast_log(LOG_WARNING, "Autodestruct on dialog '%s' with owner in place (Method: %s)\n", p->callid, sip_methods[p->method].text);
1852                 ast_queue_hangup(p->owner);
1853         } else if (p->refer) {
1854                 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
1855         } else {
1856                 sip_destroy(p);
1857         }
1858         return 0;
1859 }
1860
1861 /*! \brief Schedule destruction of SIP call */
1862 static void sip_scheddestroy(struct sip_pvt *p, int ms)
1863 {
1864         if (sip_debug_test_pvt(p))
1865                 ast_verbose("Scheduling destruction of SIP dialog '%s' in %d ms (Method: %s)\n", p->callid, ms, sip_methods[p->method].text);
1866         if (recordhistory)
1867                 append_history(p, "SchedDestroy", "%d ms", ms);
1868
1869         if (p->autokillid > -1)
1870                 ast_sched_del(sched, p->autokillid);
1871         p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
1872 }
1873
1874 /*! \brief Cancel destruction of SIP dialog */
1875 static void sip_cancel_destroy(struct sip_pvt *p)
1876 {
1877         if (p->autokillid > -1) {
1878                 ast_sched_del(sched, p->autokillid);
1879                 append_history(p, "CancelDestroy", "");
1880                 p->autokillid = -1;
1881         }
1882 }
1883
1884 /*! \brief Acknowledges receipt of a packet and stops retransmission */
1885 static void __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod, int reset)
1886 {
1887         struct sip_pkt *cur, *prev = NULL;
1888
1889         /* Just in case... */
1890         char *msg;
1891         int res = FALSE;
1892
1893         msg = sip_methods[sipmethod].text;
1894
1895         ast_mutex_lock(&p->lock);
1896         for (cur = p->packets; cur; prev = cur, cur = cur->next) {
1897                 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
1898                         ((ast_test_flag(cur, FLAG_RESPONSE)) || 
1899                          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
1900                         if (!resp && (seqno == p->pendinginvite)) {
1901                                 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
1902                                 p->pendinginvite = 0;
1903                         }
1904                         /* this is our baby */
1905                         res = TRUE;
1906                         UNLINK(cur, p->packets, prev);
1907                         if (cur->retransid > -1) {
1908                                 if (sipdebug && option_debug > 3)
1909                                         ast_log(LOG_DEBUG, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
1910                                 ast_sched_del(sched, cur->retransid);
1911                         }
1912                         if (!reset)
1913                                 free(cur);
1914                         break;
1915                 }
1916         }
1917         ast_mutex_unlock(&p->lock);
1918         if (option_debug)
1919                 ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: Match %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
1920 }
1921
1922 /*! \brief Pretend to ack all packets
1923  * maybe the lock on p is not strictly necessary but there might be a race */
1924 static void __sip_pretend_ack(struct sip_pvt *p)
1925 {
1926         struct sip_pkt *cur = NULL;
1927
1928         while (p->packets) {
1929                 int method;
1930                 if (cur == p->packets) {
1931                         ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
1932                         return;
1933                 }
1934                 cur = p->packets;
1935                 method = (cur->method) ? cur->method : find_sip_method(cur->data);
1936                 __sip_ack(p, cur->seqno, ast_test_flag(cur, FLAG_RESPONSE), method, FALSE);
1937         }
1938 }
1939
1940 /*! \brief Acks receipt of packet, keep it around (used for provisional responses) */
1941 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
1942 {
1943         struct sip_pkt *cur;
1944         int res = -1;
1945
1946         for (cur = p->packets; cur; cur = cur->next) {
1947                 if (cur->seqno == seqno && ast_test_flag(cur, FLAG_RESPONSE) == resp &&
1948                         (ast_test_flag(cur, FLAG_RESPONSE) || method_match(sipmethod, cur->data))) {
1949                         /* this is our baby */
1950                         if (cur->retransid > -1) {
1951                                 if (option_debug > 3 && sipdebug)
1952                                         ast_log(LOG_DEBUG, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, sip_methods[sipmethod].text);
1953                                 ast_sched_del(sched, cur->retransid);
1954                         }
1955                         cur->retransid = -1;
1956                         res = 0;
1957                         break;
1958                 }
1959         }
1960         if (option_debug)
1961                 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");
1962         return res;
1963 }
1964
1965
1966 /*! \brief Copy SIP request, parse it */
1967 static void parse_copy(struct sip_request *dst, const struct sip_request *src)
1968 {
1969         memset(dst, 0, sizeof(*dst));
1970         memcpy(dst->data, src->data, sizeof(dst->data));
1971         dst->len = src->len;
1972         parse_request(dst);
1973 }
1974
1975 /* add a blank line if no body */
1976 static void add_blank(struct sip_request *req)
1977 {
1978         if (!req->lines) {
1979                 /* Add extra empty return. add_header() reserves 4 bytes so cannot be truncated */
1980                 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
1981                 req->len += strlen(req->data + req->len);
1982         }
1983 }
1984
1985 /*! \brief Transmit response on SIP request*/
1986 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
1987 {
1988         int res;
1989
1990         add_blank(req);
1991         if (sip_debug_test_pvt(p)) {
1992                 char iabuf[INET_ADDRSTRLEN];
1993                 const struct sockaddr_in *dst = sip_real_dst(p);
1994
1995                 ast_verbose("%sTransmitting (%s) to %s:%d:\n%s\n---\n",
1996                         reliable ? "Reliably " : "", sip_nat_mode(p),
1997                         ast_inet_ntoa(iabuf, sizeof(iabuf), dst->sin_addr),
1998                         ntohs(dst->sin_port), req->data);
1999         }
2000         if (recordhistory) {
2001                 struct sip_request tmp;
2002                 parse_copy(&tmp, req);
2003                 append_history(p, reliable ? "TxRespRel" : "TxResp", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"), 
2004                         tmp.method == SIP_RESPONSE ? tmp.rlPart2 : sip_methods[tmp.method].text);
2005         }
2006         res = (reliable) ?
2007                 __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable == XMIT_CRITICAL), req->method) :
2008                 __sip_xmit(p, req->data, req->len);
2009         if (res > 0)
2010                 return 0;
2011         return res;
2012 }
2013
2014 /*! \brief Send SIP Request to the other part of the dialogue */
2015 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
2016 {
2017         int res;
2018
2019         add_blank(req);
2020         if (sip_debug_test_pvt(p)) {
2021                 char iabuf[INET_ADDRSTRLEN];
2022                 if (ast_test_flag(&p->flags[0], SIP_NAT_ROUTE))
2023                         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);
2024                 else
2025                         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);
2026         }
2027         if (recordhistory) {
2028                 struct sip_request tmp;
2029                 parse_copy(&tmp, req);
2030                 append_history(p, reliable ? "TxReqRel" : "TxReq", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"), sip_methods[tmp.method].text);
2031         }
2032         res = (reliable) ?
2033                 __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1), req->method) :
2034                 __sip_xmit(p, req->data, req->len);
2035         return res;
2036 }
2037
2038 /*! \brief Pick out text in brackets from character string
2039         \return pointer to terminated stripped string
2040         \param tmp input string that will be modified */
2041 static char *get_in_brackets(char *tmp)
2042 {
2043         char *parse;
2044         char *first_quote;
2045         char *first_bracket;
2046         char *second_bracket;
2047         char last_char;
2048
2049         parse = tmp;
2050         for (;;) {
2051                 first_quote = strchr(parse, '"');
2052                 first_bracket = strchr(parse, '<');
2053                 if (first_quote && first_bracket && (first_quote < first_bracket)) {
2054                         last_char = '\0';
2055                         for (parse = first_quote + 1; *parse; parse++) {
2056                                 if ((*parse == '"') && (last_char != '\\'))
2057                                         break;
2058                                 last_char = *parse;
2059                         }
2060                         if (!*parse) {
2061                                 ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
2062                                 return tmp;
2063                         }
2064                         parse++;
2065                         continue;
2066                 }
2067                 if (first_bracket) {
2068                         second_bracket = strchr(first_bracket + 1, '>');
2069                         if (second_bracket) {
2070                                 *second_bracket = '\0';
2071                                 return first_bracket + 1;
2072                         } else {
2073                                 ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
2074                                 return tmp;
2075                         }
2076                 }
2077                 return tmp;
2078         }
2079 }
2080
2081 /*! \brief Send SIP MESSAGE text within a call
2082         Called from PBX core sendtext() application */
2083 static int sip_sendtext(struct ast_channel *ast, const char *text)
2084 {
2085         struct sip_pvt *p = ast->tech_pvt;
2086         int debug = sip_debug_test_pvt(p);
2087
2088         if (debug)
2089                 ast_verbose("Sending text %s on %s\n", text, ast->name);
2090         if (!p)
2091                 return -1;
2092         if (ast_strlen_zero(text))
2093                 return 0;
2094         if (debug)
2095                 ast_verbose("Really sending text %s on %s\n", text, ast->name);
2096         transmit_message_with_text(p, text);
2097         return 0;       
2098 }
2099
2100 /*! \brief Update peer object in realtime storage */
2101 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expirey)
2102 {
2103         char port[10];
2104         char ipaddr[20];
2105         char regseconds[20];
2106         time_t nowtime = time(NULL) + expirey;
2107         const char *fc = fullcontact ? "fullcontact" : NULL;
2108         
2109         snprintf(regseconds, sizeof(regseconds), "%d", (int)nowtime);   /* Expiration time */
2110         ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
2111         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
2112         
2113         ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr,
2114                 "port", port, "regseconds", regseconds,
2115                 "username", username, fc, fullcontact, NULL); /* note fc _can_ be NULL */
2116 }
2117
2118 /*! \brief Automatically add peer extension to dial plan */
2119 static void register_peer_exten(struct sip_peer *peer, int onoff)
2120 {
2121         char multi[256];
2122         char *stringp, *ext, *context;
2123
2124         /* XXX note that global_regcontext is both a global 'enable' flag and
2125          * the name of the global regexten context, if not specified
2126          * individually.
2127          */
2128         if (ast_strlen_zero(global_regcontext))
2129                 return;
2130
2131         ast_copy_string(multi, S_OR(peer->regexten, peer->name), sizeof(multi));
2132         stringp = multi;
2133         while ((ext = strsep(&stringp, "&"))) {
2134                 if ((context = strchr(ext, '@'))) {
2135                         *context++ = '\0';      /* split ext@context */
2136                         if (!ast_context_find(context)) {
2137                                 ast_log(LOG_WARNING, "Context %s must exist in regcontext= in sip.conf!\n", context);
2138                                 continue;
2139                         }
2140                 } else {
2141                         context = global_regcontext;
2142                 }
2143                 if (onoff)
2144                         ast_add_extension(context, 1, ext, 1, NULL, NULL, "Noop",
2145                                  ast_strdup(peer->name), free, "SIP");
2146                 else
2147                         ast_context_remove_extension(context, ext, 1, NULL);
2148         }
2149 }
2150
2151 /*! \brief Destroy peer object from memory */
2152 static void sip_destroy_peer(struct sip_peer *peer)
2153 {
2154         if (option_debug > 2)
2155                 ast_log(LOG_DEBUG, "Destroying SIP peer %s\n", peer->name);
2156
2157         /* Delete it, it needs to disappear */
2158         if (peer->call)
2159                 sip_destroy(peer->call);
2160
2161         if (peer->mwipvt) {     /* We have an active subscription, delete it */
2162                 sip_destroy(peer->mwipvt);
2163         }
2164
2165         if (peer->chanvars) {
2166                 ast_variables_destroy(peer->chanvars);
2167                 peer->chanvars = NULL;
2168         }
2169         if (peer->expire > -1)
2170                 ast_sched_del(sched, peer->expire);
2171         if (peer->pokeexpire > -1)
2172                 ast_sched_del(sched, peer->pokeexpire);
2173         register_peer_exten(peer, FALSE);
2174         ast_free_ha(peer->ha);
2175         if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT))
2176                 apeerobjs--;
2177         else if (ast_test_flag(&peer->flags[0], SIP_REALTIME))
2178                 rpeerobjs--;
2179         else
2180                 speerobjs--;
2181         clear_realm_authentication(peer->auth);
2182         peer->auth = NULL;
2183         if (peer->dnsmgr)
2184                 ast_dnsmgr_release(peer->dnsmgr);
2185         free(peer);
2186 }
2187
2188 /*! \brief Update peer data in database (if used) */
2189 static void update_peer(struct sip_peer *p, int expiry)
2190 {
2191         int rtcachefriends = ast_test_flag(&p->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
2192         if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTUPDATE) &&
2193             (ast_test_flag(&p->flags[0], SIP_REALTIME) || rtcachefriends)) {
2194                 realtime_update_peer(p->name, &p->addr, p->username, rtcachefriends ? p->fullcontact : NULL, expiry);
2195         }
2196 }
2197
2198
2199 /*! \brief  realtime_peer: Get peer from realtime storage
2200  * Checks the "sippeers" realtime family from extconfig.conf 
2201  * \todo Consider adding check of port address when matching here to follow the same
2202  *      algorithm as for static peers. Will we break anything by adding that?
2203 */
2204 static struct sip_peer *realtime_peer(const char *newpeername, struct sockaddr_in *sin)
2205 {
2206         struct sip_peer *peer;
2207         struct ast_variable *var = NULL;
2208         struct ast_variable *tmp;
2209         char iabuf[80];
2210
2211         /* First check on peer name */
2212         if (newpeername) 
2213                 var = ast_load_realtime("sippeers", "name", newpeername, NULL);
2214         else if (sin) { /* Then check on IP address for dynamic peers */
2215                 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
2216                 var = ast_load_realtime("sippeers", "host", iabuf, NULL);       /* First check for fixed IP hosts */
2217                 if (!var)
2218                         var = ast_load_realtime("sippeers", "ipaddr", iabuf, NULL);     /* Then check for registred hosts */
2219         
2220         }
2221
2222         if (!var)
2223                 return NULL;
2224
2225         for (tmp = var; tmp; tmp = tmp->next) {
2226                 /* If this is type=user, then skip this object. */
2227                 if (!strcasecmp(tmp->name, "type") &&
2228                     !strcasecmp(tmp->value, "user")) {
2229                         ast_variables_destroy(var);
2230                         return NULL;
2231                 } else if (!newpeername && !strcasecmp(tmp->name, "name")) {
2232                         newpeername = tmp->value;
2233                 }
2234         }
2235         
2236         if (!newpeername) {     /* Did not find peer in realtime */
2237                 ast_log(LOG_WARNING, "Cannot Determine peer name ip=%s\n", iabuf);
2238                 ast_variables_destroy(var);
2239                 return NULL;
2240         }
2241
2242         /* Peer found in realtime, now build it in memory */
2243         peer = build_peer(newpeername, var, !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS));
2244         if (!peer) {
2245                 ast_variables_destroy(var);
2246                 return NULL;
2247         }
2248
2249         if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
2250                 /* Cache peer */
2251                 ast_copy_flags(&peer->flags[1],&global_flags[1], SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
2252                 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTAUTOCLEAR)) {
2253                         if (peer->expire > -1) {
2254                                 ast_sched_del(sched, peer->expire);
2255                         }
2256                         peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, (void *)peer);
2257                 }
2258                 ASTOBJ_CONTAINER_LINK(&peerl,peer);
2259         } else {
2260                 ast_set_flag(&peer->flags[0], SIP_REALTIME);
2261         }
2262         ast_variables_destroy(var);
2263
2264         return peer;
2265 }
2266
2267 /*! \brief Support routine for find_peer */
2268 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
2269 {
2270         /* We know name is the first field, so we can cast */
2271         struct sip_peer *p = (struct sip_peer *) name;
2272         return  !(!inaddrcmp(&p->addr, sin) || 
2273                                         (ast_test_flag(&p->flags[0], SIP_INSECURE_PORT) &&
2274                                         (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
2275 }
2276
2277 /*! \brief Locate peer by name or ip address 
2278  *      This is used on incoming SIP message to find matching peer on ip
2279         or outgoing message to find matching peer on name */
2280 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
2281 {
2282         struct sip_peer *p = NULL;
2283
2284         if (peer)
2285                 p = ASTOBJ_CONTAINER_FIND(&peerl, peer);
2286         else
2287                 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl, sin, name, sip_addr_hashfunc, 1, sip_addrcmp);
2288
2289         if (!p && realtime) {
2290                 p = realtime_peer(peer, sin);
2291         }
2292         return p;
2293 }
2294
2295 /*! \brief Remove user object from in-memory storage */
2296 static void sip_destroy_user(struct sip_user *user)
2297 {
2298         if (option_debug > 2)
2299                 ast_log(LOG_DEBUG, "Destroying user object from memory: %s\n", user->name);
2300         ast_free_ha(user->ha);
2301         if (user->chanvars) {
2302                 ast_variables_destroy(user->chanvars);
2303                 user->chanvars = NULL;
2304         }
2305         if (ast_test_flag(&user->flags[0], SIP_REALTIME))
2306                 ruserobjs--;
2307         else
2308                 suserobjs--;
2309         free(user);
2310 }
2311
2312 /*! \brief Load user from realtime storage
2313  * Loads user from "sipusers" category in realtime (extconfig.conf)
2314  * Users are matched on From: user name (the domain in skipped) */
2315 static struct sip_user *realtime_user(const char *username)
2316 {
2317         struct ast_variable *var;
2318         struct ast_variable *tmp;
2319         struct sip_user *user = NULL;
2320
2321         var = ast_load_realtime("sipusers", "name", username, NULL);
2322
2323         if (!var)
2324                 return NULL;
2325
2326         for (tmp = var; tmp; tmp = tmp->next) {
2327                 if (!strcasecmp(tmp->name, "type") &&
2328                         !strcasecmp(tmp->value, "peer")) {
2329                         ast_variables_destroy(var);
2330                         return NULL;
2331                 }
2332         }
2333
2334         user = build_user(username, var, !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS));
2335         
2336         if (!user) {    /* No user found */
2337                 ast_variables_destroy(var);
2338                 return NULL;
2339         }
2340
2341         if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
2342                 ast_set_flag(&user->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
2343                 suserobjs++;
2344                 ASTOBJ_CONTAINER_LINK(&userl,user);
2345         } else {
2346                 /* Move counter from s to r... */
2347                 suserobjs--;
2348                 ruserobjs++;
2349                 ast_set_flag(&user->flags[0], SIP_REALTIME);
2350         }
2351         ast_variables_destroy(var);
2352         return user;
2353 }
2354
2355 /*! \brief Locate user by name 
2356  * Locates user by name (From: sip uri user name part) first
2357  * from in-memory list (static configuration) then from 
2358  * realtime storage (defined in extconfig.conf) */
2359 static struct sip_user *find_user(const char *name, int realtime)
2360 {
2361         struct sip_user *u = ASTOBJ_CONTAINER_FIND(&userl, name);
2362         if (!u && realtime)
2363                 u = realtime_user(name);
2364         return u;
2365 }
2366
2367 /*! \brief Create address structure from peer reference.
2368  *  return -1 on error, 0 on success.
2369  */
2370 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer)
2371 {
2372         int natflags;
2373
2374         if ((peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr) &&
2375             (!peer->maxms || ((peer->lastms >= 0)  && (peer->lastms <= peer->maxms)))) {
2376                 r->sa = (peer->addr.sin_addr.s_addr) ? peer->addr : peer->defaddr;
2377                 r->recv = r->sa;
2378         } else {
2379                 return -1;
2380         }
2381
2382         ast_copy_flags(&r->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
2383         ast_copy_flags(&r->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
2384         r->capability = peer->capability;
2385         if (!ast_test_flag(&r->flags[1], SIP_PAGE2_VIDEOSUPPORT) && r->vrtp) {
2386                 ast_rtp_destroy(r->vrtp);
2387                 r->vrtp = NULL;
2388         }
2389         r->prefs = peer->prefs;
2390         natflags = ast_test_flag(&r->flags[0], SIP_NAT) & SIP_NAT_ROUTE;
2391         if (r->rtp) {
2392                 if (option_debug)
2393                         ast_log(LOG_DEBUG, "Setting NAT on RTP to %s\n", natflags ? "On" : "Off");
2394                 ast_rtp_setnat(r->rtp, natflags);
2395                 ast_rtp_setdtmf(r->rtp, ast_test_flag(&r->flags[0], SIP_DTMF) != SIP_DTMF_INFO);
2396         }
2397         if (r->vrtp) {
2398                 if (option_debug)
2399                         ast_log(LOG_DEBUG, "Setting NAT on VRTP to %s\n", natflags ? "On" : "Off");
2400                 ast_rtp_setnat(r->vrtp, natflags);
2401                 ast_rtp_setdtmf(r->vrtp, 0);
2402         }
2403         ast_string_field_set(r, peername, peer->username);
2404         ast_string_field_set(r, authname, peer->username);
2405         ast_string_field_set(r, username, peer->username);
2406         ast_string_field_set(r, peersecret, peer->secret);
2407         ast_string_field_set(r, peermd5secret, peer->md5secret);
2408         ast_string_field_set(r, tohost, peer->tohost);
2409         ast_string_field_set(r, fullcontact, peer->fullcontact);
2410         if (!r->initreq.headers && !ast_strlen_zero(peer->fromdomain)) {
2411                 char *tmpcall;
2412                 char *c;
2413                 tmpcall = ast_strdupa(r->callid);
2414                 c = strchr(tmpcall, '@');
2415                 if (c) {
2416                         *c = '\0';
2417                         ast_string_field_build(r, callid, "%s@%s", tmpcall, peer->fromdomain);
2418                 }
2419         }
2420         if (ast_strlen_zero(r->tohost)) {
2421                 char iabuf[INET_ADDRSTRLEN];
2422
2423                 ast_inet_ntoa(iabuf, sizeof(iabuf),  r->sa.sin_addr);
2424                 ast_string_field_set(r, tohost, iabuf);
2425         }
2426         if (!ast_strlen_zero(peer->fromdomain))
2427                 ast_string_field_set(r, fromdomain, peer->fromdomain);
2428         if (!ast_strlen_zero(peer->fromuser))
2429                 ast_string_field_set(r, fromuser, peer->fromuser);
2430         r->maxtime = peer->maxms;
2431         r->callgroup = peer->callgroup;
2432         r->pickupgroup = peer->pickupgroup;
2433         r->allowtransfer = peer->allowtransfer;
2434         /* Set timer T1 to RTT for this peer (if known by qualify=) */
2435         /* Minimum is settable or default to 100 ms */
2436         if (peer->maxms && peer->lastms)
2437                 r->timer_t1 = peer->lastms < global_t1min ? global_t1min : peer->lastms;
2438         if ((ast_test_flag(&r->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
2439             (ast_test_flag(&r->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
2440                 r->noncodeccapability |= AST_RTP_DTMF;
2441         else
2442                 r->noncodeccapability &= ~AST_RTP_DTMF;
2443         ast_string_field_set(r, context, peer->context);
2444         r->rtptimeout = peer->rtptimeout;
2445         r->rtpholdtimeout = peer->rtpholdtimeout;
2446         r->rtpkeepalive = peer->rtpkeepalive;
2447         if (peer->call_limit)
2448                 ast_set_flag(&r->flags[0], SIP_CALL_LIMIT);
2449         r->maxcallbitrate = peer->maxcallbitrate;
2450         
2451         return 0;
2452 }
2453
2454 /*! \brief create address structure from peer name
2455  *      Or, if peer not found, find it in the global DNS 
2456  *      returns TRUE (-1) on failure, FALSE on success */
2457 static int create_addr(struct sip_pvt *dialog, const char *opeer)
2458 {
2459         struct hostent *hp;
2460         struct ast_hostent ahp;
2461         struct sip_peer *p;
2462         char *port;
2463         int portno;
2464         char host[MAXHOSTNAMELEN], *hostn;
2465         char peer[256];
2466
2467         ast_copy_string(peer, opeer, sizeof(peer));
2468         port = strchr(peer, ':');
2469         if (port)
2470                 *port++ = '\0';
2471         dialog->sa.sin_family = AF_INET;
2472         dialog->timer_t1 = 500; /* Default SIP retransmission timer T1 (RFC 3261) */
2473         p = find_peer(peer, NULL, 1);
2474
2475         if (p) {
2476                 int res = create_addr_from_peer(dialog, p);
2477                 ASTOBJ_UNREF(p, sip_destroy_peer);
2478                 return res;
2479         }
2480         hostn = peer;
2481         portno = port ? atoi(port) : DEFAULT_SIP_PORT;
2482         if (srvlookup) {
2483                 char service[MAXHOSTNAMELEN];
2484                 int tportno;
2485                 int ret;
2486
2487                 snprintf(service, sizeof(service), "_sip._udp.%s", peer);
2488                 ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
2489                 if (ret > 0) {
2490                         hostn = host;
2491                         portno = tportno;
2492                 }
2493         }
2494         hp = ast_gethostbyname(hostn, &ahp);
2495         if (!hp) {
2496                 ast_log(LOG_WARNING, "No such host: %s\n", peer);
2497                 return -1;
2498         }
2499         ast_string_field_set(dialog, tohost, peer);
2500         memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr));
2501         dialog->sa.sin_port = htons(portno);
2502         dialog->recv = dialog->sa;
2503         return 0;
2504 }
2505
2506 /*! \brief Scheduled congestion on a call */
2507 static int auto_congest(void *nothing)
2508 {
2509         struct sip_pvt *p = nothing;
2510
2511         ast_mutex_lock(&p->lock);
2512         p->initid = -1;
2513         if (p->owner) {
2514                 /* XXX fails on possible deadlock */
2515                 if (!ast_channel_trylock(p->owner)) {
2516                         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
2517                         append_history(p, "Cong", "Auto-congesting (timer)");
2518                         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
2519                         ast_channel_unlock(p->owner);
2520                 }
2521         }
2522         ast_mutex_unlock(&p->lock);
2523         return 0;
2524 }
2525
2526
2527 /*! \brief Initiate SIP call from PBX 
2528  *      used from the dial() application      */
2529 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
2530 {
2531         int res;
2532         struct sip_pvt *p;
2533         struct varshead *headp;
2534         struct ast_var_t *current;
2535         const char *referer = NULL;   /* SIP refererer */       
2536
2537         p = ast->tech_pvt;
2538         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
2539                 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
2540                 return -1;
2541         }
2542
2543         /* Check whether there is vxml_url, distinctive ring variables */
2544         headp=&ast->varshead;
2545         AST_LIST_TRAVERSE(headp,current,entries) {
2546                 /* Check whether there is a VXML_URL variable */
2547                 if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
2548                         p->options->vxml_url = ast_var_value(current);
2549                 } else if (!p->options->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
2550                         p->options->uri_options = ast_var_value(current);
2551                 } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
2552                         /* Check whether there is a ALERT_INFO variable */
2553                         p->options->distinctive_ring = ast_var_value(current);
2554                 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
2555                         /* Check whether there is a variable with a name starting with SIPADDHEADER */
2556                         p->options->addsipheaders = 1;
2557                 } else if (!strcasecmp(ast_var_name(current),"SIPTRANSFER")) {
2558                         /* This is a transfered call */
2559                         p->options->transfer = 1;
2560                 } else if (!strcasecmp(ast_var_name(current),"SIPTRANSFER_REFERER")) {
2561                         /* This is the referer */
2562                         referer = ast_var_value(current);
2563                 } else if (!strcasecmp(ast_var_name(current),"SIPTRANSFER_REPLACES")) {
2564                         /* We're replacing a call. */
2565                         p->options->replaces = ast_var_value(current);
2566                 }
2567         }
2568         
2569         res = 0;
2570         ast_set_flag(&p->flags[0], SIP_OUTGOING);
2571
2572         if (p->options->transfer) {
2573                 char buf[BUFSIZ/2];
2574
2575                 if (referer) {
2576                         if (sipdebug && option_debug > 2)
2577                                 ast_log(LOG_DEBUG, "Call for %s transfered by %s\n", p->username, referer);
2578                         snprintf(buf, sizeof(buf)-1, "-> %s (via %s)", p->cid_name, referer);
2579                 } else {
2580                         snprintf(buf, sizeof(buf)-1, "-> %s", p->cid_name);
2581                 }
2582                 ast_string_field_set(p, cid_name, buf);
2583         } 
2584         if (option_debug)
2585                 ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
2586
2587         res = update_call_counter(p, INC_CALL_RINGING);
2588         if ( res != -1 ) {
2589                 p->callingpres = ast->cid.cid_pres;
2590                 p->jointcapability = p->capability;
2591                 transmit_invite(p, SIP_INVITE, 1, 2);
2592                 if (p->maxtime) {
2593                         /* Initialize auto-congest time */
2594                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
2595                 } else {
2596                         p->initid = ast_sched_add(sched, SIP_TRANS_TIMEOUT, auto_congest, p);
2597                 }
2598         }
2599         return res;
2600 }
2601
2602 /*! \brief Destroy registry object
2603         Objects created with the register= statement in static configuration */
2604 static void sip_registry_destroy(struct sip_registry *reg)
2605 {
2606         /* Really delete */
2607         if (option_debug > 2)
2608                 ast_log(LOG_DEBUG, "Destroying registry entry for %s@%s\n", reg->username, reg->hostname);
2609
2610         if (reg->call) {
2611                 /* Clear registry before destroying to ensure
2612                    we don't get reentered trying to grab the registry lock */
2613                 reg->call->registry = NULL;
2614                 if (option_debug > 2)
2615                         ast_log(LOG_DEBUG, "Destroying active SIP dialog for registry %s@%s\n", reg->username, reg->hostname);
2616                 sip_destroy(reg->call);
2617         }
2618         if (reg->expire > -1)
2619                 ast_sched_del(sched, reg->expire);
2620         if (reg->timeout > -1)
2621                 ast_sched_del(sched, reg->timeout);
2622         ast_string_field_free_all(reg);
2623         regobjs--;
2624         free(reg);
2625         
2626 }
2627
2628 /*! \brief Execute destruction of SIP dialog structure, release memory */
2629 static void __sip_destroy(struct sip_pvt *p, int lockowner)
2630 {
2631         struct sip_pvt *cur, *prev = NULL;
2632         struct sip_pkt *cp;
2633
2634         if (sip_debug_test_pvt(p) || option_debug > 2)
2635                 ast_verbose("Really destroying SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);
2636
2637         /* Remove link from peer to subscription of MWI */
2638         if (p->relatedpeer && p->relatedpeer->mwipvt)
2639                 p->relatedpeer->mwipvt = NULL;
2640
2641         if (dumphistory)
2642                 sip_dump_history(p);
2643
2644         if (p->options)
2645                 free(p->options);
2646
2647         if (p->stateid > -1)
2648                 ast_extension_state_del(p->stateid, NULL);
2649         if (p->initid > -1)
2650                 ast_sched_del(sched, p->initid);
2651         if (p->autokillid > -1)
2652                 ast_sched_del(sched, p->autokillid);
2653
2654         if (p->rtp)
2655                 ast_rtp_destroy(p->rtp);
2656         if (p->vrtp)
2657                 ast_rtp_destroy(p->vrtp);
2658         if (p->refer)
2659                 free(p->refer);
2660         if (p->route) {
2661                 free_old_route(p->route);
2662                 p->route = NULL;
2663         }
2664         if (p->registry) {
2665                 if (p->registry->call == p)
2666                         p->registry->call = NULL;
2667                 ASTOBJ_UNREF(p->registry, sip_registry_destroy);
2668         }
2669
2670         /* Unlink us from the owner if we have one */
2671         if (p->owner) {
2672                 if (lockowner)
2673                         ast_channel_lock(p->owner);
2674                 if (option_debug)
2675                         ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
2676                 p->owner->tech_pvt = NULL;
2677                 if (lockowner)
2678                         ast_channel_unlock(p->owner);
2679         }
2680         /* Clear history */
2681         if (p->history) {
2682                 struct sip_history *hist;
2683                 while( (hist = AST_LIST_REMOVE_HEAD(p->history, list)) )
2684                         free(hist);
2685                 free(p->history);
2686                 p->history = NULL;
2687         }
2688
2689         for (prev = NULL, cur = iflist; cur; prev = cur, cur = cur->next) {
2690                 if (cur == p) {
2691                         UNLINK(cur, iflist, prev);
2692                         break;
2693                 }
2694         }
2695         if (!cur) {
2696                 ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
2697                 return;
2698         } 
2699         if (p->initid > -1)
2700                 ast_sched_del(sched, p->initid);
2701
2702         /* remove all current packets in this dialog */
2703         while((cp = p->packets)) {
2704                 p->packets = p->packets->next;
2705                 if (cp->retransid > -1)
2706                         ast_sched_del(sched, cp->retransid);
2707                 free(cp);
2708         }
2709         if (p->chanvars) {
2710                 ast_variables_destroy(p->chanvars);
2711                 p->chanvars = NULL;
2712         }
2713         ast_mutex_destroy(&p->lock);
2714
2715         ast_string_field_free_all(p);
2716
2717         free(p);
2718 }
2719
2720 /*! \brief  update_call_counter: Handle call_limit for SIP users 
2721  * Setting a call-limit will cause calls above the limit not to be accepted.
2722  *
2723  * Remember that for a type=friend, there's one limit for the user and
2724  * another for the peer, not a combined call limit.
2725  * This will cause unexpected behaviour in subscriptions, since a "friend"
2726  * is *two* devices in Asterisk, not one.
2727  *
2728  * Thought: For realtime, we should propably update storage with inuse counter... 
2729  *
2730  * \return 0 if call is ok (no call limit, below treshold)
2731  *      -1 on rejection of call
2732  *              
2733  */
2734 static int update_call_counter(struct sip_pvt *fup, int event)
2735 {
2736         char name[256];
2737         int *inuse, *call_limit, *inringing = NULL;
2738         int outgoing = ast_test_flag(&fup->flags[0], SIP_OUTGOING);
2739         struct sip_user *u = NULL;
2740         struct sip_peer *p = NULL;
2741
2742         if (option_debug > 2)
2743                 ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
2744         /* Test if we need to check call limits, in order to avoid 
2745            realtime lookups if we do not need it */
2746         if (!ast_test_flag(&fup->flags[0], SIP_CALL_LIMIT))
2747                 return 0;
2748
2749         ast_copy_string(name, fup->username, sizeof(name));
2750
2751         /* Check the list of users */
2752         if (!outgoing)  /* Only check users for incoming calls */
2753                 u = find_user(name, 1);
2754
2755         if (u) {
2756                 inuse = &u->inUse;
2757                 call_limit = &u->call_limit;
2758                 p = NULL;
2759         } else {
2760                 /* Try to find peer */
2761                 if (!p)
2762                         p = find_peer(fup->peername, NULL, 1);
2763                 if (p) {
2764                         inuse = &p->inUse;
2765                         call_limit = &p->call_limit;
2766                         inringing = &p->inRinging;
2767                         ast_copy_string(name, fup->peername, sizeof(name));
2768                 } else {
2769                         if (option_debug > 1)
2770                                 ast_log(LOG_DEBUG, "%s is not a local device, no call limit\n", name);
2771                         return 0;
2772                 }
2773         }
2774         switch(event) {
2775                 /* incoming and outgoing affects the inUse counter */
2776                 case DEC_CALL_LIMIT:
2777                         if ( *inuse > 0 ) {
2778                                 if (ast_test_flag(&fup->flags[0], SIP_INC_COUNT))
2779                                         (*inuse)--;
2780                         } else {
2781                                 *inuse = 0;
2782                         }
2783                         if (inringing) {
2784                                 if (ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
2785                                         if (*inringing > 0)
2786                                                 (*inringing)--;
2787                                         else
2788                                                 ast_log(LOG_WARNING, "Inringing for peer '%s' < 0?\n", fup->peername);
2789                                         ast_clear_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
2790                                 }
2791                         }
2792                         if (option_debug > 1 || sipdebug) {
2793                                 ast_log(LOG_DEBUG, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
2794                         }
2795                         break;
2796                 case INC_CALL_RINGING:
2797                 case INC_CALL_LIMIT:
2798                         if (*call_limit > 0 ) {
2799                                 if (*inuse >= *call_limit) {
2800                                         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);
2801                                         if (u)
2802                                                 ASTOBJ_UNREF(u, sip_destroy_user);
2803                                         else
2804                                                 ASTOBJ_UNREF(p, sip_destroy_peer);
2805                                         return -1; 
2806                                 }
2807                         }
2808                         if (inringing && (event == INC_CALL_RINGING)) {
2809                                 if (!ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
2810                                         (*inringing)++;
2811                                         ast_set_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
2812                                 }
2813                         }
2814                         /* Continue */
2815                         (*inuse)++;
2816                         ast_set_flag(&fup->flags[0], SIP_INC_COUNT);
2817                         if (option_debug > 1 || sipdebug) {
2818                                 ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
2819                         }
2820                         break;
2821                 case DEC_CALL_RINGING:
2822                         if (inringing) {
2823                                 if (ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
2824                                         if (*inringing > 0)
2825                                                 (*inringing)--;
2826                                         else
2827                                                 ast_log(LOG_WARNING, "Inringing for peer '%s' < 0?\n", p->name);
2828                                         ast_clear_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
2829                                 }
2830                         }
2831                         break;
2832                 default:
2833                         ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
2834         }
2835         if (p)
2836                 ast_device_state_changed("SIP/%s", p->name);
2837         if (u)
2838                 ASTOBJ_UNREF(u, sip_destroy_user);
2839         else
2840                 ASTOBJ_UNREF(p, sip_destroy_peer);
2841         return 0;
2842 }
2843
2844 /*! \brief Destroy SIP call structure */
2845 static void sip_destroy(struct sip_pvt *p)
2846 {
2847         ast_mutex_lock(&iflock);
2848         if (option_debug > 2)
2849                 ast_log(LOG_DEBUG, "Destroying SIP dialog %s\n", p->callid);
2850         __sip_destroy(p, 1);
2851         ast_mutex_unlock(&iflock);
2852 }
2853
2854 /*! \brief Convert SIP hangup causes to Asterisk hangup causes */
2855 static int hangup_sip2cause(int cause)
2856 {
2857         /* Possible values taken from causes.h */
2858
2859         switch(cause) {
2860                 case 401:       /* Unauthorized */
2861                         return AST_CAUSE_CALL_REJECTED;
2862                 case 403:       /* Not found */
2863                         return AST_CAUSE_CALL_REJECTED;
2864                 case 404:       /* Not found */
2865                         return AST_CAUSE_UNALLOCATED;
2866                 case 405:       /* Method not allowed */
2867                         return AST_CAUSE_INTERWORKING;
2868                 case 407:       /* Proxy authentication required */
2869                         return AST_CAUSE_CALL_REJECTED;
2870                 case 408:       /* No reaction */
2871                         return AST_CAUSE_NO_USER_RESPONSE;
2872                 case 409:       /* Conflict */
2873                         return AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
2874                 case 410:       /* Gone */
2875                         return AST_CAUSE_UNALLOCATED;
2876                 case 411:       /* Length required */
2877                         return AST_CAUSE_INTERWORKING;
2878                 case 413:       /* Request entity too large */
2879                         return AST_CAUSE_INTERWORKING;
2880                 case 414:       /* Request URI too large */
2881                         return AST_CAUSE_INTERWORKING;
2882                 case 415:       /* Unsupported media type */
2883                         return AST_CAUSE_INTERWORKING;
2884                 case 420:       /* Bad extension */
2885                         return AST_CAUSE_NO_ROUTE_DESTINATION;
2886                 case 480:       /* No answer */
2887                         return AST_CAUSE_NO_ANSWER;
2888                 case 481:       /* No answer */
2889                         return AST_CAUSE_INTERWORKING;
2890                 case 482:       /* Loop detected */
2891                         return AST_CAUSE_INTERWORKING;
2892                 case 483:       /* Too many hops */
2893                         return AST_CAUSE_NO_ANSWER;
2894                 case 484:       /* Address incomplete */
2895                         return AST_CAUSE_INVALID_NUMBER_FORMAT;
2896                 case 485:       /* Ambigous */
2897                         return AST_CAUSE_UNALLOCATED;
2898                 case 486:       /* Busy everywhere */
2899                         return AST_CAUSE_BUSY;
2900                 case 487:       /* Request terminated */
2901                         return AST_CAUSE_INTERWORKING;
2902                 case 488:       /* No codecs approved */
2903                         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2904                 case 491:       /* Request pending */
2905                         return AST_CAUSE_INTERWORKING;
2906                 case 493:       /* Undecipherable */
2907                         return AST_CAUSE_INTERWORKING;
2908                 case 500:       /* Server internal failure */
2909                         return AST_CAUSE_FAILURE;
2910                 case 501:       /* Call rejected */
2911                         return AST_CAUSE_FACILITY_REJECTED;
2912                 case 502:       
2913                         return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2914                 case 503:       /* Service unavailable */
2915                         return AST_CAUSE_CONGESTION;
2916                 case 504:       /* Gateway timeout */
2917                         return AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE;
2918                 case 505:       /* SIP version not supported */
2919                         return AST_CAUSE_INTERWORKING;
2920                 case 600:       /* Busy everywhere */
2921                         return AST_CAUSE_USER_BUSY;
2922                 case 603:       /* Decline */
2923                         return AST_CAUSE_CALL_REJECTED;
2924                 case 604:       /* Does not exist anywhere */
2925                         return AST_CAUSE_UNALLOCATED;
2926                 case 606:       /* Not acceptable */
2927                         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2928                 default:
2929                         return AST_CAUSE_NORMAL;
2930         }
2931         /* Never reached */
2932         return 0;
2933 }
2934
2935 /*! \brief Convert Asterisk hangup causes to SIP codes 
2936 \verbatim
2937  Possible values from causes.h
2938         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
2939         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
2940
2941         In addition to these, a lot of PRI codes is defined in causes.h 
2942         ...should we take care of them too ?
2943         
2944         Quote RFC 3398
2945
2946    ISUP Cause value                        SIP response
2947    ----------------                        ------------
2948    1  unallocated number                   404 Not Found
2949    2  no route to network                  404 Not found
2950    3  no route to destination              404 Not found
2951    16 normal call clearing                 --- (*)
2952    17 user busy                            486 Busy here
2953    18 no user responding                   408 Request Timeout
2954    19 no answer from the user              480 Temporarily unavailable
2955    20 subscriber absent                    480 Temporarily unavailable
2956    21 call rejected                        403 Forbidden (+)
2957    22 number changed (w/o diagnostic)      410 Gone
2958    22 number changed (w/ diagnostic)       301 Moved Permanently
2959    23 redirection to new destination       410 Gone
2960    26 non-selected user clearing           404 Not Found (=)
2961    27 destination out of order             502 Bad Gateway
2962    28 address incomplete                   484 Address incomplete
2963    29 facility rejected                    501 Not implemented
2964    31 normal unspecified                   480 Temporarily unavailable
2965 \endverbatim
2966 */
2967 static const char *hangup_cause2sip(int cause)
2968 {
2969         switch (cause) {
2970                 case AST_CAUSE_UNALLOCATED:             /* 1 */
2971                 case AST_CAUSE_NO_ROUTE_DESTINATION:    /* 3 IAX2: Can't find extension in context */
2972                 case AST_CAUSE_NO_ROUTE_TRANSIT_NET:    /* 2 */
2973                         return "404 Not Found";
2974                 case AST_CAUSE_CONGESTION:              /* 34 */
2975                 case AST_CAUSE_SWITCH_CONGESTION:       /* 42 */
2976                         return "503 Service Unavailable";
2977                 case AST_CAUSE_NO_USER_RESPONSE:        /* 18 */
2978                         return "408 Request Timeout";
2979                 case AST_CAUSE_NO_ANSWER:               /* 19 */
2980                         return "480 Temporarily unavailable";
2981                 case AST_CAUSE_CALL_REJECTED:           /* 21 */
2982                         return "403 Forbidden";
2983                 case AST_CAUSE_NUMBER_CHANGED:          /* 22 */
2984                         return "410 Gone";
2985                 case AST_CAUSE_NORMAL_UNSPECIFIED:      /* 31 */
2986                         return "480 Temporarily unavailable";
2987                 case AST_CAUSE_INVALID_NUMBER_FORMAT:
2988                         return "484 Address incomplete";
2989                 case AST_CAUSE_USER_BUSY:
2990                         return "486 Busy here";
2991                 case AST_CAUSE_FAILURE:
2992                         return "500 Server internal failure";
2993                 case AST_CAUSE_FACILITY_REJECTED:       /* 29 */
2994                         return "501 Not Implemented";
2995                 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
2996                         return "503 Service Unavailable";
2997                 /* Used in chan_iax2 */
2998                 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
2999                         return "502 Bad Gateway";
3000                 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:       /* Can't find codec to connect to host */
3001                         return "488 Not Acceptable Here";
3002                         
3003                 case AST_CAUSE_NOTDEFINED:
3004                 default:
3005                         ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
3006                         return NULL;
3007         }
3008
3009         /* Never reached */
3010         return 0;
3011 }
3012
3013
3014 /*! \brief  sip_hangup: Hangup SIP call
3015  * Part of PBX interface, called from ast_hangup */
3016 static int sip_hangup(struct ast_channel *ast)
3017 {
3018         struct sip_pvt *p = ast->tech_pvt;
3019         int needcancel = FALSE;
3020         struct ast_flags locflags = {0};
3021
3022         if (!p) {
3023                 ast_log(LOG_DEBUG, "Asked to hangup channel that was not connected\n");
3024                 return 0;
3025         }
3026
3027         if (ast_test_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER)) {
3028                 if (option_debug >3)
3029                         ast_log(LOG_DEBUG, "SIP Transfer: Not hanging up right now... Rescheduling hangup for %s.\n", p->callid);
3030                 if (p->autokillid > -1)
3031                         sip_cancel_destroy(p);
3032                 sip_scheddestroy(p, 32000);
3033                 ast_clear_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER);        /* Really hang up next time */
3034                 ast_clear_flag(&p->flags[0], SIP_NEEDDESTROY);
3035                 p->owner->tech_pvt = NULL;
3036                 p->owner = NULL;  /*