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