e8236d27bfbec151ed74ca0d133099b9aff4209b
[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 static int handle_response_peerpoke(struct sip_pvt *p, int resp, struct sip_request *req);
1111
1112 /*----- RTP interface functions */
1113 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active);
1114 static struct ast_rtp *sip_get_rtp_peer(struct ast_channel *chan);
1115 static struct ast_rtp *sip_get_vrtp_peer(struct ast_channel *chan);
1116 static int sip_get_codec(struct ast_channel *chan);
1117
1118 /*! \brief Definition of this channel for PBX channel registration */
1119 static const struct ast_channel_tech sip_tech = {
1120         .type = "SIP",
1121         .description = "Session Initiation Protocol (SIP)",
1122         .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
1123         .properties = AST_CHAN_TP_WANTSJITTER,
1124         .requester = sip_request_call,
1125         .devicestate = sip_devicestate,
1126         .call = sip_call,
1127         .hangup = sip_hangup,
1128         .answer = sip_answer,
1129         .read = sip_read,
1130         .write = sip_write,
1131         .write_video = sip_write,
1132         .indicate = sip_indicate,
1133         .transfer = sip_transfer,
1134         .fixup = sip_fixup,
1135         .send_digit = sip_senddigit,
1136         .bridge = ast_rtp_bridge,
1137         .send_text = sip_sendtext,
1138 };
1139
1140 /*! \brief Interface structure with callbacks used to connect to RTP module */
1141 static struct ast_rtp_protocol sip_rtp = {
1142         type: "SIP",
1143         get_rtp_info: sip_get_rtp_peer,
1144         get_vrtp_info: sip_get_vrtp_peer,
1145         set_rtp_peer: sip_set_rtp_peer,
1146         get_codec: sip_get_codec,
1147 };
1148
1149 /*! \brief Convert transfer status to string */
1150 static char *referstatus2str(enum referstatus rstatus)
1151 {
1152         int i = (sizeof(referstatusstrings) / sizeof(referstatusstrings[0]));
1153         int x;
1154
1155         for (x = 0; x < i; x++) {
1156                 if (referstatusstrings[x].status ==  rstatus)
1157                         return (char *) referstatusstrings[x].text;
1158         }
1159         return "";
1160 }
1161
1162 /*! \brief Initialize the initital request packet in the pvt structure.
1163         This packet is used for creating replies and future requests in
1164         a dialog */
1165 void initialize_initreq(struct sip_pvt *p, struct sip_request *req)
1166 {
1167         if (p->initreq.headers) {
1168                 ast_log(LOG_WARNING, "Initializing already initialized SIP dialog??? %s\n", p->callid);
1169                 return;
1170         }
1171         /* Use this as the basis */
1172         copy_request(&p->initreq, req);
1173         parse_request(&p->initreq);
1174         if (ast_test_flag(req, SIP_PKT_DEBUG))
1175                 ast_verbose("%d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
1176 }
1177
1178
1179 /*! \brief returns true if 'name' (with optional trailing whitespace)
1180  * matches the sip method 'id'.
1181  * Strictly speaking, SIP methods are case SENSITIVE, but we do
1182  * a case-insensitive comparison to be more tolerant.
1183  * following Jon Postel's rule: Be gentle in what you accept, strict with what you send 
1184  */
1185 static int method_match(enum sipmethod id, const char *name)
1186 {
1187         int len = strlen(sip_methods[id].text);
1188         int l_name = name ? strlen(name) : 0;
1189         /* true if the string is long enough, and ends with whitespace, and matches */
1190         return (l_name >= len && name[len] < 33 &&
1191                 !strncasecmp(sip_methods[id].text, name, len));
1192 }
1193
1194 /*! \brief  find_sip_method: Find SIP method from header */
1195 static int find_sip_method(const char *msg)
1196 {
1197         int i, res = 0;
1198         
1199         if (ast_strlen_zero(msg))
1200                 return 0;
1201         for (i = 1; i < (sizeof(sip_methods) / sizeof(sip_methods[0])) && !res; i++) {
1202                 if (method_match(i, msg))
1203                         res = sip_methods[i].id;
1204         }
1205         return res;
1206 }
1207
1208 /*! \brief Parse supported header in incoming packet */
1209 static unsigned int parse_sip_options(struct sip_pvt *pvt, const char *supported)
1210 {
1211         char *next, *sep;
1212         char *temp = ast_strdupa(supported);
1213         unsigned int profile = 0;
1214         int i, found;
1215
1216         if (!pvt || ast_strlen_zero(supported) )
1217                 return 0;
1218
1219         if (option_debug > 2 && sipdebug)
1220                 ast_log(LOG_DEBUG, "Begin: parsing SIP \"Supported: %s\"\n", supported);
1221
1222         for (next = temp; next; next = sep) {
1223                 found = FALSE;
1224                 if ( (sep = strchr(next, ',')) != NULL)
1225                         *sep++ = '\0';
1226                 next = ast_skip_blanks(next);
1227                 if (option_debug > 2 && sipdebug)
1228                         ast_log(LOG_DEBUG, "Found SIP option: -%s-\n", next);
1229                 for (i=0; i < (sizeof(sip_options) / sizeof(sip_options[0])); i++) {
1230                         if (!strcasecmp(next, sip_options[i].text)) {
1231                                 profile |= sip_options[i].id;
1232                                 found = TRUE;
1233                                 if (option_debug > 2 && sipdebug)
1234                                         ast_log(LOG_DEBUG, "Matched SIP option: %s\n", next);
1235                                 break;
1236                         }
1237                 }
1238                 if (!found && option_debug > 2 && sipdebug)
1239                         ast_log(LOG_DEBUG, "Found no match for SIP option: %s (Please file bug report!)\n", next);
1240         }
1241
1242         pvt->sipoptions = profile;
1243         return profile;
1244 }
1245
1246 /*! \brief See if we pass debug IP filter */
1247 static inline int sip_debug_test_addr(const struct sockaddr_in *addr) 
1248 {
1249         if (!sipdebug)
1250                 return 0;
1251         if (debugaddr.sin_addr.s_addr) {
1252                 if (((ntohs(debugaddr.sin_port) != 0)
1253                         && (debugaddr.sin_port != addr->sin_port))
1254                         || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
1255                         return 0;
1256         }
1257         return 1;
1258 }
1259
1260 /* The real destination address for a write */
1261 static const struct sockaddr_in *sip_real_dst(const struct sip_pvt *p)
1262 {
1263         return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? &p->recv : &p->sa;
1264 }
1265
1266 static const char *sip_nat_mode(const struct sip_pvt *p)
1267 {
1268         return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? "NAT" : "no NAT";
1269 }
1270
1271 /*! \brief Test PVT for debugging output */
1272 static inline int sip_debug_test_pvt(struct sip_pvt *p) 
1273 {
1274         if (!sipdebug)
1275                 return 0;
1276         return sip_debug_test_addr(sip_real_dst(p));
1277 }
1278
1279 /*! \brief Transmit SIP message */
1280 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
1281 {
1282         int res;
1283         char iabuf[INET_ADDRSTRLEN];
1284         const struct sockaddr_in *dst = sip_real_dst(p);
1285         res=sendto(sipsock, data, len, 0, (const struct sockaddr *)dst, sizeof(struct sockaddr_in));
1286
1287         if (res != len)
1288                 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));
1289         return res;
1290 }
1291
1292
1293 /*! \brief Build a Via header for a request */
1294 static void build_via(struct sip_pvt *p)
1295 {
1296         char iabuf[INET_ADDRSTRLEN];
1297         /* Work around buggy UNIDEN UIP200 firmware */
1298         const char *rport = ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_RFC3581 ? ";rport" : "";
1299
1300         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
1301         ast_string_field_build(p, via, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x%s",
1302                          ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch, rport);
1303 }
1304
1305 /*! \brief NAT fix - decide which IP address to use for ASterisk server?
1306  * Only used for outbound registrations */
1307 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
1308 {
1309         /*
1310          * Using the localaddr structure built up with localnet statements
1311          * apply it to their address to see if we need to substitute our
1312          * externip or can get away with our internal bindaddr
1313          */
1314         struct sockaddr_in theirs;
1315         theirs.sin_addr = *them;
1316
1317         if (localaddr && externip.sin_addr.s_addr &&
1318            ast_apply_ha(localaddr, &theirs)) {
1319                 if (externexpire && time(NULL) >= externexpire) {
1320                         struct ast_hostent ahp;
1321                         struct hostent *hp;
1322
1323                         time(&externexpire);
1324                         externexpire += externrefresh;
1325                         if ((hp = ast_gethostbyname(externhost, &ahp))) {
1326                                 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
1327                         } else
1328                                 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
1329                 }
1330                 *us = externip.sin_addr;
1331                 if (option_debug) {
1332                         char iabuf[INET_ADDRSTRLEN];
1333                         ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
1334                 
1335                         ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
1336                 }
1337         } else if (bindaddr.sin_addr.s_addr)
1338                 *us = bindaddr.sin_addr;
1339         else
1340                 return ast_ouraddrfor(them, us);
1341         return 0;
1342 }
1343
1344 /*! \brief Append to SIP dialog history 
1345         \return Always returns 0 */
1346 #define append_history(p, event, fmt , args... )        append_history_full(p, "%-15s " fmt, event, ## args)
1347
1348 static int append_history_full(struct sip_pvt *p, const char *fmt, ...)
1349         __attribute__ ((format (printf, 2, 3)));
1350
1351 /*! \brief Append to SIP dialog history with arg list  */
1352 static void append_history_va(struct sip_pvt *p, const char *fmt, va_list ap)
1353 {
1354         char buf[80], *c = buf; /* max history length */
1355         struct sip_history *hist;
1356         int l;
1357
1358         vsnprintf(buf, sizeof(buf), fmt, ap);
1359         strsep(&c, "\r\n"); /* Trim up everything after \r or \n */
1360         l = strlen(buf) + 1;
1361         if (!(hist = ast_calloc(1, sizeof(*hist) + l)))
1362                 return;
1363         if (!p->history && !(p->history = ast_calloc(1, sizeof(*p->history)))) {
1364                 free(hist);
1365                 return;
1366         }
1367         memcpy(hist->event, buf, l);
1368         AST_LIST_INSERT_TAIL(p->history, hist, list);
1369 }
1370
1371 /*! \brief Append to SIP dialog history with arg list  */
1372 static int append_history_full(struct sip_pvt *p, const char *fmt, ...)
1373 {
1374         va_list ap;
1375
1376         if (!recordhistory || !p)
1377                 return 0;
1378         va_start(ap, fmt);
1379         append_history_va(p, fmt, ap);
1380         va_end(ap);
1381
1382         return 0;
1383 }
1384
1385 /*! \brief Retransmit SIP message if no answer */
1386 static int retrans_pkt(void *data)
1387 {
1388         struct sip_pkt *pkt = data, *prev, *cur = NULL;
1389         char iabuf[INET_ADDRSTRLEN];
1390         int reschedule = DEFAULT_RETRANS;
1391
1392         /* Lock channel PVT */
1393         ast_mutex_lock(&pkt->owner->lock);
1394
1395         if (pkt->retrans < MAX_RETRANS) {
1396                 pkt->retrans++;
1397                 if (!pkt->timer_t1) {   /* Re-schedule using timer_a and timer_t1 */
1398                         if (sipdebug && option_debug > 3)
1399                                 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);
1400                 } else {
1401                         int siptimer_a;
1402
1403                         if (sipdebug && option_debug > 3)
1404                                 ast_log(LOG_DEBUG, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n", pkt->retransid, pkt->retrans, sip_methods[pkt->method].text, pkt->method);
1405                         if (!pkt->timer_a)
1406                                 pkt->timer_a = 2 ;
1407                         else
1408                                 pkt->timer_a = 2 * pkt->timer_a;
1409  
1410                         /* For non-invites, a maximum of 4 secs */
1411                         siptimer_a = pkt->timer_t1 * pkt->timer_a;      /* Double each time */
1412                         if (pkt->method != SIP_INVITE && siptimer_a > 4000)
1413                                 siptimer_a = 4000;
1414                 
1415                         /* Reschedule re-transmit */
1416                         reschedule = siptimer_a;
1417                         if (option_debug > 3)
1418                                 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);
1419                 } 
1420
1421                 if (pkt->owner && sip_debug_test_pvt(pkt->owner)) {
1422                         if (ast_test_flag(&pkt->owner->flags[0], SIP_NAT_ROUTE))
1423                                 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);
1424                         else
1425                                 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);
1426                 }
1427
1428                 append_history(pkt->owner, "ReTx", "%d %s", reschedule, pkt->data);
1429                 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
1430                 ast_mutex_unlock(&pkt->owner->lock);
1431                 return  reschedule;
1432         } 
1433         /* Too many retries */
1434         if (pkt->owner && pkt->method != SIP_OPTIONS) {
1435                 if (ast_test_flag(pkt, FLAG_FATAL) || sipdebug) /* Tell us if it's critical or if we're debugging */
1436                         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");
1437         } else {
1438                 if ((pkt->method == SIP_OPTIONS) && sipdebug)
1439                         ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s) \n", pkt->owner->callid);
1440         }
1441         append_history(pkt->owner, "MaxRetries", "%s", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
1442                 
1443         pkt->retransid = -1;
1444
1445         if (ast_test_flag(pkt, FLAG_FATAL)) {
1446                 while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
1447                         ast_mutex_unlock(&pkt->owner->lock);
1448                         usleep(1);
1449                         ast_mutex_lock(&pkt->owner->lock);
1450                 }
1451                 if (pkt->owner->owner) {
1452                         ast_set_flag(&pkt->owner->flags[0], SIP_ALREADYGONE);
1453                         ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet.\n", pkt->owner->callid);
1454                         ast_queue_hangup(pkt->owner->owner);
1455                         ast_channel_unlock(pkt->owner->owner);
1456                 } else {
1457                         /* If no channel owner, destroy now */
1458                         ast_set_flag(&pkt->owner->flags[0], SIP_NEEDDESTROY);   
1459                 }
1460         }
1461         /* In any case, go ahead and remove the packet */
1462         for (prev = NULL, cur = pkt->owner->packets; cur; prev = cur, cur = cur->next) {
1463                 if (cur == pkt)
1464                         break;
1465         }
1466         if (cur) {
1467                 if (prev)
1468                         prev->next = cur->next;
1469                 else
1470                         pkt->owner->packets = cur->next;
1471                 ast_mutex_unlock(&pkt->owner->lock);
1472                 free(cur);
1473                 pkt = NULL;
1474         } else
1475                 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
1476         if (pkt)
1477                 ast_mutex_unlock(&pkt->owner->lock);
1478         return 0;
1479 }
1480
1481 /*! \brief Transmit packet with retransmits 
1482         \return 0 on success, -1 on failure to allocate packet 
1483 */
1484 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod)
1485 {
1486         struct sip_pkt *pkt;
1487         int siptimer_a = DEFAULT_RETRANS;
1488
1489         if (!(pkt = ast_calloc(1, sizeof(*pkt) + len + 1)))
1490                 return -1;
1491         memcpy(pkt->data, data, len);
1492         pkt->method = sipmethod;
1493         pkt->packetlen = len;
1494         pkt->next = p->packets;
1495         pkt->owner = p;
1496         pkt->seqno = seqno;
1497         pkt->flags = resp;
1498         pkt->data[len] = '\0';
1499         pkt->timer_t1 = p->timer_t1;    /* Set SIP timer T1 */
1500         if (fatal)
1501                 ast_set_flag(pkt, FLAG_FATAL);
1502         if (pkt->timer_t1)
1503                 siptimer_a = pkt->timer_t1 * 2;
1504
1505         /* Schedule retransmission */
1506         pkt->retransid = ast_sched_add_variable(sched, siptimer_a, retrans_pkt, pkt, 1);
1507         if (option_debug > 3 && sipdebug)
1508                 ast_log(LOG_DEBUG, "*** SIP TIMER: Initalizing retransmit timer on packet: Id  #%d\n", pkt->retransid);
1509         pkt->next = p->packets;
1510         p->packets = pkt;
1511
1512         __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);      /* Send packet */
1513         if (sipmethod == SIP_INVITE) {
1514                 /* Note this is a pending invite */
1515                 p->pendinginvite = seqno;
1516         }
1517         return 0;
1518 }
1519
1520 /*! \brief Kill a SIP dialog (called by scheduler) */
1521 static int __sip_autodestruct(void *data)
1522 {
1523         struct sip_pvt *p = data;
1524
1525         /* If this is a subscription, tell the phone that we got a timeout */
1526         if (p->subscribed) {
1527                 p->subscribed = TIMEOUT;
1528                 transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1); /* Send last notification */
1529                 p->subscribed = NONE;
1530                 append_history(p, "Subscribestatus", "timeout");
1531                 if (option_debug > 2)
1532                         ast_log(LOG_DEBUG, "Re-scheduled destruction of SIP subsription %s\n", p->callid ? p->callid : "<unknown>");
1533                 return 10000;   /* Reschedule this destruction so that we know that it's gone */
1534         }
1535
1536         /* Reset schedule ID */
1537         p->autokillid = -1;
1538
1539         if (option_debug)
1540                 ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
1541         append_history(p, "AutoDestroy", "");
1542         if (p->owner) {
1543                 ast_log(LOG_WARNING, "Autodestruct on dialog '%s' with owner in place (Method: %s)\n", p->callid, sip_methods[p->method].text);
1544                 ast_queue_hangup(p->owner);
1545         } else {
1546                 sip_destroy(p);
1547         }
1548         return 0;
1549 }
1550
1551 /*! \brief Schedule destruction of SIP call */
1552 static int sip_scheddestroy(struct sip_pvt *p, int ms)
1553 {
1554         if (sip_debug_test_pvt(p))
1555                 ast_verbose("Scheduling destruction of SIP dialog '%s' in %d ms (Method: %s)\n", p->callid, ms, sip_methods[p->method].text);
1556         if (recordhistory)
1557                 append_history(p, "SchedDestroy", "%d ms", ms);
1558
1559         if (p->autokillid > -1)
1560                 ast_sched_del(sched, p->autokillid);
1561         p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
1562         return 0;
1563 }
1564
1565 /*! \brief Cancel destruction of SIP dialog */
1566 static int sip_cancel_destroy(struct sip_pvt *p)
1567 {
1568         if (p->autokillid > -1) {
1569                 ast_sched_del(sched, p->autokillid);
1570                 append_history(p, "CancelDestroy", "");
1571                 p->autokillid = -1;
1572         }
1573         return 0;
1574 }
1575
1576 /*! \brief Acknowledges receipt of a packet and stops retransmission */
1577 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod, int reset)
1578 {
1579         struct sip_pkt *cur, *prev = NULL;
1580         int res = -1;
1581
1582         /* Just in case... */
1583         char *msg;
1584
1585         msg = sip_methods[sipmethod].text;
1586
1587         ast_mutex_lock(&p->lock);
1588         for (cur = p->packets; cur; prev = cur, cur = cur->next) {
1589                 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
1590                         ((ast_test_flag(cur, FLAG_RESPONSE)) || 
1591                          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
1592                         if (!resp && (seqno == p->pendinginvite)) {
1593                                 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
1594                                 p->pendinginvite = 0;
1595                         }
1596                         /* this is our baby */
1597                         if (prev)
1598                                 prev->next = cur->next;
1599                         else
1600                                 p->packets = cur->next;
1601                         if (cur->retransid > -1) {
1602                                 if (sipdebug && option_debug > 3)
1603                                         ast_log(LOG_DEBUG, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
1604                                 ast_sched_del(sched, cur->retransid);
1605                         }
1606                         if (!reset)
1607                                 free(cur);
1608                         res = 0;
1609                         break;
1610                 }
1611         }
1612         ast_mutex_unlock(&p->lock);
1613         if (option_debug)
1614                 ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: Match %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
1615         return res;
1616 }
1617
1618 /*! \brief Pretend to ack all packets */
1619 static int __sip_pretend_ack(struct sip_pvt *p)
1620 {
1621         struct sip_pkt *cur = NULL;
1622
1623         while (p->packets) {
1624                 if (cur == p->packets) {
1625                         ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
1626                         return -1;
1627                 }
1628                 cur = p->packets;
1629                 if (cur->method)
1630                         __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), cur->method, FALSE);
1631                 else {  /* Unknown packet type */
1632                         char *c;
1633                         char method[128];
1634
1635                         ast_copy_string(method, p->packets->data, sizeof(method));
1636                         c = ast_skip_blanks(method); /* XXX what ? */
1637                         *c = '\0';
1638                         __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), find_sip_method(method), FALSE);
1639                 }
1640         }
1641         return 0;
1642 }
1643
1644 /*! \brief Acks receipt of packet, keep it around (used for provisional responses) */
1645 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
1646 {
1647         struct sip_pkt *cur;
1648         int res = -1;
1649
1650         for (cur = p->packets; cur; cur = cur->next) {
1651                 if (cur->seqno == seqno && ast_test_flag(cur, FLAG_RESPONSE) == resp &&
1652                         (ast_test_flag(cur, FLAG_RESPONSE) || method_match(sipmethod, cur->data))) {
1653                         /* this is our baby */
1654                         if (cur->retransid > -1) {
1655                                 if (option_debug > 3 && sipdebug)
1656                                         ast_log(LOG_DEBUG, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, sip_methods[sipmethod].text);
1657                                 ast_sched_del(sched, cur->retransid);
1658                         }
1659                         cur->retransid = -1;
1660                         res = 0;
1661                         break;
1662                 }
1663         }
1664         if (option_debug)
1665                 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");
1666         return res;
1667 }
1668
1669
1670 /*! \brief Copy SIP request, parse it */
1671 static void parse_copy(struct sip_request *dst, struct sip_request *src)
1672 {
1673         memset(dst, 0, sizeof(*dst));
1674         memcpy(dst->data, src->data, sizeof(dst->data));
1675         dst->len = src->len;
1676         parse_request(dst);
1677 }
1678
1679 /*! \brief Transmit response on SIP request*/
1680 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
1681 {
1682         int res;
1683
1684         if (sip_debug_test_pvt(p)) {
1685                 char iabuf[INET_ADDRSTRLEN];
1686                 if (ast_test_flag(&p->flags[0], SIP_NAT_ROUTE))
1687                         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);
1688                 else
1689                         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);
1690         }
1691         if (recordhistory) {
1692                 struct sip_request tmp;
1693                 parse_copy(&tmp, req);
1694                 append_history(p, reliable ? "TxRespRel" : "TxResp", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"), 
1695                         tmp.method == SIP_RESPONSE ? tmp.rlPart2 : sip_methods[tmp.method].text);
1696         }
1697         res = (reliable) ?
1698                 __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable == XMIT_CRITICAL), req->method) :
1699                 __sip_xmit(p, req->data, req->len);
1700         if (res > 0)
1701                 return 0;
1702         return res;
1703 }
1704
1705 /*! \brief Send SIP Request to the other part of the dialogue */
1706 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
1707 {
1708         int res;
1709
1710         if (sip_debug_test_pvt(p)) {
1711                 char iabuf[INET_ADDRSTRLEN];
1712                 if (ast_test_flag(&p->flags[0], SIP_NAT_ROUTE))
1713                         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);
1714                 else
1715                         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);
1716         }
1717         if (recordhistory) {
1718                 struct sip_request tmp;
1719                 parse_copy(&tmp, req);
1720                 append_history(p, reliable ? "TxReqRel" : "TxReq", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"), sip_methods[tmp.method].text);
1721         }
1722         res = (reliable) ?
1723                 __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1), req->method) :
1724                 __sip_xmit(p, req->data, req->len);
1725         return res;
1726 }
1727
1728 /*! \brief Pick out text in brackets from character string
1729         \return pointer to terminated stripped string
1730         \param tmp input string that will be modified */
1731 static char *get_in_brackets(char *tmp)
1732 {
1733         char *parse;
1734         char *first_quote;
1735         char *first_bracket;
1736         char *second_bracket;
1737         char last_char;
1738
1739         parse = tmp;
1740         for (;;) {
1741                 first_quote = strchr(parse, '"');
1742                 first_bracket = strchr(parse, '<');
1743                 if (first_quote && first_bracket && (first_quote < first_bracket)) {
1744                         last_char = '\0';
1745                         for (parse = first_quote + 1; *parse; parse++) {
1746                                 if ((*parse == '"') && (last_char != '\\'))
1747                                         break;
1748                                 last_char = *parse;
1749                         }
1750                         if (!*parse) {
1751                                 ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
1752                                 return tmp;
1753                         }
1754                         parse++;
1755                         continue;
1756                 }
1757                 if (first_bracket) {
1758                         second_bracket = strchr(first_bracket + 1, '>');
1759                         if (second_bracket) {
1760                                 *second_bracket = '\0';
1761                                 return first_bracket + 1;
1762                         } else {
1763                                 ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
1764                                 return tmp;
1765                         }
1766                 }
1767                 return tmp;
1768         }
1769 }
1770
1771 /*! \brief Send SIP MESSAGE text within a call
1772         Called from PBX core sendtext() application */
1773 static int sip_sendtext(struct ast_channel *ast, const char *text)
1774 {
1775         struct sip_pvt *p = ast->tech_pvt;
1776         int debug = sip_debug_test_pvt(p);
1777
1778         if (debug)
1779                 ast_verbose("Sending text %s on %s\n", text, ast->name);
1780         if (!p)
1781                 return -1;
1782         if (ast_strlen_zero(text))
1783                 return 0;
1784         if (debug)
1785                 ast_verbose("Really sending text %s on %s\n", text, ast->name);
1786         transmit_message_with_text(p, text);
1787         return 0;       
1788 }
1789
1790 /*! \brief Update peer object in realtime storage */
1791 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expirey)
1792 {
1793         char port[10];
1794         char ipaddr[20];
1795         char regseconds[20];
1796         time_t nowtime;
1797         const char *fc = fullcontact ? "fullcontact" : NULL;
1798         
1799         time(&nowtime);
1800         nowtime += expirey;
1801         snprintf(regseconds, sizeof(regseconds), "%d", (int)nowtime);   /* Expiration time */
1802         ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
1803         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
1804         
1805         ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr,
1806                 "port", port, "regseconds", regseconds,
1807                 "username", username, fc, fullcontact, NULL); /* note fc _can_ be NULL */
1808 }
1809
1810 /*! \brief Automatically add peer extension to dial plan */
1811 static void register_peer_exten(struct sip_peer *peer, int onoff)
1812 {
1813         char multi[256];
1814         char *stringp, *ext;
1815         if (!ast_strlen_zero(global_regcontext)) {
1816
1817                 ast_copy_string(multi, S_OR(peer->regexten, peer->name), sizeof(multi));
1818                 stringp = multi;
1819                 while((ext = strsep(&stringp, "&"))) {
1820                         if (onoff)
1821                                 ast_add_extension(global_regcontext, 1, ext, 1, NULL, NULL, "Noop",
1822                                                   ast_strdup(peer->name), free, "SIP");
1823                         else
1824                                 ast_context_remove_extension(global_regcontext, ext, 1, NULL);
1825                 }
1826         }
1827 }
1828
1829 /*! \brief Destroy peer object from memory */
1830 static void sip_destroy_peer(struct sip_peer *peer)
1831 {
1832         if (option_debug > 2)
1833                 ast_log(LOG_DEBUG, "Destroying SIP peer %s\n", peer->name);
1834
1835         /* Delete it, it needs to disappear */
1836         if (peer->call)
1837                 sip_destroy(peer->call);
1838
1839         if (peer->mwipvt) {     /* We have an active subscription, delete it */
1840                 sip_destroy(peer->mwipvt);
1841         }
1842
1843         if (peer->chanvars) {
1844                 ast_variables_destroy(peer->chanvars);
1845                 peer->chanvars = NULL;
1846         }
1847         if (peer->expire > -1)
1848                 ast_sched_del(sched, peer->expire);
1849         if (peer->pokeexpire > -1)
1850                 ast_sched_del(sched, peer->pokeexpire);
1851         register_peer_exten(peer, FALSE);
1852         ast_free_ha(peer->ha);
1853         if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT))
1854                 apeerobjs--;
1855         else if (ast_test_flag(&peer->flags[0], SIP_REALTIME))
1856                 rpeerobjs--;
1857         else
1858                 speerobjs--;
1859         clear_realm_authentication(peer->auth);
1860         peer->auth = NULL;
1861         if (peer->dnsmgr)
1862                 ast_dnsmgr_release(peer->dnsmgr);
1863         free(peer);
1864 }
1865
1866 /*! \brief Update peer data in database (if used) */
1867 static void update_peer(struct sip_peer *p, int expiry)
1868 {
1869         int rtcachefriends = ast_test_flag(&p->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
1870         if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTUPDATE) &&
1871             (ast_test_flag(&p->flags[0], SIP_REALTIME) || rtcachefriends)) {
1872                 realtime_update_peer(p->name, &p->addr, p->username, rtcachefriends ? p->fullcontact : NULL, expiry);
1873         }
1874 }
1875
1876
1877 /*! \brief  realtime_peer: Get peer from realtime storage
1878  * Checks the "sippeers" realtime family from extconfig.conf 
1879  * \todo Consider adding check of port address when matching here to follow the same
1880  *      algorithm as for static peers. Will we break anything by adding that?
1881 */
1882 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1883 {
1884         struct sip_peer *peer = NULL;
1885         struct ast_variable *var;
1886         struct ast_variable *tmp;
1887         char *newpeername = (char *) peername;
1888         char iabuf[80];
1889
1890         /* First check on peer name */
1891         if (newpeername) 
1892                 var = ast_load_realtime("sippeers", "name", peername, NULL);
1893         else if (sin) { /* Then check on IP address for dynamic peers */
1894                 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
1895                 var = ast_load_realtime("sippeers", "host", iabuf, NULL);       /* First check for fixed IP hosts */
1896                 if (!var)
1897                         var = ast_load_realtime("sippeers", "ipaddr", iabuf, NULL);     /* Then check for registred hosts */
1898         
1899         } else
1900                 return NULL;
1901
1902         if (!var)
1903                 return NULL;
1904
1905         for (tmp = var; tmp; tmp = tmp->next) {
1906                 /* If this is type=user, then skip this object. */
1907                 if (!strcasecmp(tmp->name, "type") &&
1908                     !strcasecmp(tmp->value, "user")) {
1909                         ast_variables_destroy(var);
1910                         return NULL;
1911                 } else if (!newpeername && !strcasecmp(tmp->name, "name")) {
1912                         newpeername = tmp->value;
1913                 }
1914         }
1915         
1916         if (!newpeername) {     /* Did not find peer in realtime */
1917                 ast_log(LOG_WARNING, "Cannot Determine peer name ip=%s\n", iabuf);
1918                 ast_variables_destroy(var);
1919                 return NULL;
1920         }
1921
1922         /* Peer found in realtime, now build it in memory */
1923         peer = build_peer(newpeername, var, !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS));
1924         if (!peer) {
1925                 ast_variables_destroy(var);
1926                 return NULL;
1927         }
1928
1929         if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
1930                 /* Cache peer */
1931                 ast_copy_flags(&peer->flags[1],&global_flags[1], SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
1932                 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTAUTOCLEAR)) {
1933                         if (peer->expire > -1) {
1934                                 ast_sched_del(sched, peer->expire);
1935                         }
1936                         peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, (void *)peer);
1937                 }
1938                 ASTOBJ_CONTAINER_LINK(&peerl,peer);
1939         } else {
1940                 ast_set_flag(&peer->flags[0], SIP_REALTIME);
1941         }
1942         ast_variables_destroy(var);
1943
1944         return peer;
1945 }
1946
1947 /*! \brief Support routine for find_peer */
1948 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
1949 {
1950         /* We know name is the first field, so we can cast */
1951         struct sip_peer *p = (struct sip_peer *) name;
1952         return  !(!inaddrcmp(&p->addr, sin) || 
1953                                         (ast_test_flag(&p->flags[0], SIP_INSECURE_PORT) &&
1954                                         (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
1955 }
1956
1957 /*! \brief Locate peer by name or ip address 
1958  *      This is used on incoming SIP message to find matching peer on ip
1959         or outgoing message to find matching peer on name */
1960 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
1961 {
1962         struct sip_peer *p = NULL;
1963
1964         if (peer)
1965                 p = ASTOBJ_CONTAINER_FIND(&peerl, peer);
1966         else
1967                 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl, sin, name, sip_addr_hashfunc, 1, sip_addrcmp);
1968
1969         if (!p && realtime) {
1970                 p = realtime_peer(peer, sin);
1971         }
1972         return p;
1973 }
1974
1975 /*! \brief Remove user object from in-memory storage */
1976 static void sip_destroy_user(struct sip_user *user)
1977 {
1978         if (option_debug > 2)
1979                 ast_log(LOG_DEBUG, "Destroying user object from memory: %s\n", user->name);
1980         ast_free_ha(user->ha);
1981         if (user->chanvars) {
1982                 ast_variables_destroy(user->chanvars);
1983                 user->chanvars = NULL;
1984         }
1985         if (ast_test_flag(&user->flags[0], SIP_REALTIME))
1986                 ruserobjs--;
1987         else
1988                 suserobjs--;
1989         free(user);
1990 }
1991
1992 /*! \brief Load user from realtime storage
1993  * Loads user from "sipusers" category in realtime (extconfig.conf)
1994  * Users are matched on From: user name (the domain in skipped) */
1995 static struct sip_user *realtime_user(const char *username)
1996 {
1997         struct ast_variable *var;
1998         struct ast_variable *tmp;
1999         struct sip_user *user = NULL;
2000
2001         var = ast_load_realtime("sipusers", "name", username, NULL);
2002
2003         if (!var)
2004                 return NULL;
2005
2006         for (tmp = var; tmp; tmp = tmp->next) {
2007                 if (!strcasecmp(tmp->name, "type") &&
2008                         !strcasecmp(tmp->value, "peer")) {
2009                         ast_variables_destroy(var);
2010                         return NULL;
2011                 }
2012         }
2013
2014         user = build_user(username, var, !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS));
2015         
2016         if (!user) {    /* No user found */
2017                 ast_variables_destroy(var);
2018                 return NULL;
2019         }
2020
2021         if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
2022                 ast_set_flag(&user->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
2023                 suserobjs++;
2024                 ASTOBJ_CONTAINER_LINK(&userl,user);
2025         } else {
2026                 /* Move counter from s to r... */
2027                 suserobjs--;
2028                 ruserobjs++;
2029                 ast_set_flag(&user->flags[0], SIP_REALTIME);
2030         }
2031         ast_variables_destroy(var);
2032         return user;
2033 }
2034
2035 /*! \brief Locate user by name 
2036  * Locates user by name (From: sip uri user name part) first
2037  * from in-memory list (static configuration) then from 
2038  * realtime storage (defined in extconfig.conf) */
2039 static struct sip_user *find_user(const char *name, int realtime)
2040 {
2041         struct sip_user *u = ASTOBJ_CONTAINER_FIND(&userl, name);
2042         if (!u && realtime)
2043                 u = realtime_user(name);
2044         return u;
2045 }
2046
2047 /*! \brief Create address structure from peer reference */
2048 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer)
2049 {
2050         int natflags;
2051
2052         if ((peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr) &&
2053             (!peer->maxms || ((peer->lastms >= 0)  && (peer->lastms <= peer->maxms)))) {
2054                 r->sa = (peer->addr.sin_addr.s_addr) ? peer->addr : peer->defaddr;
2055                 r->recv = r->sa;
2056         } else {
2057                 return -1;
2058         }
2059
2060         ast_copy_flags(&r->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
2061         ast_copy_flags(&r->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
2062         r->capability = peer->capability;
2063         if (!ast_test_flag(&r->flags[1], SIP_PAGE2_VIDEOSUPPORT) && r->vrtp) {
2064                 ast_rtp_destroy(r->vrtp);
2065                 r->vrtp = NULL;
2066         }
2067         r->prefs = peer->prefs;
2068         natflags = ast_test_flag(&r->flags[0], SIP_NAT) & SIP_NAT_ROUTE;
2069         if (r->rtp) {
2070                 if (option_debug)
2071                         ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", natflags);
2072                 ast_rtp_setnat(r->rtp, natflags);
2073         }
2074         if (r->vrtp) {
2075                 if (option_debug)
2076                         ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", natflags);
2077                 ast_rtp_setnat(r->vrtp, natflags);
2078         }
2079         ast_string_field_set(r, peername, peer->username);
2080         ast_string_field_set(r, authname, peer->username);
2081         ast_string_field_set(r, username, peer->username);
2082         ast_string_field_set(r, peersecret, peer->secret);
2083         ast_string_field_set(r, peermd5secret, peer->md5secret);
2084         ast_string_field_set(r, tohost, peer->tohost);
2085         ast_string_field_set(r, fullcontact, peer->fullcontact);
2086         if (!r->initreq.headers && !ast_strlen_zero(peer->fromdomain)) {
2087                 char *tmpcall;
2088                 char *c;
2089                 tmpcall = ast_strdupa(r->callid);
2090                 if (tmpcall) {
2091                         c = strchr(tmpcall, '@');
2092                         if (c) {
2093                                 *c = '\0';
2094                                 ast_string_field_build(r, callid, "%s@%s", tmpcall, peer->fromdomain);
2095                         }
2096                 }
2097         }
2098         if (ast_strlen_zero(r->tohost)) {
2099                 char iabuf[INET_ADDRSTRLEN];
2100
2101                 ast_inet_ntoa(iabuf, sizeof(iabuf),  r->sa.sin_addr);
2102                 ast_string_field_set(r, tohost, iabuf);
2103         }
2104         if (!ast_strlen_zero(peer->fromdomain))
2105                 ast_string_field_set(r, fromdomain, peer->fromdomain);
2106         if (!ast_strlen_zero(peer->fromuser))
2107                 ast_string_field_set(r, fromuser, peer->fromuser);
2108         r->maxtime = peer->maxms;
2109         r->callgroup = peer->callgroup;
2110         r->pickupgroup = peer->pickupgroup;
2111         r->allowtransfer = peer->allowtransfer;
2112         /* Set timer T1 to RTT for this peer (if known by qualify=) */
2113         /* Minimum is settable or default to 100 ms */
2114         if (peer->maxms && peer->lastms)
2115                 r->timer_t1 = peer->lastms < global_t1min ? global_t1min : peer->lastms;
2116         if ((ast_test_flag(&r->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
2117             (ast_test_flag(&r->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
2118                 r->noncodeccapability |= AST_RTP_DTMF;
2119         else
2120                 r->noncodeccapability &= ~AST_RTP_DTMF;
2121         ast_string_field_set(r, context, peer->context);
2122         r->rtptimeout = peer->rtptimeout;
2123         r->rtpholdtimeout = peer->rtpholdtimeout;
2124         r->rtpkeepalive = peer->rtpkeepalive;
2125         if (peer->call_limit)
2126                 ast_set_flag(&r->flags[0], SIP_CALL_LIMIT);
2127         r->maxcallbitrate = peer->maxcallbitrate;
2128         
2129         return 0;
2130 }
2131
2132 /*! \brief create address structure from peer name
2133  *      Or, if peer not found, find it in the global DNS 
2134  *      returns TRUE (-1) on failure, FALSE on success */
2135 static int create_addr(struct sip_pvt *dialog, const char *opeer)
2136 {
2137         struct hostent *hp;
2138         struct ast_hostent ahp;
2139         struct sip_peer *p;
2140         int found=0;
2141         char *port;
2142         int portno;
2143         char host[MAXHOSTNAMELEN], *hostn;
2144         char peer[256];
2145
2146         ast_copy_string(peer, opeer, sizeof(peer));
2147         port = strchr(peer, ':');
2148         if (port)
2149                 *port++ = '\0';
2150         dialog->sa.sin_family = AF_INET;
2151         dialog->timer_t1 = 500; /* Default SIP retransmission timer T1 (RFC 3261) */
2152         p = find_peer(peer, NULL, 1);
2153
2154         if (p) {
2155                 found++;
2156                 if (create_addr_from_peer(dialog, p))
2157                         ASTOBJ_UNREF(p, sip_destroy_peer);
2158         }
2159         if (!p) {
2160                 if (found)
2161                         return -1;
2162
2163                 hostn = peer;
2164                 portno = port ? atoi(port) : DEFAULT_SIP_PORT;
2165                 if (srvlookup) {
2166                         char service[MAXHOSTNAMELEN];
2167                         int tportno;
2168                         int ret;
2169                         snprintf(service, sizeof(service), "_sip._udp.%s", peer);
2170                         ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
2171                         if (ret > 0) {
2172                                 hostn = host;
2173                                 portno = tportno;
2174                         }
2175                 }
2176                 hp = ast_gethostbyname(hostn, &ahp);
2177                 if (hp) {
2178                         ast_string_field_set(dialog, tohost, peer);
2179                         memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr));
2180                         dialog->sa.sin_port = htons(portno);
2181                         dialog->recv = dialog->sa;
2182                         return 0;
2183                 } else {
2184                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
2185                         return -1;
2186                 }
2187         } else {
2188                 ASTOBJ_UNREF(p, sip_destroy_peer);
2189                 return 0;
2190         }
2191 }
2192
2193 /*! \brief Scheduled congestion on a call */
2194 static int auto_congest(void *nothing)
2195 {
2196         struct sip_pvt *p = nothing;
2197
2198         ast_mutex_lock(&p->lock);
2199         p->initid = -1;
2200         if (p->owner) {
2201                 /* XXX fails on possible deadlock */
2202                 if (!ast_channel_trylock(p->owner)) {
2203                         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
2204                         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
2205                         ast_channel_unlock(p->owner);
2206                 }
2207         }
2208         ast_mutex_unlock(&p->lock);
2209         return 0;
2210 }
2211
2212
2213 /*! \brief Initiate SIP call from PBX 
2214  *      used from the dial() application      */
2215 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
2216 {
2217         int res;
2218         struct sip_pvt *p;
2219         struct varshead *headp;
2220         struct ast_var_t *current;
2221         const char *referer = NULL;   /* SIP refererer */       
2222
2223         p = ast->tech_pvt;
2224         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
2225                 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
2226                 return -1;
2227         }
2228
2229         /* Check whether there is vxml_url, distinctive ring variables */
2230         headp=&ast->varshead;
2231         AST_LIST_TRAVERSE(headp,current,entries) {
2232                 /* Check whether there is a VXML_URL variable */
2233                 if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
2234                         p->options->vxml_url = ast_var_value(current);
2235                 } else if (!p->options->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
2236                         p->options->uri_options = ast_var_value(current);
2237                 } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
2238                         /* Check whether there is a ALERT_INFO variable */
2239                         p->options->distinctive_ring = ast_var_value(current);
2240                 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
2241                         /* Check whether there is a variable with a name starting with SIPADDHEADER */
2242                         p->options->addsipheaders = 1;
2243                 } else if (!strcasecmp(ast_var_name(current),"SIPTRANSFER")) {
2244                         /* This is a transfered call */
2245                         p->options->transfer = 1;
2246                 } else if (!strcasecmp(ast_var_name(current),"SIPTRANSFER_REFERER")) {
2247                         /* This is the referer */
2248                         referer = ast_var_value(current);
2249                 } else if (!strcasecmp(ast_var_name(current),"SIPTRANSFER_REPLACES")) {
2250                         /* We're replacing a call. */
2251                         p->options->replaces = ast_var_value(current);
2252                 }
2253         }
2254         
2255         res = 0;
2256         ast_set_flag(&p->flags[0], SIP_OUTGOING);
2257
2258         if (p->options->transfer) {
2259                 char buf[BUFSIZ/2];
2260
2261                 if (referer) {
2262                         if (sipdebug && option_debug > 2)
2263                                 ast_log(LOG_DEBUG, "Call for %s transfered by %s\n", p->username, referer);
2264                         snprintf(buf, sizeof(buf)-1, "-> %s (via %s)", p->cid_name, referer);
2265                 } else {
2266                         snprintf(buf, sizeof(buf)-1, "-> %s", p->cid_name);
2267                 }
2268                 ast_string_field_set(p, cid_name, buf);
2269         } 
2270         if (option_debug)
2271                 ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
2272
2273         res = update_call_counter(p, INC_CALL_LIMIT);
2274         if ( res != -1 ) {
2275                 p->callingpres = ast->cid.cid_pres;
2276                 p->jointcapability = p->capability;
2277                 transmit_invite(p, SIP_INVITE, 1, 2);
2278                 if (p->maxtime) {
2279                         /* Initialize auto-congest time */
2280                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
2281                 } else {
2282                         p->initid = ast_sched_add(sched, SIP_TRANS_TIMEOUT, auto_congest, p);
2283                 }
2284         }
2285         return res;
2286 }
2287
2288 /*! \brief Destroy registry object
2289         Objects created with the register= statement in static configuration */
2290 static void sip_registry_destroy(struct sip_registry *reg)
2291 {
2292         /* Really delete */
2293         if (option_debug > 2)
2294                 ast_log(LOG_DEBUG, "Destroying registry entry for %s@%s\n", reg->username, reg->hostname);
2295
2296         if (reg->call) {
2297                 /* Clear registry before destroying to ensure
2298                    we don't get reentered trying to grab the registry lock */
2299                 reg->call->registry = NULL;
2300                 if (option_debug > 2)
2301                         ast_log(LOG_DEBUG, "Destroying active SIP dialog for registry %s@%s\n", reg->username, reg->hostname);
2302                 sip_destroy(reg->call);
2303         }
2304         if (reg->expire > -1)
2305                 ast_sched_del(sched, reg->expire);
2306         if (reg->timeout > -1)
2307                 ast_sched_del(sched, reg->timeout);
2308         ast_string_field_free_all(reg);
2309         regobjs--;
2310         free(reg);
2311         
2312 }
2313
2314 /*! \brief Execute destrucion of SIP dialog structure, release memory */
2315 static void __sip_destroy(struct sip_pvt *p, int lockowner)
2316 {
2317         struct sip_pvt *cur, *prev = NULL;
2318         struct sip_pkt *cp;
2319
2320         if (sip_debug_test_pvt(p) || option_debug > 2)
2321                 ast_verbose("Really destroying SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);
2322
2323         /* Remove link from peer to subscription of MWI */
2324         if (p->relatedpeer && p->relatedpeer->mwipvt)
2325                 p->relatedpeer->mwipvt = NULL;
2326
2327         if (dumphistory)
2328                 sip_dump_history(p);
2329
2330         if (p->options)
2331                 free(p->options);
2332
2333         if (p->stateid > -1)
2334                 ast_extension_state_del(p->stateid, NULL);
2335         if (p->initid > -1)
2336                 ast_sched_del(sched, p->initid);
2337         if (p->autokillid > -1)
2338                 ast_sched_del(sched, p->autokillid);
2339
2340         if (p->rtp)
2341                 ast_rtp_destroy(p->rtp);
2342         if (p->vrtp)
2343                 ast_rtp_destroy(p->vrtp);
2344         if (p->refer)
2345                 free(p->refer);
2346         if (p->route) {
2347                 free_old_route(p->route);
2348                 p->route = NULL;
2349         }
2350         if (p->registry) {
2351                 if (p->registry->call == p)
2352                         p->registry->call = NULL;
2353                 ASTOBJ_UNREF(p->registry, sip_registry_destroy);
2354         }
2355
2356         /* Unlink us from the owner if we have one */
2357         if (p->owner) {
2358                 if (lockowner)
2359                         ast_channel_lock(p->owner);
2360                 if (option_debug)
2361                         ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
2362                 p->owner->tech_pvt = NULL;
2363                 if (lockowner)
2364                         ast_channel_unlock(p->owner);
2365         }
2366         /* Clear history */
2367         if (p->history) {
2368                 struct sip_history *hist;
2369                 while( (hist = AST_LIST_REMOVE_HEAD(p->history, list)) )
2370                         free(hist);
2371                 free(p->history);
2372                 p->history = NULL;
2373         }
2374
2375         for (prev = NULL, cur = iflist; cur; prev = cur, cur = cur->next) {
2376                 if (cur == p) {
2377                         if (prev)
2378                                 prev->next = cur->next;
2379                         else
2380                                 iflist = cur->next;
2381                         break;
2382                 }
2383         }
2384         if (!cur) {
2385                 ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
2386                 return;
2387         } 
2388         if (p->initid > -1)
2389                 ast_sched_del(sched, p->initid);
2390
2391         /* remove all current packets in this dialog */
2392         while((cp = p->packets)) {
2393                 p->packets = p->packets->next;
2394                 if (cp->retransid > -1)
2395                         ast_sched_del(sched, cp->retransid);
2396                 free(cp);
2397         }
2398         if (p->chanvars) {
2399                 ast_variables_destroy(p->chanvars);
2400                 p->chanvars = NULL;
2401         }
2402         ast_mutex_destroy(&p->lock);
2403
2404         ast_string_field_free_all(p);
2405
2406         free(p);
2407 }
2408
2409 /*! \brief  update_call_counter: Handle call_limit for SIP users 
2410  * Setting a call-limit will cause calls above the limit not to be accepted.
2411  *
2412  * Remember that for a type=friend, there's one limit for the user and
2413  * another for the peer, not a combined call limit.
2414  * This will cause unexpected behaviour in subscriptions, since a "friend"
2415  * is *two* devices in Asterisk, not one.
2416  *
2417  * Thought: For realtime, we should propably update storage with inuse counter... 
2418  *
2419  * \return 0 if call is ok (no call limit, below treshold)
2420  *      -1 on rejection of call
2421  *              
2422  */
2423 static int update_call_counter(struct sip_pvt *fup, int event)
2424 {
2425         char name[256];
2426         int *inuse, *call_limit;
2427         int outgoing = ast_test_flag(&fup->flags[0], SIP_OUTGOING);
2428         struct sip_user *u = NULL;
2429         struct sip_peer *p = NULL;
2430
2431         if (option_debug > 2)
2432                 ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
2433         /* Test if we need to check call limits, in order to avoid 
2434            realtime lookups if we do not need it */
2435         if (!ast_test_flag(&fup->flags[0], SIP_CALL_LIMIT))
2436                 return 0;
2437
2438         ast_copy_string(name, fup->username, sizeof(name));
2439
2440         /* Check the list of users */
2441         if (!outgoing)  /* Only check users for incoming calls */
2442                 u = find_user(name, 1);
2443
2444         if (u) {
2445                 inuse = &u->inUse;
2446                 call_limit = &u->call_limit;
2447                 p = NULL;
2448         } else {
2449                 /* Try to find peer */
2450                 if (!p)
2451                         p = find_peer(fup->peername, NULL, 1);
2452                 if (p) {
2453                         inuse = &p->inUse;
2454                         call_limit = &p->call_limit;
2455                         ast_copy_string(name, fup->peername, sizeof(name));
2456                 } else {
2457                         if (option_debug > 1)
2458                                 ast_log(LOG_DEBUG, "%s is not a local user, no call limit\n", name);
2459                         return 0;
2460                 }
2461         }
2462         switch(event) {
2463                 /* incoming and outgoing affects the inUse counter */
2464                 case DEC_CALL_LIMIT:
2465                         if ( *inuse > 0 ) {
2466                                 if (ast_test_flag(&fup->flags[0], SIP_INC_COUNT))
2467                                         (*inuse)--;
2468                         } else {
2469                                 *inuse = 0;
2470                         }
2471                         if (option_debug > 1 || sipdebug) {
2472                                 ast_log(LOG_DEBUG, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
2473                         }
2474                         break;
2475                 case INC_CALL_LIMIT:
2476                         if (*call_limit > 0 ) {
2477                                 if (*inuse >= *call_limit) {
2478                                         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);
2479                                         if (u)
2480                                                 ASTOBJ_UNREF(u, sip_destroy_user);
2481                                         else
2482                                                 ASTOBJ_UNREF(p, sip_destroy_peer);
2483                                         return -1; 
2484                                 }
2485                         }
2486                         (*inuse)++;
2487                         ast_set_flag(&fup->flags[0], SIP_INC_COUNT);
2488                         if (option_debug > 1 || sipdebug) {
2489                                 ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
2490                         }
2491                         break;
2492                 default:
2493                         ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
2494         }
2495         if (u)
2496                 ASTOBJ_UNREF(u, sip_destroy_user);
2497         else
2498                 ASTOBJ_UNREF(p, sip_destroy_peer);
2499         return 0;
2500 }
2501
2502 /*! \brief Destroy SIP call structure */
2503 static void sip_destroy(struct sip_pvt *p)
2504 {
2505         ast_mutex_lock(&iflock);
2506         if (option_debug > 2)
2507                 ast_log(LOG_DEBUG, "Destroying SIP dialog %s\n", p->callid);
2508         __sip_destroy(p, 1);
2509         ast_mutex_unlock(&iflock);
2510 }
2511
2512 /*! \brief Convert SIP hangup causes to Asterisk hangup causes */
2513 static int hangup_sip2cause(int cause)
2514 {
2515         /* Possible values taken from causes.h */
2516
2517         switch(cause) {
2518                 case 401:       /* Unauthorized */
2519                         return AST_CAUSE_CALL_REJECTED;
2520                 case 403:       /* Not found */
2521                         return AST_CAUSE_CALL_REJECTED;
2522                 case 404:       /* Not found */
2523                         return AST_CAUSE_UNALLOCATED;
2524                 case 405:       /* Method not allowed */
2525                         return AST_CAUSE_INTERWORKING;
2526                 case 407:       /* Proxy authentication required */
2527                         return AST_CAUSE_CALL_REJECTED;
2528                 case 408:       /* No reaction */
2529                         return AST_CAUSE_NO_USER_RESPONSE;
2530                 case 409:       /* Conflict */
2531                         return AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
2532                 case 410:       /* Gone */
2533                         return AST_CAUSE_UNALLOCATED;
2534                 case 411:       /* Length required */
2535                         return AST_CAUSE_INTERWORKING;
2536                 case 413:       /* Request entity too large */
2537                         return AST_CAUSE_INTERWORKING;
2538                 case 414:       /* Request URI too large */
2539                         return AST_CAUSE_INTERWORKING;
2540                 case 415:       /* Unsupported media type */
2541                         return AST_CAUSE_INTERWORKING;
2542                 case 420:       /* Bad extension */
2543                         return AST_CAUSE_NO_ROUTE_DESTINATION;
2544                 case 480:       /* No answer */
2545                         return AST_CAUSE_FAILURE;
2546                 case 481:       /* No answer */
2547                         return AST_CAUSE_INTERWORKING;
2548                 case 482:       /* Loop detected */
2549                         return AST_CAUSE_INTERWORKING;
2550                 case 483:       /* Too many hops */
2551                         return AST_CAUSE_NO_ANSWER;
2552                 case 484:       /* Address incomplete */
2553                         return AST_CAUSE_INVALID_NUMBER_FORMAT;
2554                 case 485:       /* Ambigous */
2555                         return AST_CAUSE_UNALLOCATED;
2556                 case 486:       /* Busy everywhere */
2557                         return AST_CAUSE_BUSY;
2558                 case 487:       /* Request terminated */
2559                         return AST_CAUSE_INTERWORKING;
2560                 case 488:       /* No codecs approved */
2561                         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2562                 case 491:       /* Request pending */
2563                         return AST_CAUSE_INTERWORKING;
2564                 case 493:       /* Undecipherable */
2565                         return AST_CAUSE_INTERWORKING;
2566                 case 500:       /* Server internal failure */
2567                         return AST_CAUSE_FAILURE;
2568                 case 501:       /* Call rejected */
2569                         return AST_CAUSE_FACILITY_REJECTED;
2570                 case 502:       
2571                         return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2572                 case 503:       /* Service unavailable */
2573                         return AST_CAUSE_CONGESTION;
2574                 case 504:       /* Gateway timeout */
2575                         return AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE;
2576                 case 505:       /* SIP version not supported */
2577                         return AST_CAUSE_INTERWORKING;
2578                 case 600:       /* Busy everywhere */
2579                         return AST_CAUSE_USER_BUSY;
2580                 case 603:       /* Decline */
2581                         return AST_CAUSE_CALL_REJECTED;
2582                 case 604:       /* Does not exist anywhere */
2583                         return AST_CAUSE_UNALLOCATED;
2584                 case 606:       /* Not acceptable */
2585                         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2586                 default:
2587                         return AST_CAUSE_NORMAL;
2588         }
2589         /* Never reached */
2590         return 0;
2591 }
2592
2593 /*! \brief Convert Asterisk hangup causes to SIP codes 
2594 \verbatim
2595  Possible values from causes.h
2596         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
2597         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
2598
2599         In addition to these, a lot of PRI codes is defined in causes.h 
2600         ...should we take care of them too ?
2601         
2602         Quote RFC 3398
2603
2604    ISUP Cause value                        SIP response
2605    ----------------                        ------------
2606    1  unallocated number                   404 Not Found
2607    2  no route to network                  404 Not found
2608    3  no route to destination              404 Not found
2609    16 normal call clearing                 --- (*)
2610    17 user busy                            486 Busy here
2611    18 no user responding                   408 Request Timeout
2612    19 no answer from the user              480 Temporarily unavailable
2613    20 subscriber absent                    480 Temporarily unavailable
2614    21 call rejected                        403 Forbidden (+)
2615    22 number changed (w/o diagnostic)      410 Gone
2616    22 number changed (w/ diagnostic)       301 Moved Permanently
2617    23 redirection to new destination       410 Gone
2618    26 non-selected user clearing           404 Not Found (=)
2619    27 destination out of order             502 Bad Gateway
2620    28 address incomplete                   484 Address incomplete
2621    29 facility rejected                    501 Not implemented
2622    31 normal unspecified                   480 Temporarily unavailable
2623 \endverbatim
2624 */
2625 static const char *hangup_cause2sip(int cause)
2626 {
2627         switch (cause) {
2628                 case AST_CAUSE_UNALLOCATED:             /* 1 */
2629                 case AST_CAUSE_NO_ROUTE_DESTINATION:    /* 3 IAX2: Can't find extension in context */
2630                 case AST_CAUSE_NO_ROUTE_TRANSIT_NET:    /* 2 */
2631                         return "404 Not Found";
2632                 case AST_CAUSE_CONGESTION:              /* 34 */
2633                 case AST_CAUSE_SWITCH_CONGESTION:       /* 42 */
2634                         return "503 Service Unavailable";
2635                 case AST_CAUSE_NO_USER_RESPONSE:        /* 18 */
2636                         return "408 Request Timeout";
2637                 case AST_CAUSE_NO_ANSWER:               /* 19 */
2638                         return "480 Temporarily unavailable";
2639                 case AST_CAUSE_CALL_REJECTED:           /* 21 */
2640                         return "403 Forbidden";
2641                 case AST_CAUSE_NUMBER_CHANGED:          /* 22 */
2642                         return "410 Gone";
2643                 case AST_CAUSE_NORMAL_UNSPECIFIED:      /* 31 */
2644                         return "480 Temporarily unavailable";
2645                 case AST_CAUSE_INVALID_NUMBER_FORMAT:
2646                         return "484 Address incomplete";
2647                 case AST_CAUSE_USER_BUSY:
2648                         return "486 Busy here";
2649                 case AST_CAUSE_FAILURE:
2650                         return "500 Server internal failure";
2651                 case AST_CAUSE_FACILITY_REJECTED:       /* 29 */
2652                         return "501 Not Implemented";
2653                 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
2654                         return "503 Service Unavailable";
2655                 /* Used in chan_iax2 */
2656                 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
2657                         return "502 Bad Gateway";
2658                 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:       /* Can't find codec to connect to host */
2659                         return "488 Not Acceptable Here";
2660                         
2661                 case AST_CAUSE_NOTDEFINED:
2662                 default:
2663                         ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
2664                         return NULL;
2665         }
2666
2667         /* Never reached */
2668         return 0;
2669 }
2670
2671
2672 /*! \brief  sip_hangup: Hangup SIP call
2673  * Part of PBX interface, called from ast_hangup */
2674 static int sip_hangup(struct ast_channel *ast)
2675 {
2676         struct sip_pvt *p = ast->tech_pvt;
2677         int needcancel = FALSE;
2678         struct ast_flags locflags = {0};
2679
2680         if (!p) {
2681                 ast_log(LOG_DEBUG, "Asked to hangup channel that was not connected\n");
2682                 return 0;
2683         }
2684         if (option_debug && sipdebug)
2685                 ast_log(LOG_DEBUG, "Hangup call %s, SIP callid %s)\n", ast->name, p->callid);
2686
2687         ast_mutex_lock(&p->lock);
2688         if (option_debug && sipdebug)
2689                 ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter on hangup\n", p->username);
2690         update_call_counter(p, DEC_CALL_LIMIT);
2691         /* Determine how to disconnect */
2692         if (p->owner != ast) {
2693                 ast_log(LOG_WARNING, "Huh?  We aren't the owner? Can't hangup call.\n");
2694                 ast_mutex_unlock(&p->lock);
2695                 return 0;
2696         }
2697         /* If the call is not UP, we need to send CANCEL instead of BYE */
2698         if (ast->_state != AST_STATE_UP)
2699                 needcancel = TRUE;
2700
2701         /* Disconnect */
2702         p = ast->tech_pvt;
2703         if (p->vad)
2704                 ast_dsp_free(p->vad);
2705
2706         p->owner = NULL;
2707         ast->tech_pvt = NULL;
2708
2709         ast_mutex_lock(&usecnt_lock);
2710         usecnt--;
2711         ast_mutex_unlock(&usecnt_lock);
2712         ast_update_use_count();
2713
2714         ast_set_flag(&locflags, SIP_NEEDDESTROY);       
2715
2716         /* Start the process if it's not already started */
2717         if (!ast_test_flag(&p->flags[0], SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
2718                 if (needcancel) {       /* Outgoing call, not up */
2719                         if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
2720                                 /* stop retransmitting an INVITE that has not received a response */
2721                                 __sip_pretend_ack(p);
2722
2723                                 /* Send a new request: CANCEL */
2724                                 transmit_request_with_auth(p, SIP_CANCEL, p->ocseq, XMIT_RELIABLE, 0);
2725                                 /* Actually don't destroy us yet, wait for the 487 on our original 
2726                                    INVITE, but do set an autodestruct just in case we never get it. */
2727                                 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
2728
2729                                 sip_scheddestroy(p, SIP_TRANS_TIMEOUT);
2730                                 if ( p->initid != -1 ) {
2731                                         /* channel still up - reverse dec of inUse counter
2732                                            only if the channel is not auto-congested */
2733                                         update_call_counter(p, INC_CALL_LIMIT);
2734                                 }
2735                         } else {        /* Incoming call, not up */
2736                                 const char *res;
2737                                 if (ast->hangupcause && (res = hangup_cause2sip(ast->hangupcause)))
2738                                         transmit_response_reliable(p, res, &p->initreq);
2739                                 else 
2740                                         transmit_response_reliable(p, "603 Declined", &p->initreq);
2741                         }
2742                 } else {        /* Call is in UP state, send BYE */
2743                         if (!p->pendinginvite) {
2744                                 /* Send a hangup */
2745                                 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
2746                         } else {
2747                                 /* Note we will need a BYE when this all settles out
2748                                    but we can't send one while we have "INVITE" outstanding. */
2749                                 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);     
2750                                 ast_clear_flag(&p->flags[0], SIP_NEEDREINVITE); 
2751                         }
2752                 }
2753         }
2754         ast_copy_flags(&p->flags[0], &locflags, SIP_NEEDDESTROY);       
2755         ast_mutex_unlock(&p->lock);
2756         return 0;
2757 }
2758
2759 /*! \brief Try setting codec suggested by the SIP_CODEC channel variable */
2760 static void try_suggested_sip_codec(struct sip_pvt *p)
2761 {
2762         int fmt;
2763         const char *codec;
2764
2765         codec = pbx_builtin_getvar_helper(p->owner, "SIP_CODEC");
2766         if (!codec) 
2767                 return;
2768
2769         fmt = ast_getformatbyname(codec);
2770         if (fmt) {
2771                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n", codec);
2772                 if (p->jointcapability & fmt) {
2773                         p->jointcapability &= fmt;
2774                         p->capability &= fmt;
2775                 } else
2776                         ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
2777         } else
2778                 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n", codec);
2779         return; 
2780 }
2781
2782 /*! \brief  sip_answer: Answer SIP call , send 200 OK on Invite 
2783  * Part of PBX interface */
2784 static int sip_answer(struct ast_channel *ast)
2785 {
2786         int res = 0;
2787         struct sip_pvt *p = ast->tech_pvt;
2788
2789         ast_mutex_lock(&p->lock);
2790         if (ast->_state != AST_STATE_UP) {
2791                 try_suggested_sip_codec(p);     
2792
2793                 ast_setstate(ast, AST_STATE_UP);
2794                 if (option_debug)
2795                         ast_log(LOG_DEBUG, "SIP answering channel: %s\n", ast->name);
2796                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL);
2797         }
2798         ast_mutex_unlock(&p->lock);
2799         return res;
2800 }
2801
2802 /*! \brief Send frame to media channel (rtp) */
2803 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
2804 {
2805         struct sip_pvt *p = ast->tech_pvt;
2806         int res = 0;
2807
2808         switch (frame->frametype) {
2809         case AST_FRAME_VOICE:
2810                 if (!(frame->subclass & ast->nativeformats)) {
2811                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
2812                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
2813                         return 0;
2814                 }
2815                 if (p) {
2816                         ast_mutex_lock(&p->lock);
2817                         if (p->rtp) {
2818                                 /* If channel is not up, activate early media session */
2819                                 if ((ast->_state != AST_STATE_UP) &&
2820                                     !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
2821                                     !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
2822                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
2823                                         ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);  
2824                                 }
2825                                 time(&p->lastrtptx);
2826                                 res =  ast_rtp_write(p->rtp, frame);
2827                         }
2828                         ast_mutex_unlock(&p->lock);
2829                 }
2830                 break;
2831         case AST_FRAME_VIDEO:
2832                 if (p) {
2833                         ast_mutex_lock(&p->lock);
2834                         if (p->vrtp) {
2835                                 /* Activate video early media */
2836                                 if ((ast->_state != AST_STATE_UP) &&
2837                                     !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
2838                                     !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
2839                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
2840                                         ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);  
2841                                 }
2842                                 time(&p->lastrtptx);
2843                                 res =  ast_rtp_write(p->vrtp, frame);
2844                         }
2845                         ast_mutex_unlock(&p->lock);
2846                 }
2847                 break;
2848         case AST_FRAME_IMAGE:
2849                 return 0;
2850                 break;
2851         default: 
2852                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
2853                 return 0;
2854         }
2855
2856         return res;
2857 }
2858
2859 /*! \brief  sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
2860         Basically update any ->owner links */
2861 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
2862 {
2863         int ret = -1;
2864         struct sip_pvt *p;
2865
2866         if (!newchan || !newchan->tech_pvt) {
2867                 ast_log(LOG_WARNING, "No SIP tech_pvt! Fixup of %s failed.\n", oldchan->name);
2868                 return -1;
2869         }
2870         p = newchan->tech_pvt;
2871
2872         ast_mutex_lock(&p->lock);
2873         append_history(p, "Masq", "Old channel: %s\n", oldchan->name);
2874         append_history(p, "Masq (cont)", "...new owner: %s\n", p->owner->name);
2875         if (p->owner != oldchan)
2876                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
2877         else {
2878                 p->owner = newchan;
2879                 ret = 0;
2880         }
2881         ast_mutex_unlock(&p->lock);
2882         return ret;
2883 }
2884
2885 /*! \brief Send DTMF character on SIP channel
2886         within one call, we're able to transmit in many methods simultaneously */
2887 static int sip_senddigit(struct ast_channel *ast, char digit)
2888 {
2889         struct sip_pvt *p = ast->tech_pvt;
2890         int res = 0;
2891
2892         ast_mutex_lock(&p->lock);
2893         switch (ast_test_flag(&p->flags[0], SIP_DTMF)) {
2894         case SIP_DTMF_INFO:
2895                 transmit_info_with_digit(p, digit);
2896                 break;
2897         case SIP_DTMF_RFC2833:
2898                 if (p->rtp)
2899                         ast_rtp_senddigit(p->rtp, digit);
2900                 break;
2901         case SIP_DTMF_INBAND:
2902                 res = -1;
2903                 break;
2904         }
2905         ast_mutex_unlock(&p->lock);
2906         return res;
2907 }
2908
2909 /*! \brief Transfer SIP call */
2910 static int sip_transfer(struct ast_channel *ast, const char *dest)
2911 {
2912         struct sip_pvt *p = ast->tech_pvt;
2913         int res;
2914
2915         ast_mutex_lock(&p->lock);
2916         if (ast->_state == AST_STATE_RING)
2917                 res = sip_sipredirect(p, dest);
2918         else
2919                 res = transmit_refer(p, dest);
2920         ast_mutex_unlock(&p->lock);
2921         return res;
2922 }
2923
2924 /*! \brief Play indication to user 
2925  * With SIP a lot of indications is sent as messages, letting the device play
2926    the indication - busy signal, congestion etc 
2927    \return -1 to force ast_indicate to send indication in audio, 0 if SIP can handle the indication by sending a message
2928 */
2929 static int sip_indicate(struct ast_channel *ast, int condition)
2930 {
2931         struct sip_pvt *p = ast->tech_pvt;
2932         int res = 0;
2933
2934         ast_mutex_lock(&p->lock);
2935         switch(condition) {
2936         case AST_CONTROL_RINGING:
2937                 if (ast->_state == AST_STATE_RING) {
2938                         if (!ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) ||
2939                             (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {                          
2940                                 /* Send 180 ringing if out-of-band seems reasonable */
2941                                 transmit_response(p, "180 Ringing", &p->initreq);
2942                                 ast_set_flag(&p->flags[0], SIP_RINGING);
2943                                 if (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
2944                                         break;
2945                         } else {
2946                                 /* Well, if it's not reasonable, just send in-band */
2947                         }
2948                 }
2949                 res = -1;
2950                 break;
2951         case AST_CONTROL_BUSY:
2952                 if (ast->_state != AST_STATE_UP) {
2953                         transmit_response(p, "486 Busy Here", &p->initreq);
2954                         ast_set_flag(&p->flags[0], SIP_ALREADYGONE);    
2955                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2956                         break;
2957                 }
2958                 res = -1;
2959                 break;
2960         case AST_CONTROL_CONGESTION:
2961                 if (ast->_state != AST_STATE_UP) {
2962                         transmit_response(p, "503 Service Unavailable", &p->initreq);
2963                         ast_set_flag(&p->flags[0], SIP_ALREADYGONE);    
2964                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2965                         break;
2966                 }
2967                 res = -1;
2968                 break;
2969         case AST_CONTROL_PROCEEDING:
2970                 if ((ast->_state != AST_STATE_UP) &&
2971                     !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
2972                     !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
2973                         transmit_response(p, "100 Trying", &p->initreq);
2974                         break;
2975                 }
2976                 res = -1;
2977                 break;
2978         case AST_CONTROL_PROGRESS:
2979                 if ((ast->_state != AST_STATE_UP) &&
2980                     !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
2981                     !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
2982                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
2983                         ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);  
2984                         break;
2985                 }
2986                 res = -1;
2987                 break;
2988         case AST_CONTROL_HOLD:  /* The other part of the bridge are put on hold */
2989                 if (sipdebug)
2990                         ast_log(LOG_DEBUG, "Bridged channel now on hold - %s\n", p->callid);
2991                 res = -1;
2992                 break;
2993         case AST_CONTROL_UNHOLD:        /* The other part of the bridge are back from hold */
2994                 if (sipdebug)
2995                         ast_log(LOG_DEBUG, "Bridged channel is back from hold, let's talk! : %s\n", p->callid);
2996                 res = -1;
2997                 break;
2998         case AST_CONTROL_VIDUPDATE:     /* Request a video frame update */
2999                 if (p->vrtp && !ast_test_flag(&p->flags[0], SIP_NOVIDEO)) {
3000                         transmit_info_with_vidupdate(p);
3001                         /* ast_rtcp_send_h261fur(p->vrtp); */
3002                         res = 0;
3003                 } else
3004                         res = -1;
3005                 break;
3006         case -1:
3007                 res = -1;
3008                 break;
3009         default:
3010                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
3011                 res = -1;
3012                 break;
3013         }
3014         ast_mutex_unlock(&p->lock);
3015         return res;
3016 }
3017
3018
3019
3020 /*! \brief Initiate a call in the SIP channel
3021         called from sip_request_call (calls from the pbx ) */
3022 static struct ast_channel *sip_new(struct sip_pvt *i, int state, const char *title)
3023 {
3024         struct ast_channel *tmp;
3025         struct ast_variable *v = NULL;
3026         int fmt;
3027         int what;
3028         
3029         ast_mutex_unlock(&i->lock);
3030         /* Don't hold a sip pvt lock while we allocate a channel */
3031         tmp = ast_channel_alloc(1);
3032         ast_mutex_lock(&i->lock);
3033         if (!tmp) {
3034                 ast_log(LOG_WARNING, "Unable to allocate SIP channel structure\n");
3035                 return NULL;
3036         }
3037         tmp->tech = &sip_tech;
3038         /* Select our native format based on codec preference until we receive
3039            something from another device to the contrary. */
3040         if (i->jointcapability)
3041                 what = i->jointcapability;
3042         else if (i->capability)
3043                 what = i->capability;
3044         else
3045                 what = global_capability;
3046         tmp->nativeformats = ast_codec_choose(&i->prefs, what, 1) | (i->jointcapability & AST_FORMAT_VIDEO_MASK);
3047         fmt = ast_best_codec(tmp->nativeformats);
3048
3049         if (title)
3050                 ast_string_field_build(tmp, name, "SIP/%s-%04lx", title, ast_random() & 0xffff);
3051         else if (strchr(i->fromdomain,':'))
3052                 ast_string_field_build(tmp, name, "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
3053         else
3054                 ast_string_field_build(tmp, name, "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
3055
3056         if (ast_test_flag(&i->flags[0], SIP_DTMF) ==  SIP_DTMF_INBAND) {
3057                 i->vad = ast_dsp_new();
3058                 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
3059                 if (global_relaxdtmf)
3060                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
3061         }
3062         if (i->rtp) {
3063                 tmp->fds[0] = ast_rtp_fd(i->rtp);
3064                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
3065         }
3066         if (i->vrtp) {
3067                 tmp->fds[2] = ast_rtp_fd(i->vrtp);
3068                 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
3069         }
3070         if (state == AST_STATE_RING)
3071                 tmp->rings = 1;
3072         tmp->adsicpe = AST_ADSI_UNAVAILABLE;
3073         tmp->writeformat = fmt;
3074         tmp->rawwriteformat = fmt;
3075         tmp->readformat = fmt;
3076         tmp->rawreadformat = fmt;
3077         tmp->tech_pvt = i;
3078
3079         tmp->callgroup = i->callgroup;
3080         tmp->pickupgroup = i->pickupgroup;
3081         tmp->cid.cid_pres = i->callingpres;
3082         if (!ast_strlen_zero(i->accountcode))
3083                 ast_string_field_set(tmp, accountcode, i->accountcode);
3084         if (i->amaflags)
3085                 tmp->amaflags = i->amaflags;
3086         if (!ast_strlen_zero(i->language))
3087                 ast_string_field_set(tmp, language, i->language);
3088         if (!ast_strlen_zero(i->musicclass))
3089                 ast_string_field_set(tmp, musicclass, i->musicclass);
3090         i->owner = tmp;
3091         ast_mutex_lock(&usecnt_lock);
3092         usecnt++;
3093         ast_mutex_unlock(&usecnt_lock);
3094         ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
3095         ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
3096         if (!ast_strlen_zero(i->cid_num)) 
3097                 tmp->cid.cid_num = ast_strdup(i->cid_num);
3098         if (!ast_strlen_zero(i->cid_name))
3099                 tmp->cid.cid_name = ast_strdup(i->cid_name);
3100         if (!ast_strlen_zero(i->rdnis))
3101                 tmp->cid.cid_rdnis = ast_strdup(i->rdnis);
3102         if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
3103                 tmp->cid.cid_dnid = ast_strdup(i->exten);
3104         tmp->priority = 1;
3105         if (!ast_strlen_zero(i->uri))
3106                 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
3107         if (!ast_strlen_zero(i->domain))
3108                 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
3109         if (!ast_strlen_zero(i->useragent))
3110                 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
3111         if (!ast_strlen_zero(i->callid))
3112                 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
3113         ast_setstate(tmp, state);
3114         if (state != AST_STATE_DOWN && ast_pbx_start(tmp)) {
3115                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
3116                 tmp->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
3117                 ast_hangup(tmp);
3118                 tmp = NULL;
3119         }
3120         /* Set channel variables for this call from configuration */
3121         for (v = i->chanvars ; v ; v = v->next)
3122                 pbx_builtin_setvar_helper(tmp,v->name,v->value);
3123
3124         if (recordhistory)
3125                 append_history(i, "NewChan", "Channel %s - from %s", tmp->name, i->callid);
3126                                 
3127         return tmp;
3128 }
3129
3130 /*! \brief Reads one line of SIP message body */
3131 static const char* get_sdp_by_line(const char* line, const char *name, int nameLen)
3132 {
3133         if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=')
3134                 return ast_skip_blanks(line + nameLen + 1);
3135         return "";
3136 }
3137
3138 /*! \brief get_sdp_iterate: lookup 'name' in the request starting
3139  * at the 'start' line. Returns the matching line, and 'start'
3140  * is updated with the next line number.
3141  */
3142 static const char* get_sdp_iterate(int* start,
3143                              struct sip_request *req, const char *name)
3144 {
3145         int len = strlen(name);
3146
3147         while (*start < req->lines) {
3148                 const char *r = get_sdp_by_line(req->line[(*start)++], name, len);
3149                 if (r[0] != '\0')
3150                         return r;
3151         }
3152         return "";
3153 }
3154
3155 /*! \brief  get_sdp: Gets all kind of SIP message bodies, including SDP,
3156    but the name wrongly applies _only_ sdp */
3157 static const char *get_sdp(struct sip_request *req, const char *name) 
3158 {
3159         int dummy = 0;
3160         return get_sdp_iterate(&dummy, req, name);
3161 }
3162
3163 static const char *find_alias(const char *name, const char *_default)
3164 {
3165         /*! \brief Structure for conversion between compressed SIP and "normal" SIP */
3166         static const struct cfalias {
3167                 char * const fullname;
3168                 char * const shortname;
3169         } aliases[] = {
3170                 { "Content-Type", "c" },
3171                 { "Content-Encoding", "e" },
3172                 { "From", "f" },
3173                 { "Call-ID", "i" },
3174                 { "Contact", "m" },
3175                 { "Content-Length", "l" },
3176                 { "Subject", "s" },
3177                 { "To", "t" },
3178                 { "Supported", "k" },
3179                 { "Refer-To", "r" },
3180                 { "Referred-By", "b" },
3181                 { "Allow-Events", "u" },
3182                 { "Event", "o" },
3183                 { "Via", "v" },
3184                 { "Accept-Contact",      "a" },
3185                 { "Reject-Contact",      "j" },
3186                 { "Request-Disposition", "d" },
3187                 { "Session-Expires",     "x" },
3188         };
3189         int x;
3190         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++) 
3191                 if (!strcasecmp(aliases[x].fullname, name))
3192                         return aliases[x].shortname;
3193         return _default;
3194 }
3195
3196 static const char *__get_header(const struct sip_request *req, const char *name, int *start)
3197 {
3198         int pass;
3199
3200         /*
3201          * Technically you can place arbitrary whitespace both before and after the ':' in
3202          * a header, although RFC3261 clearly says you shouldn't before, and place just
3203          * one afterwards.  If you shouldn't do it, what absolute idiot decided it was 
3204          * a good idea to say you can do it, and if you can do it, why in the hell would.
3205          * you say you shouldn't.
3206          * Anyways, pedanticsipchecking controls whether we allow spaces before ':',
3207          * and we always allow spaces after that for compatibility.
3208          */
3209         for (pass = 0; name && pass < 2;pass++) {
3210                 int x, len = strlen(name);
3211                 for (x=*start; x<req->headers; x++) {
3212                         if (!strncasecmp(req->header[x], name, len)) {
3213                                 char *r = req->header[x] + len; /* skip name */
3214                                 if (pedanticsipchecking)
3215                                         r = ast_skip_blanks(r);
3216
3217                                 if (*r == ':') {
3218                                         *start = x+1;
3219                                         return ast_skip_blanks(r+1);
3220                                 }
3221                         }
3222                 }
3223                 if (pass == 0) /* Try aliases */
3224                         name = find_alias(name, NULL);
3225         }
3226
3227         /* Don't return NULL, so get_header is always a valid pointer */
3228         return "";
3229 }
3230
3231 /*! \brief Get header from SIP request */
3232 static const char *get_header(const struct sip_request *req, const char *name)
3233 {
3234         int start = 0;
3235         return __get_header(req, name, &start);
3236 }
3237
3238 /*! \brief Read RTP from network */
3239 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
3240 {
3241         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
3242         struct ast_frame *f;
3243         
3244         if (!p->rtp) {
3245                 /* We have no RTP allocated for this channel */
3246                 return &ast_null_frame;
3247         }
3248
3249         switch(ast->fdno) {
3250         case 0:
3251                 f = ast_rtp_read(p->rtp);       /* RTP Audio */
3252                 break;
3253         case 1:
3254                 f = ast_rtcp_read(p->rtp);      /* RTCP Control Channel */
3255                 break;
3256         case 2:
3257                 f = ast_rtp_read(p->vrtp);      /* RTP Video */
3258                 break;
3259         case 3:
3260                 f = ast_rtcp_read(p->vrtp);     /* RTCP Control Channel for video */
3261                 break;
3262         default:
3263                 f = &ast_null_frame;
3264         }
3265         /* Don't forward RFC2833 if we're not supposed to */
3266         if (f && (f->frametype == AST_FRAME_DTMF) &&
3267             (ast_test_flag(&p->flags[0], SIP_DTMF) != SIP_DTMF_RFC2833))
3268                 return &ast_null_frame;
3269
3270         if (p->owner) {
3271                 /* We already hold the channel lock */
3272                 if (f->frametype == AST_FRAME_VOICE) {
3273                         if (f->subclass != (p->owner->nativeformats & AST_FORMAT_AUDIO_MASK)) {
3274                                 if (option_debug)
3275                                         ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
3276                                 p->owner->nativeformats = (p->owner->nativeformats & AST_FORMAT_VIDEO_MASK) | f->subclass;
3277                                 ast_set_read_format(p->owner, p->owner->readformat);
3278                                 ast_set_write_format(p->owner, p->owner->writeformat);
3279                         }
3280                         if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
3281                                 f = ast_dsp_process(p->owner, p->vad, f);
3282                                 if (option_debug && f && (f->frametype == AST_FRAME_DTMF)) 
3283                                         ast_log(LOG_DEBUG, "* Detected inband DTMF '%c'\n", f->subclass);
3284                         }
3285                 }
3286         }
3287         return f;
3288 }
3289
3290 /*! \brief Read SIP RTP from channel */
3291 static struct ast_frame *sip_read(struct ast_channel *ast)
3292 {
3293         struct ast_frame *fr;
3294         struct sip_pvt *p = ast->tech_pvt;
3295
3296         ast_mutex_lock(&p->lock);
3297         fr = sip_rtp_read(ast, p);
3298         time(&p->lastrtprx);
3299         ast_mutex_unlock(&p->lock);
3300         return fr;
3301 }
3302
3303
3304 /*! \brief Generate 32 byte random string for callid's etc */
3305 static char *generate_random_string(char *buf, size_t size)
3306 {
3307         long val[4];
3308         int x;
3309
3310         for (x=0; x<4; x++)
3311                 val[x] = ast_random();
3312         snprintf(buf, size, "%08lx%08lx%08lx%08lx", val[0], val[1], val[2], val[3]);
3313
3314         return buf;
3315 }
3316
3317 /*! \brief Build SIP Call-ID value for a non-REGISTER transaction */
3318 static void build_callid_pvt(struct sip_pvt *pvt)
3319 {
3320         char iabuf[INET_ADDRSTRLEN];
3321         char buf[33];
3322
3323         const char *host = S_OR(pvt->fromdomain, ast_inet_ntoa(iabuf, sizeof(iabuf), pvt->ourip));
3324         
3325         ast_string_field_build(pvt, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host);
3326
3327 }
3328
3329 /*! \brief Build SIP Call-ID value for a REGISTER transaction */
3330 static void build_callid_registry(struct sip_registry *reg, struct in_addr ourip, const char *fromdomain)
3331 {
3332         char iabuf[INET_ADDRSTRLEN];
3333         char buf[33];
3334
3335         const char *host = S_OR(fromdomain, ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
3336
3337         ast_string_field_build(reg, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host);
3338 }
3339
3340 /*! \brief Make our SIP dialog tag */
3341 static void make_our_tag(char *tagbuf, size_t len)
3342 {
3343         snprintf(tagbuf, len, "as%08lx", ast_random());
3344 }
3345
3346 /*! \brief Allocate SIP_PVT structure and set defaults */
3347 static struct sip_pvt *sip_alloc(ast_string_field callid, struct sockaddr_in *sin,
3348                                  int useglobal_nat, const int intended_method)
3349 {
3350         struct sip_pvt *p;
3351
3352         if (!(p = ast_calloc(1, sizeof(*p))))
3353                 return NULL;
3354
3355         if (ast_string_field_init(p, 512)) {
3356                 free(p);
3357                 return NULL;
3358         }
3359
3360         ast_mutex_init(&p->lock);
3361
3362         p->method = intended_method;
3363         p->initid = -1;
3364         p->autokillid = -1;
3365         p->subscribed = NONE;
3366         p->stateid = -1;
3367         p->prefs = default_prefs;               /* Set default codecs for this call */
3368
3369         if (intended_method != SIP_OPTIONS)     /* Peerpoke has it's own system */
3370                 p->timer_t1 = 500;      /* Default SIP retransmission timer T1 (RFC 3261) */
3371         if (sin) {
3372                 p->sa = *sin;
3373                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
3374                         p->ourip = __ourip;
3375         } else {
3376                 p->ourip = __ourip;
3377         }
3378         
3379         ast_copy_flags(&p->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
3380         ast_copy_flags(&p->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
3381
3382         p->branch = ast_random();       
3383         make_our_tag(p->tag, sizeof(p->tag));
3384         p->ocseq = INITIAL_CSEQ;
3385
3386         if (sip_methods[intended_method].need_rtp) {
3387                 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
3388                 if (ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT))
3389                         p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
3390                 if (!p->rtp || (ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) && !p->vrtp)) {
3391                         ast_log(LOG_WARNING, "Unable to create RTP audio %s session: %s\n",
3392                                 ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "and video" : "", strerror(errno));
3393                         ast_mutex_destroy(&p->lock);
3394                         if (p->chanvars) {
3395                                 ast_variables_destroy(p->chanvars);
3396                                 p->chanvars = NULL;
3397                         }
3398                         free(p);
3399                         return NULL;
3400                 }
3401                 ast_rtp_settos(p->rtp, global_tos_audio);
3402                 if (p->vrtp)
3403                         ast_rtp_settos(p->vrtp, global_tos_video);
3404                 p->rtptimeout = global_rtptimeout;
3405                 p->rtpholdtimeout = global_rtpholdtimeout;
3406                 p->rtpkeepalive = global_rtpkeepalive;
3407                 p->maxcallbitrate = default_maxcallbitrate;
3408         }
3409
3410         if (useglobal_nat && sin) {
3411                 int natflags;
3412                 /* Setup NAT structure according to global settings if we have an address */
3413                 ast_copy_flags(&p->flags[0], &global_flags[0], SIP_NAT);
3414                 p->recv = *sin;
3415                 natflags = ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE;
3416                 if (p->rtp)
3417                         ast_rtp_setnat(p->rtp, natflags);
3418                 if (p->vrtp)
3419                         ast_rtp_setnat(p->vrtp, natflags);
3420         }
3421
3422         if (p->method != SIP_REGISTER)
3423                 ast_string_field_set(p, fromdomain, default_fromdomain);
3424         build_via(p);
3425         if (!callid)
3426                 build_callid_pvt(p);
3427         else
3428                 ast_string_field_set(p, callid, callid);
3429         /* Assign default music on hold class */
3430         ast_string_field_set(p, musicclass, default_musicclass);
3431         p->capability = global_capability;
3432         p->allowtransfer = global_allowtransfer;
3433         if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
3434             (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
3435                 p->noncodeccapability |= AST_RTP_DTMF;
3436         ast_string_field_set(p, context, default_context);
3437
3438         /* Add to active dialog list */
3439         ast_mutex_lock(&iflock);
3440         p->next = iflist;
3441         iflist = p;
3442         ast_mutex_unlock(&iflock);
3443         if (option_debug)
3444                 ast_log(LOG_DEBUG, "Allocating new SIP dialog for %s - %s (%s)\n", callid ? callid : "(No Call-ID)", sip_methods[intended_method].text, p->rtp ? "With RTP" : "No RTP");
3445         return p;
3446 }
3447
3448 /*! \brief Connect incoming SIP message to current dialog or create new dialog structure
3449         Called by handle_request, sipsock_read */
3450 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
3451 {
3452         struct sip_pvt *p;
3453         char *tag = ""; /* note, tag is never NULL */
3454         char totag[128];
3455         char fromtag[128];
3456         const char *callid = get_header(req, "Call-ID");
3457         const char *from = get_header(req, "From");
3458         const char *to = get_header(req, "To");
3459         const char *cseq = get_header(req, "Cseq");
3460
3461         if (!callid || !to || !from || !cseq)           /* Call-ID, to, from and Cseq are required by RFC 3261. (Max-forwards and via too - ignored now) */
3462                 return NULL;    /* Invalid packet */
3463
3464         if (pedanticsipchecking) {
3465                 /* In principle Call-ID's uniquely identify a call, but with a forking SIP proxy
3466                    we need more to identify a branch - so we have to check branch, from
3467                    and to tags to identify a call leg.
3468                    For Asterisk to behave correctly, you need to turn on pedanticsipchecking
3469                    in sip.conf
3470                    */
3471                 if (gettag(req, "To", totag, sizeof(totag)))
3472                         ast_set_flag(req, SIP_PKT_WITH_TOTAG);  /* Used in handle_request/response */
3473                 gettag(req, "From", fromtag, sizeof(fromtag));
3474
3475                 tag = (req->method == SIP_RESPONSE) ? totag : fromtag;
3476
3477